Google Git
Sign in
chromium / chromium / src.git / main / . / chrome / browser / ui / toolbar / toolbar_actions_model_unittest.cc
blob: 505ed40f27a0a63ab32ec6f94914fce64f6e0ce7 [file] [log] [blame]
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ui/toolbar/toolbar_actions_model.h"
#include <stddef.h>
#include <array>
#include <memory>
#include <string>
#include "base/containers/contains.h"
#include "base/files/file_util.h"
#include "base/functional/callback.h"
#include "base/functional/callback_helpers.h"
#include "base/json/json_reader.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/ref_counted.h"
#include "base/run_loop.h"
#include "base/strings/stringprintf.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/values.h"
#include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
#include "chrome/browser/extensions/extension_action_test_util.h"
#include "chrome/browser/extensions/extension_service_user_test_base.h"
#include "chrome/browser/extensions/extension_util.h"
#include "chrome/browser/extensions/test_extension_system.h"
#include "chrome/browser/extensions/unpacked_installer.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/ui/toolbar/test_toolbar_action_view_controller.h"
#include "chrome/common/pref_names.h"
#include "components/crx_file/id_util.h"
#include "components/policy/core/common/policy_map.h"
#include "components/prefs/scoped_user_pref_update.h"
#include "content/public/test/test_renderer_host.h"
#include "content/public/test/web_contents_tester.h"
#include "extensions/browser/extension_action_manager.h"
#include "extensions/browser/extension_prefs.h"
#include "extensions/browser/extension_registrar.h"
#include "extensions/browser/extension_registry.h"
#include "extensions/browser/extension_system.h"
#include "extensions/browser/pref_names.h"
#include "extensions/browser/test_extension_registry_observer.h"
#include "extensions/browser/uninstall_reason.h"
#include "extensions/common/api/extension_action/action_info.h"
#include "extensions/common/extension.h"
#include "extensions/common/extension_builder.h"
#include "extensions/common/extension_id.h"
#include "extensions/common/manifest.h"
#include "extensions/test/test_extension_dir.h"
#include "testing/gmock/include/gmock/gmock.h"
namespace {
using extensions::mojom::ManifestLocation;
// A simple observer that tracks the number of times certain events occur.
class ToolbarActionsModelTestObserver : public ToolbarActionsModel::Observer {
public:
explicit ToolbarActionsModelTestObserver(ToolbarActionsModel* model);
ToolbarActionsModelTestObserver(const ToolbarActionsModelTestObserver&) =
delete;
ToolbarActionsModelTestObserver& operator=(
const ToolbarActionsModelTestObserver&) = delete;
~ToolbarActionsModelTestObserver() override;
size_t inserted_count() const { return inserted_count_; }
size_t removed_count() const { return removed_count_; }
size_t initialized_count() const { return initialized_count_; }
const std::vector<ToolbarActionsModel::ActionId>& last_pinned_action_ids()
const {
return last_pinned_action_ids_;
}
private:
// ToolbarActionsModel::Observer:
void OnToolbarActionAdded(
const ToolbarActionsModel::ActionId& action_id) override {
++inserted_count_;
}
void OnToolbarActionRemoved(
const ToolbarActionsModel::ActionId& id) override {
++removed_count_;
}
void OnToolbarActionUpdated(
const ToolbarActionsModel::ActionId& id) override {}
void OnToolbarModelInitialized() override { ++initialized_count_; }
void OnToolbarPinnedActionsChanged() override {
last_pinned_action_ids_ = model_->pinned_action_ids();
}
const raw_ptr<ToolbarActionsModel> model_;
size_t inserted_count_ = 0;
size_t removed_count_ = 0;
size_t initialized_count_ = 0;
std::vector<ToolbarActionsModel::ActionId> last_pinned_action_ids_;
};
ToolbarActionsModelTestObserver::ToolbarActionsModelTestObserver(
ToolbarActionsModel* model)
: model_(model) {
model_->AddObserver(this);
}
ToolbarActionsModelTestObserver::~ToolbarActionsModelTestObserver() {
model_->RemoveObserver(this);
}
} // namespace
class ToolbarActionsModelUnitTest
: public extensions::ExtensionServiceUserTestBase {
public:
ToolbarActionsModelUnitTest() = default;
ToolbarActionsModelUnitTest(const ToolbarActionsModelUnitTest&) = delete;
ToolbarActionsModelUnitTest& operator=(const ToolbarActionsModelUnitTest&) =
delete;
~ToolbarActionsModelUnitTest() override = default;
protected:
// Initialize the ExtensionService, ToolbarActionsModel, and ExtensionSystem.
void Init();
void InitToolbarModelAndObserver();
void TearDown() override;
// Adds or removes the given |extension| and verify success.
[[nodiscard]] testing::AssertionResult AddExtension(
const scoped_refptr<const extensions::Extension>& extension);
[[nodiscard]] testing::AssertionResult RemoveExtension(
const scoped_refptr<const extensions::Extension>& extension);
// Adds three extensions, all with browser actions.
[[nodiscard]] testing::AssertionResult AddBrowserActionExtensions();
// Adds three extensions, one each for browser action, page action, and no
// action, and are added in that order.
[[nodiscard]] testing::AssertionResult AddActionExtensions();
// Returns true if the |toobar_model_| has an action with the given |id|.
bool ModelHasActionForId(const std::string& id) const;
// Test that certain histograms are emitted for user and non-user profiles
// (for ChromeOS Ash we look at user accounts vs profiles).
void RunEmitUserHistogramsTest(int incremented_histogram_count);
ToolbarActionsModel* toolbar_model() { return toolbar_model_; }
const ToolbarActionsModelTestObserver* observer() const {
return model_observer_.get();
}
size_t num_actions() const { return toolbar_model_->action_ids().size(); }
const extensions::Extension* browser_action_a() const {
return browser_action_a_.get();
}
const extensions::Extension* browser_action_b() const {
return browser_action_b_.get();
}
const extensions::Extension* browser_action_c() const {
return browser_action_c_.get();
}
const extensions::Extension* browser_action() const {
return browser_action_extension_.get();
}
const extensions::Extension* page_action() const {
return page_action_extension_.get();
}
const extensions::Extension* no_action() const {
return no_action_extension_.get();
}
private:
// Verifies that all extensions in |extensions| are added successfully.
testing::AssertionResult AddAndVerifyExtensions(
const extensions::ExtensionList& extensions);
// The toolbar model associated with the testing profile.
raw_ptr<ToolbarActionsModel> toolbar_model_;
// The test observer to track events. Must come after toolbar_model_ so that
// it is destroyed and removes itself as an observer first.
std::unique_ptr<ToolbarActionsModelTestObserver> model_observer_;
// Sample extensions with only browser actions.
scoped_refptr<const extensions::Extension> browser_action_a_;
scoped_refptr<const extensions::Extension> browser_action_b_;
scoped_refptr<const extensions::Extension> browser_action_c_;
// Sample extensions with different kinds of actions.
scoped_refptr<const extensions::Extension> browser_action_extension_;
scoped_refptr<const extensions::Extension> page_action_extension_;
scoped_refptr<const extensions::Extension> no_action_extension_;
};
void ToolbarActionsModelUnitTest::Init() {
InitializeEmptyExtensionService();
InitToolbarModelAndObserver();
}
void ToolbarActionsModelUnitTest::InitToolbarModelAndObserver() {
toolbar_model_ =
extensions::extension_action_test_util::CreateToolbarModelForProfile(
profile());
model_observer_ =
std::make_unique<ToolbarActionsModelTestObserver>(toolbar_model_);
}
void ToolbarActionsModelUnitTest::TearDown() {
model_observer_.reset();
extensions::ExtensionServiceUserTestBase::TearDown();
}
void ToolbarActionsModelUnitTest::RunEmitUserHistogramsTest(
int incremented_histogram_count) {
base::HistogramTester histograms;
InitToolbarModelAndObserver();
histograms.ExpectTotalCount("ExtensionToolbarModel.BrowserActionsCount", 1);
histograms.ExpectTotalCount("Extension.Toolbar.BrowserActionsCount2",
incremented_histogram_count);
}
testing::AssertionResult ToolbarActionsModelUnitTest::AddExtension(
const scoped_refptr<const extensions::Extension>& extension) {
if (registry()->enabled_extensions().GetByID(extension->id())) {
return testing::AssertionFailure()
<< "Extension " << extension->name() << " already installed!";
}
registrar()->AddExtension(extension.get());
if (!registry()->enabled_extensions().GetByID(extension->id())) {
return testing::AssertionFailure()
<< "Failed to install extension: " << extension->name();
}
return testing::AssertionSuccess();
}
testing::AssertionResult ToolbarActionsModelUnitTest::RemoveExtension(
const scoped_refptr<const extensions::Extension>& extension) {
if (!registry()->enabled_extensions().GetByID(extension->id())) {
return testing::AssertionFailure()
<< "Extension " << extension->name() << " not installed!";
}
registrar()->RemoveExtension(extension->id(),
extensions::UnloadedExtensionReason::DISABLE);
if (registry()->enabled_extensions().GetByID(extension->id())) {
return testing::AssertionFailure()
<< "Failed to unload extension: " << extension->name();
}
return testing::AssertionSuccess();
}
testing::AssertionResult ToolbarActionsModelUnitTest::AddActionExtensions() {
browser_action_extension_ =
extensions::ExtensionBuilder("browser_action")
.SetAction(extensions::ActionInfo::Type::kBrowser)
.SetLocation(ManifestLocation::kInternal)
.Build();
page_action_extension_ = extensions::ExtensionBuilder("page_action")
.SetAction(extensions::ActionInfo::Type::kPage)
.SetLocation(ManifestLocation::kInternal)
.Build();
no_action_extension_ = extensions::ExtensionBuilder("no_action")
.SetLocation(ManifestLocation::kInternal)
.Build();
extensions::ExtensionList extensions;
extensions.push_back(browser_action_extension_);
extensions.push_back(page_action_extension_);
extensions.push_back(no_action_extension_);
return AddAndVerifyExtensions(extensions);
}
testing::AssertionResult
ToolbarActionsModelUnitTest::AddBrowserActionExtensions() {
browser_action_a_ = extensions::ExtensionBuilder("browser_actionA")
.SetAction(extensions::ActionInfo::Type::kBrowser)
.SetLocation(ManifestLocation::kInternal)
.Build();
browser_action_b_ = extensions::ExtensionBuilder("browser_actionB")
.SetAction(extensions::ActionInfo::Type::kBrowser)
.SetLocation(ManifestLocation::kInternal)
.Build();
browser_action_c_ = extensions::ExtensionBuilder("browser_actionC")
.SetAction(extensions::ActionInfo::Type::kBrowser)
.SetLocation(ManifestLocation::kInternal)
.Build();
extensions::ExtensionList extensions;
extensions.push_back(browser_action_a_);
extensions.push_back(browser_action_b_);
extensions.push_back(browser_action_c_);
return AddAndVerifyExtensions(extensions);
}
bool ToolbarActionsModelUnitTest::ModelHasActionForId(
const std::string& id) const {
for (const auto& toolbar_action_id : toolbar_model_->action_ids()) {
if (toolbar_action_id == id) {
return true;
}
}
return false;
}
testing::AssertionResult ToolbarActionsModelUnitTest::AddAndVerifyExtensions(
const extensions::ExtensionList& extensions) {
for (const auto& extension : extensions) {
if (!AddExtension(extension)) {
return testing::AssertionFailure()
<< "Failed to install extension: " << extension->name();
}
}
return testing::AssertionSuccess();
}
// A basic test for extensions with browser actions showing up in the toolbar.
TEST_F(ToolbarActionsModelUnitTest, BasicToolbarActionsModelTest) {
Init();
// Starts empty.
EXPECT_EQ(0u, observer()->inserted_count());
EXPECT_THAT(toolbar_model()->action_ids(), ::testing::IsEmpty());
EXPECT_THAT(toolbar_model()->pinned_action_ids(), ::testing::IsEmpty());
// Load an extension with a browser action.
scoped_refptr<const extensions::Extension> extension =
extensions::ExtensionBuilder("browser_action")
.SetAction(extensions::ActionInfo::Type::kBrowser)
.SetLocation(ManifestLocation::kInternal)
.Build();
ASSERT_TRUE(AddExtension(extension));
// We should now find our extension in the model.
EXPECT_EQ(1u, observer()->inserted_count());
EXPECT_THAT(toolbar_model()->action_ids(),
::testing::UnorderedElementsAre(extension->id()));
// It should be unpinned.
EXPECT_THAT(toolbar_model()->pinned_action_ids(), ::testing::IsEmpty());
// Remove the extension and verify it is removed in the model.
ASSERT_TRUE(RemoveExtension(extension));
EXPECT_EQ(1u, observer()->removed_count());
EXPECT_THAT(toolbar_model()->action_ids(), ::testing::IsEmpty());
EXPECT_THAT(toolbar_model()->pinned_action_ids(), ::testing::IsEmpty());
}
// Test that new extension actions are always visible on installation and
// inserted at the "end" of the visible section.
TEST_F(ToolbarActionsModelUnitTest, NewToolbarExtensionsAreUnpinned) {
Init();
// Three extensions with actions.
scoped_refptr<const extensions::Extension> extension_a =
extensions::ExtensionBuilder("a")
.SetAction(extensions::ActionInfo::Type::kBrowser)
.SetLocation(ManifestLocation::kInternal)
.Build();
scoped_refptr<const extensions::Extension> extension_b =
extensions::ExtensionBuilder("b")
.SetAction(extensions::ActionInfo::Type::kBrowser)
.SetLocation(ManifestLocation::kInternal)
.Build();
scoped_refptr<const extensions::Extension> extension_c =
extensions::ExtensionBuilder("c")
.SetAction(extensions::ActionInfo::Type::kBrowser)
.SetLocation(ManifestLocation::kInternal)
.Build();
// We should start off without any actions.
EXPECT_EQ(0u, num_actions());
// Add one action. It should be unpinned.
EXPECT_TRUE(AddExtension(extension_a.get()));
EXPECT_EQ(1u, num_actions());
EXPECT_THAT(toolbar_model()->pinned_action_ids(), ::testing::IsEmpty());
// Add a second. It should also be unpinned (even with existing extensions,
// default state is unpinned).
EXPECT_TRUE(AddExtension(extension_b.get()));
EXPECT_EQ(2u, num_actions());
EXPECT_THAT(toolbar_model()->pinned_action_ids(), ::testing::IsEmpty());
// Pin the second. It should now be the only pinned icon.
toolbar_model()->SetActionVisibility(extension_b->id(), true);
EXPECT_EQ(2u, num_actions());
EXPECT_THAT(toolbar_model()->pinned_action_ids(),
::testing::ElementsAre(extension_b->id()));
// Add a third extension. It should be unpinned (pin state should not carry
// to new extensions).
EXPECT_TRUE(AddExtension(extension_c.get()));
EXPECT_EQ(3u, num_actions());
EXPECT_THAT(toolbar_model()->pinned_action_ids(),
::testing::ElementsAre(extension_b->id()));
}
// Test that the model contains all types of extensions, except those which
// should not be displayed on the toolbar (like component extensions).
TEST_F(ToolbarActionsModelUnitTest, TestToolbarExtensionTypesEnabledSwitch) {
Init();
ASSERT_TRUE(AddActionExtensions());
// extensions with page actions and no action should also be displayed in the
// toolbar.
EXPECT_THAT(
toolbar_model()->action_ids(),
testing::UnorderedElementsAre(browser_action()->id(), page_action()->id(),
no_action()->id()));
// Extensions that are installed by default shouldn't be given an icon.
auto default_installed_manifest =
base::Value::Dict()
.Set("name", "default installed")
.Set("description", "A default installed extension")
.Set("manifest_version", 2)
.Set("version", "1.0.0.0");
scoped_refptr<const extensions::Extension> default_installed_extension =
extensions::ExtensionBuilder()
.SetManifest(std::move(default_installed_manifest))
.SetID(crx_file::id_util::GenerateId("default"))
.SetLocation(ManifestLocation::kInternal)
.AddFlags(extensions::Extension::WAS_INSTALLED_BY_DEFAULT)
.Build();
EXPECT_TRUE(AddExtension(default_installed_extension.get()));
EXPECT_EQ(3u, num_actions());
EXPECT_FALSE(ModelHasActionForId(default_installed_extension->id()));
// Component extensions shouldn't be given an icon.
scoped_refptr<const extensions::Extension> component_extension_no_action =
extensions::ExtensionBuilder("component ext no action")
.SetLocation(ManifestLocation::kComponent)
.Build();
EXPECT_TRUE(AddExtension(component_extension_no_action.get()));
EXPECT_EQ(3u, num_actions());
EXPECT_FALSE(ModelHasActionForId(component_extension_no_action->id()));
// Sanity check: A new extension that's installed from the webstore should
// have an icon.
scoped_refptr<const extensions::Extension> internal_extension_no_action =
extensions::ExtensionBuilder("internal ext no action")
.SetLocation(ManifestLocation::kInternal)
.Build();
EXPECT_TRUE(AddExtension(internal_extension_no_action.get()));
EXPECT_EQ(4u, num_actions());
EXPECT_TRUE(ModelHasActionForId(internal_extension_no_action->id()));
}
TEST_F(ToolbarActionsModelUnitTest, PinnedStateIsTransferredToIncognito) {
Init();
ASSERT_TRUE(AddBrowserActionExtensions());
// Give two extensions incognito access.
// Note: We use ExtensionPrefs::SetIsIncognitoEnabled instead of
// util::SetIsIncognitoEnabled because the latter tries to reload the
// extension, which requries a filepath associated with the extension (and,
// for this test, reloading the extension is irrelevant to us).
extensions::ExtensionPrefs* extension_prefs =
extensions::ExtensionPrefs::Get(profile());
extension_prefs->SetIsIncognitoEnabled(browser_action_b()->id(), true);
extension_prefs->SetIsIncognitoEnabled(browser_action_c()->id(), true);
// Pin extensions A and C. State is A, C, [B].
toolbar_model()->SetActionVisibility(browser_action_a()->id(), true);
toolbar_model()->SetActionVisibility(browser_action_c()->id(), true);
EXPECT_THAT(toolbar_model()->pinned_action_ids(),
::testing::ElementsAre(browser_action_a()->id(),
browser_action_c()->id()));
// Get an incognito profile and toolbar.
ToolbarActionsModel* incognito_model =
extensions::extension_action_test_util::CreateToolbarModelForProfile(
profile()->GetPrimaryOTRProfile(/*create_if_needed=*/true));
// We should have two actions in the incognito bar, C and B. The pinned state
// should be preserved, so C should be pinned.
EXPECT_THAT(incognito_model->action_ids(),
::testing::ElementsAre(browser_action_b()->id(),
browser_action_c()->id()));
EXPECT_THAT(incognito_model->pinned_action_ids(),
::testing::ElementsAre(browser_action_c()->id()));
// Pinning from the original profile transfers to the incognito profile, so
// pinning B results in a change.
toolbar_model()->SetActionVisibility(browser_action_b()->id(), true);
EXPECT_THAT(incognito_model->pinned_action_ids(),
::testing::ElementsAre(browser_action_c()->id(),
browser_action_b()->id()));
// Similarly, unpinning C transfers to the incognito profile.
toolbar_model()->SetActionVisibility(browser_action_c()->id(), false);
EXPECT_THAT(incognito_model->pinned_action_ids(),
::testing::ElementsAre(browser_action_b()->id()));
}
TEST_F(ToolbarActionsModelUnitTest,
MovingPinnedActionsTransfersBetweenIncognito) {
Init();
ASSERT_TRUE(AddBrowserActionExtensions());
// Give all extensions incognito access.
// Note: We use ExtensionPrefs::SetIsIncognitoEnabled instead of
// util::SetIsIncognitoEnabled because the latter tries to reload the
// extension, which requires a filepath associated with the extension (and,
// for this test, reloading the extension is irrelevant to us).
extensions::ExtensionPrefs* extension_prefs =
extensions::ExtensionPrefs::Get(profile());
extension_prefs->SetIsIncognitoEnabled(browser_action_a()->id(), true);
extension_prefs->SetIsIncognitoEnabled(browser_action_b()->id(), true);
extension_prefs->SetIsIncognitoEnabled(browser_action_c()->id(), true);
// Pin all extensions, to allow moving them around.
toolbar_model()->SetActionVisibility(browser_action_a()->id(), true);
toolbar_model()->SetActionVisibility(browser_action_b()->id(), true);
toolbar_model()->SetActionVisibility(browser_action_c()->id(), true);
// Get an incognito profile and toolbar.
ToolbarActionsModel* incognito_model =
extensions::extension_action_test_util::CreateToolbarModelForProfile(
profile()->GetPrimaryOTRProfile(/*create_if_needed=*/true));
// The incognito pinned actions should be A, B, C (matching the order from
// the on-the-record profile).
EXPECT_THAT(
incognito_model->pinned_action_ids(),
::testing::ElementsAre(browser_action_a()->id(), browser_action_b()->id(),
browser_action_c()->id()));
// Moving extension C to index 0 affects both profiles.
toolbar_model()->MovePinnedAction(browser_action_c()->id(), 0);
EXPECT_THAT(
toolbar_model()->pinned_action_ids(),
::testing::ElementsAre(browser_action_c()->id(), browser_action_a()->id(),
browser_action_b()->id()));
EXPECT_THAT(
incognito_model->pinned_action_ids(),
::testing::ElementsAre(browser_action_c()->id(), browser_action_a()->id(),
browser_action_b()->id()));
}
// Test that enabling extensions incognito with an active incognito profile
// works.
TEST_F(ToolbarActionsModelUnitTest, ActionsToolbarIncognitoEnableExtension) {
Init();
static constexpr char kManifest[] =
"{"
" \"name\": \"%s\","
" \"version\": \"1.0\","
" \"manifest_version\": 2,"
" \"browser_action\": {}"
"}";
// For this test, we need to have "real" extension files, because we need to
// be able to reload them during the incognito process. Since the toolbar
// needs to be notified of the reload, we need it this time (as opposed to
// above, where we simply set the prefs before the incognito bar was
// created.
extensions::TestExtensionDir dir1;
dir1.WriteManifest(base::StringPrintf(kManifest, "incognito1"));
extensions::TestExtensionDir dir2;
dir2.WriteManifest(base::StringPrintf(kManifest, "incognito2"));
auto dirs = std::to_array<extensions::TestExtensionDir*>({&dir1, &dir2});
auto extensions =
std::to_array<const extensions::Extension*>({nullptr, nullptr});
for (size_t i = 0; i < std::size(dirs); ++i) {
// The extension id will be calculated from the file path; we need this to
// wait for the extension to load.
base::FilePath path_for_id =
base::MakeAbsoluteFilePath(dirs[i]->UnpackedPath());
std::string id = crx_file::id_util::GenerateIdForPath(path_for_id);
extensions::TestExtensionRegistryObserver observer(registry(), id);
extensions::UnpackedInstaller::Create(profile())->Load(
dirs[i]->UnpackedPath());
observer.WaitForExtensionLoaded();
extensions[i] = registry()->enabled_extensions().GetByID(id);
ASSERT_TRUE(extensions[i]);
}
// For readability, alias to A and B. Since we'll be reloading these
// extensions, we also can't rely on pointers.
std::string extension_a = extensions[0]->id();
std::string extension_b = extensions[1]->id();
// Pin Extension A in the on-the-record profile.
toolbar_model()->SetActionVisibility(extension_a, true);
EXPECT_THAT(toolbar_model()->pinned_action_ids(),
::testing::ElementsAre(extension_a));
// Get an incognito profile and toolbar.
ToolbarActionsModel* incognito_model =
extensions::extension_action_test_util::CreateToolbarModelForProfile(
profile()->GetPrimaryOTRProfile(/*create_if_needed=*/true));
ToolbarActionsModelTestObserver incognito_observer(incognito_model);
// Right now, no extensions are enabled in incognito mode.
EXPECT_THAT(incognito_model->action_ids(), ::testing::IsEmpty());
// Set extension B (which is unpinned) to be enabled in incognito. This
// results in b reloading, so wait for it.
{
extensions::TestExtensionRegistryObserver observer(registry(), extension_b);
extensions::util::SetIsIncognitoEnabled(extension_b, profile(), true);
observer.WaitForExtensionLoaded();
}
// Now, we should have one icon in the incognito bar. But, since B is
// unpinned in the main bar, it shouldn't be visible.
EXPECT_THAT(incognito_model->action_ids(),
::testing::ElementsAre(extension_b));
EXPECT_THAT(incognito_model->pinned_action_ids(), ::testing::IsEmpty());
// Also enable extension A for incognito (again, wait for the reload).
{
extensions::TestExtensionRegistryObserver observer(registry(), extension_a);
extensions::util::SetIsIncognitoEnabled(extension_a, profile(), true);
observer.WaitForExtensionLoaded();
}
// Now, both extensions should be enabled in incognito mode. Extension A
// should be pinned (since it's pinned in the main bar).
EXPECT_THAT(incognito_model->action_ids(),
::testing::UnorderedElementsAre(extension_a, extension_b));
EXPECT_THAT(incognito_model->pinned_action_ids(),
::testing::ElementsAre(extension_a));
}
// Test that observers receive no Added notifications until after the
// ExtensionSystem has initialized.
TEST_F(ToolbarActionsModelUnitTest, ModelWaitsForExtensionSystemReady) {
InitializeEmptyExtensionService();
ToolbarActionsModel* toolbar_model = extensions::extension_action_test_util::
CreateToolbarModelForProfileWithoutWaitingForReady(profile());
ToolbarActionsModelTestObserver model_observer(toolbar_model);
EXPECT_TRUE(AddBrowserActionExtensions());
// Since the model hasn't been initialized (the ExtensionSystem::ready task
// hasn't been run), there should be no insertion notifications.
EXPECT_EQ(0u, model_observer.inserted_count());
EXPECT_EQ(0u, model_observer.initialized_count());
EXPECT_FALSE(toolbar_model->actions_initialized());
// Run the ready task.
static_cast<extensions::TestExtensionSystem*>(
extensions::ExtensionSystem::Get(profile()))
->SetReady();
// Run tasks posted to TestExtensionSystem.
base::RunLoop().RunUntilIdle();
// We should still have no insertions, but should have an initialized count.
EXPECT_TRUE(toolbar_model->actions_initialized());
EXPECT_EQ(0u, model_observer.inserted_count());
EXPECT_EQ(1u, model_observer.initialized_count());
}
// Test that user-script extensions show up on the toolbar.
TEST_F(ToolbarActionsModelUnitTest, AddUserScriptExtension) {
Init();
scoped_refptr<const extensions::Extension> extension =
extensions::ExtensionBuilder("a")
.SetLocation(ManifestLocation::kInternal)
.MergeManifest(
base::Value::Dict().Set("converted_from_user_script", true))
.Build();
// We should start off without any actions.
EXPECT_EQ(0u, num_actions());
// Add the extension and verify it gets an icon.
EXPECT_TRUE(AddExtension(extension.get()));
EXPECT_THAT(toolbar_model()->action_ids(),
::testing::UnorderedElementsAre(extension->id()));
}
TEST_F(ToolbarActionsModelUnitTest, IsActionPinnedCorrespondsToPinningState) {
Init();
ASSERT_TRUE(AddBrowserActionExtensions());
// The actions should initially not be pinned.
EXPECT_FALSE(toolbar_model()->IsActionPinned(browser_action_a()->id()));
// Pinning is reflected in |IsActionPinned|.
toolbar_model()->SetActionVisibility(browser_action_a()->id(), true);
EXPECT_TRUE(toolbar_model()->IsActionPinned(browser_action_a()->id()));
// Removing pinning should also be reflected in |IsActionPinned|.
toolbar_model()->SetActionVisibility(browser_action_a()->id(), false);
EXPECT_FALSE(toolbar_model()->IsActionPinned(browser_action_a()->id()));
}
TEST_F(ToolbarActionsModelUnitTest,
TogglingVisibilityAppendsToPinnedExtensions) {
Init();
ASSERT_TRUE(AddBrowserActionExtensions());
EXPECT_THAT(toolbar_model()->pinned_action_ids(), testing::IsEmpty());
toolbar_model()->SetActionVisibility(browser_action_a()->id(), true);
EXPECT_THAT(toolbar_model()->pinned_action_ids(),
testing::ElementsAre(browser_action_a()->id()));
// Pin the remaining two extensions.
toolbar_model()->SetActionVisibility(browser_action_b()->id(), true);
toolbar_model()->SetActionVisibility(browser_action_c()->id(), true);
// Verify that they are added in order.
EXPECT_THAT(
toolbar_model()->pinned_action_ids(),
testing::ElementsAre(browser_action_a()->id(), browser_action_b()->id(),
browser_action_c()->id()));
// Verify that unpinning an extension updates the list of pinned ids.
toolbar_model()->SetActionVisibility(browser_action_b()->id(), false);
EXPECT_THAT(
toolbar_model()->pinned_action_ids(),
testing::ElementsAre(browser_action_a()->id(), browser_action_c()->id()));
// Verify that re-pinning an extension adds it back to the end of the list.
toolbar_model()->SetActionVisibility(browser_action_b()->id(), true);
EXPECT_THAT(
toolbar_model()->pinned_action_ids(),
testing::ElementsAre(browser_action_a()->id(), browser_action_c()->id(),
browser_action_b()->id()));
}
TEST_F(ToolbarActionsModelUnitTest, ChangesToPinningNotifiesObserver) {
Init();
ASSERT_TRUE(AddBrowserActionExtensions());
// The observer should not think that any extensions are initially pinned.
EXPECT_THAT(observer()->last_pinned_action_ids(), testing::IsEmpty());
// Verify that pinning the action notifies the observer.
toolbar_model()->SetActionVisibility(browser_action_a()->id(), true);
EXPECT_THAT(observer()->last_pinned_action_ids(),
testing::ElementsAre(browser_action_a()->id()));
// Verify that un-pinning an action also notifies the observer.
toolbar_model()->SetActionVisibility(browser_action_a()->id(), false);
EXPECT_THAT(observer()->last_pinned_action_ids(), testing::IsEmpty());
}
TEST_F(ToolbarActionsModelUnitTest, ChangesToPinningSavedInExtensionPrefs) {
Init();
ASSERT_TRUE(AddBrowserActionExtensions());
extensions::ExtensionPrefs* const extension_prefs =
extensions::ExtensionPrefs::Get(profile());
// The preferences shouldn't have any extensions initially pinned.
EXPECT_THAT(extension_prefs->GetPinnedExtensions(), testing::IsEmpty());
// Verify that pinned extensions are reflected in preferences.
toolbar_model()->SetActionVisibility(browser_action_a()->id(), true);
toolbar_model()->SetActionVisibility(browser_action_b()->id(), true);
toolbar_model()->SetActionVisibility(browser_action_c()->id(), true);
EXPECT_THAT(
extension_prefs->GetPinnedExtensions(),
testing::ElementsAre(browser_action_a()->id(), browser_action_b()->id(),
browser_action_c()->id()));
// Verify that un-pinning an action is also reflected in preferences.
toolbar_model()->SetActionVisibility(browser_action_b()->id(), false);
EXPECT_THAT(
extension_prefs->GetPinnedExtensions(),
testing::ElementsAre(browser_action_a()->id(), browser_action_c()->id()));
// Verify that re-pinning is added last.
toolbar_model()->SetActionVisibility(browser_action_b()->id(), true);
EXPECT_THAT(
extension_prefs->GetPinnedExtensions(),
testing::ElementsAre(browser_action_a()->id(), browser_action_c()->id(),
browser_action_b()->id()));
}
TEST_F(ToolbarActionsModelUnitTest, ChangesToExtensionPrefsReflectedInModel) {
Init();
ASSERT_TRUE(AddBrowserActionExtensions());
extensions::ExtensionPrefs* const extension_prefs =
extensions::ExtensionPrefs::Get(profile());
// No actions should be initially pinned.
EXPECT_THAT(toolbar_model()->pinned_action_ids(), testing::IsEmpty());
// Update preferences to indicate that extensions A and C are pinned.
extensions::ExtensionIdList pinned_extension_list = {
browser_action_a()->id(), browser_action_c()->id()};
// Verify that setting the extension preferences updates the model.
extension_prefs->SetPinnedExtensions(pinned_extension_list);
EXPECT_EQ(pinned_extension_list, extension_prefs->GetPinnedExtensions());
EXPECT_EQ(pinned_extension_list, toolbar_model()->pinned_action_ids());
// Verify that the observer is notified as well.
EXPECT_EQ(pinned_extension_list, observer()->last_pinned_action_ids());
}
TEST_F(ToolbarActionsModelUnitTest,
MismatchInPinnedExtensionPreferencesNotReflectedInModel) {
Init();
ASSERT_TRUE(AddBrowserActionExtensions());
extensions::ExtensionPrefs* const extension_prefs =
extensions::ExtensionPrefs::Get(profile());
// No actions should be initially pinned.
EXPECT_THAT(toolbar_model()->pinned_action_ids(), testing::IsEmpty());
// Update preferences to indicate that extensions A and C are pinned.
extensions::ExtensionIdList pinned_extension_list = {
browser_action_a()->id(), browser_action_c()->id()};
extensions::ExtensionIdList pinned_extension_list_with_additional_id =
pinned_extension_list;
pinned_extension_list_with_additional_id.push_back("bogus id");
// Verify that setting the extension preferences updates the model and that
// the additional extension id is filtered out in the model.
extension_prefs->SetPinnedExtensions(
pinned_extension_list_with_additional_id);
EXPECT_EQ(pinned_extension_list_with_additional_id,
extension_prefs->GetPinnedExtensions());
EXPECT_EQ(pinned_extension_list, toolbar_model()->pinned_action_ids());
// Verify that the observer is notified as well.
EXPECT_EQ(pinned_extension_list, observer()->last_pinned_action_ids());
}
TEST_F(ToolbarActionsModelUnitTest, PinnedExtensionsFilteredOnInitialization) {
Init();
ASSERT_TRUE(AddBrowserActionExtensions());
extensions::ExtensionPrefs* const extension_prefs =
extensions::ExtensionPrefs::Get(profile());
// Update preferences to indicate that extensions A and a "bogus id" one is
// set.
extensions::ExtensionIdList pinned_extension_list_with_additional_id = {
browser_action_a()->id(), "bogus id"};
extension_prefs->SetPinnedExtensions(
pinned_extension_list_with_additional_id);
// Create a model after setting the prefs, this is done to ensure that the
// pinned preferences are loaded and correctly filtered.
ToolbarActionsModel model_created_after_prefs_set(profile(), extension_prefs);
// Wait for load to happen (::OnReady is posted from ToolbarActionModel's
// constructor).
base::RunLoop().RunUntilIdle();
EXPECT_EQ(pinned_extension_list_with_additional_id,
extension_prefs->GetPinnedExtensions());
// Verify that the new model loads the same action_ids() and
// pinned_action_ids() from ExtensionPrefs that |toolbar_model()| should have
// saved.
EXPECT_EQ(toolbar_model()->pinned_action_ids(),
model_created_after_prefs_set.pinned_action_ids());
EXPECT_EQ(toolbar_model()->action_ids(),
model_created_after_prefs_set.action_ids());
// Verify that the new model's pinned action IDs have been pruned down to only
// extension a.
EXPECT_THAT(model_created_after_prefs_set.pinned_action_ids(),
testing::ElementsAre(browser_action_a()->id()));
}
TEST_F(ToolbarActionsModelUnitTest, ChangesToPinnedOrderSavedInExtensionPrefs) {
Init();
ASSERT_TRUE(AddBrowserActionExtensions());
extensions::ExtensionPrefs* const extension_prefs =
extensions::ExtensionPrefs::Get(profile());
// The preferences shouldn't have any extensions initially pinned.
EXPECT_THAT(extension_prefs->GetPinnedExtensions(), testing::IsEmpty());
// Verify that pinned extensions are reflected in preferences.
toolbar_model()->SetActionVisibility(browser_action_a()->id(), true);
toolbar_model()->SetActionVisibility(browser_action_b()->id(), true);
toolbar_model()->SetActionVisibility(browser_action_c()->id(), true);
EXPECT_THAT(
extension_prefs->GetPinnedExtensions(),
testing::ElementsAre(browser_action_a()->id(), browser_action_b()->id(),
browser_action_c()->id()));
// Verify that moving an action left to right is reflected in preferences.
// Note: Use index 1 (instead of 2) because moving to the end of the list
// is handled differently.
toolbar_model()->MovePinnedAction(browser_action_a()->id(), 1);
EXPECT_THAT(
extension_prefs->GetPinnedExtensions(),
testing::ElementsAre(browser_action_b()->id(), browser_action_a()->id(),
browser_action_c()->id()));
// Verify that moving an action right to left is reflected in preferences.
toolbar_model()->MovePinnedAction(browser_action_a()->id(), 0);
EXPECT_THAT(
extension_prefs->GetPinnedExtensions(),
testing::ElementsAre(browser_action_a()->id(), browser_action_b()->id(),
browser_action_c()->id()));
// Verify that moving an action to index greater than rightmost index is
// reflected in preferences as at the right end.
toolbar_model()->MovePinnedAction(browser_action_b()->id(), 4);
EXPECT_THAT(
extension_prefs->GetPinnedExtensions(),
testing::ElementsAre(browser_action_a()->id(), browser_action_c()->id(),
browser_action_b()->id()));
// "Moving" an icon to its current position should be a no-op.
toolbar_model()->MovePinnedAction(browser_action_c()->id(), 1);
EXPECT_THAT(
extension_prefs->GetPinnedExtensions(),
testing::ElementsAre(browser_action_a()->id(), browser_action_c()->id(),
browser_action_b()->id()));
// Repeat the above tests, but add in extra IDs into prefs (representing
// extensions that could be installed, but not loaded). These unloaded
// extensions' states should be preserved.
constexpr char kExtraId1[] = "extra1";
constexpr char kExtraId2[] = "extra2";
extension_prefs->SetPinnedExtensions({browser_action_a()->id(), kExtraId1,
kExtraId2, browser_action_c()->id(),
browser_action_b()->id()});
EXPECT_THAT(
toolbar_model()->pinned_action_ids(),
testing::ElementsAre(browser_action_a()->id(), browser_action_c()->id(),
browser_action_b()->id()));
// Move right to left.
toolbar_model()->MovePinnedAction(browser_action_c()->id(), 0);
EXPECT_THAT(
extension_prefs->GetPinnedExtensions(),
testing::ElementsAre(browser_action_c()->id(), browser_action_a()->id(),
kExtraId1, kExtraId2, browser_action_b()->id()));
// Move left to right.
toolbar_model()->MovePinnedAction(browser_action_c()->id(), 1);
EXPECT_THAT(
extension_prefs->GetPinnedExtensions(),
testing::ElementsAre(browser_action_a()->id(), kExtraId1, kExtraId2,
browser_action_c()->id(), browser_action_b()->id()));
// Move past the right-most index (of the visible actions).
toolbar_model()->MovePinnedAction(browser_action_a()->id(), 4);
EXPECT_THAT(
extension_prefs->GetPinnedExtensions(),
testing::ElementsAre(kExtraId1, kExtraId2, browser_action_c()->id(),
browser_action_b()->id(), browser_action_a()->id()));
// "Move" to the current position.
toolbar_model()->MovePinnedAction(browser_action_b()->id(), 1);
EXPECT_THAT(
extension_prefs->GetPinnedExtensions(),
testing::ElementsAre(kExtraId1, kExtraId2, browser_action_c()->id(),
browser_action_b()->id(), browser_action_a()->id()));
}
TEST_F(ToolbarActionsModelUnitTest, PinStateErasedOnUninstallation) {
Init();
scoped_refptr<const extensions::Extension> extension =
extensions::ExtensionBuilder("extension")
.SetAction(extensions::ActionInfo::Type::kBrowser)
.SetLocation(ManifestLocation::kInternal)
.Build();
// Add and pin an extension.
EXPECT_TRUE(AddExtension(extension));
EXPECT_FALSE(toolbar_model()->IsActionPinned(extension->id()));
extensions::ExtensionPrefs* const prefs =
extensions::ExtensionPrefs::Get(profile());
EXPECT_THAT(prefs->GetPinnedExtensions(), testing::IsEmpty());
toolbar_model()->SetActionVisibility(extension->id(), true);
EXPECT_TRUE(toolbar_model()->IsActionPinned(extension->id()));
EXPECT_THAT(prefs->GetPinnedExtensions(),
testing::ElementsAre(extension->id()));
// Uninstall the extension. The pin state should be forgotten.
registrar()->UninstallExtension(
extension->id(), extensions::UNINSTALL_REASON_FOR_TESTING, nullptr);
EXPECT_FALSE(toolbar_model()->IsActionPinned(extension->id()));
EXPECT_THAT(prefs->GetPinnedExtensions(), testing::IsEmpty());
// Re-add the extension. It should be in the default (unpinned) state.
EXPECT_TRUE(AddExtension(extension));
EXPECT_FALSE(toolbar_model()->IsActionPinned(extension->id()));
EXPECT_THAT(prefs->GetPinnedExtensions(), testing::IsEmpty());
}
TEST_F(ToolbarActionsModelUnitTest, ForcePinnedByPolicy) {
Init();
// Set the extension to force-pin via enterprise policy.
std::string extension_id = crx_file::id_util::GenerateId("qwertyuiop");
std::string json = base::StringPrintf(
R"({
"%s": {
"toolbar_pin": "force_pinned"
}
})",
extension_id.c_str());
std::optional<base::Value> parsed = base::JSONReader::Read(json);
policy::PolicyMap map;
map.Set("ExtensionSettings", policy::POLICY_LEVEL_MANDATORY,
policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_PLATFORM,
std::move(parsed), nullptr);
policy_provider()->UpdateChromePolicy(map);
scoped_refptr<const extensions::Extension> extension =
extensions::ExtensionBuilder("test")
.SetAction(extensions::ActionInfo::Type::kBrowser)
.SetLocation(ManifestLocation::kInternal)
.SetID(extension_id)
.Build();
// Add an extension. It should auto-pin because of the ExtensionSettings
// policy.
EXPECT_TRUE(AddExtension(extension));
EXPECT_TRUE(toolbar_model()->IsActionPinned(extension->id()));
auto* prefs = extensions::ExtensionPrefs::Get(profile());
EXPECT_FALSE(base::Contains(prefs->GetPinnedExtensions(), extension_id));
// Pin all other extensions, to allow moving them around.
ASSERT_TRUE(AddBrowserActionExtensions());
const auto& id_a = browser_action_a()->id();
const auto& id_b = browser_action_b()->id();
const auto& id_c = browser_action_c()->id();
toolbar_model()->SetActionVisibility(id_a, true);
toolbar_model()->SetActionVisibility(id_b, true);
toolbar_model()->SetActionVisibility(id_c, true);
// Force-pinned extensions aren't saved in the pref.
EXPECT_THAT(prefs->GetPinnedExtensions(),
testing::ElementsAre(id_a, id_b, id_c));
EXPECT_THAT(toolbar_model()->pinned_action_ids(),
testing::ElementsAre(id_a, id_b, id_c, extension_id));
// Try to move the force-pinned extension. This shouldn't do anything because
// they can't be moved. See crbug.com/1266952.
toolbar_model()->MovePinnedAction(extension_id, 1);
EXPECT_THAT(prefs->GetPinnedExtensions(),
testing::ElementsAre(id_a, id_b, id_c));
EXPECT_THAT(toolbar_model()->pinned_action_ids(),
testing::ElementsAre(id_a, id_b, id_c, extension_id));
// Try to move other extensions. This should work fine.
toolbar_model()->MovePinnedAction(id_a, 1);
EXPECT_THAT(prefs->GetPinnedExtensions(),
testing::ElementsAre(id_b, id_a, id_c));
EXPECT_THAT(toolbar_model()->pinned_action_ids(),
testing::ElementsAre(id_b, id_a, id_c, extension_id));
toolbar_model()->MovePinnedAction(id_a, 2);
EXPECT_THAT(prefs->GetPinnedExtensions(),
testing::ElementsAre(id_b, id_c, id_a));
EXPECT_THAT(toolbar_model()->pinned_action_ids(),
testing::ElementsAre(id_b, id_c, id_a, extension_id));
toolbar_model()->MovePinnedAction(id_a, 0);
EXPECT_THAT(prefs->GetPinnedExtensions(),
testing::ElementsAre(id_a, id_b, id_c));
EXPECT_THAT(toolbar_model()->pinned_action_ids(),
testing::ElementsAre(id_a, id_b, id_c, extension_id));
// Try to move an extension to the right of the force-pinned one. This will
// not work, and the force-pinned one will stay to the right. But the other
// extension will still get moved as far right as it can.
toolbar_model()->MovePinnedAction(id_a, 3);
EXPECT_THAT(prefs->GetPinnedExtensions(),
testing::ElementsAre(id_b, id_c, id_a));
EXPECT_THAT(toolbar_model()->pinned_action_ids(),
testing::ElementsAre(id_b, id_c, id_a, extension_id));
// Again, but using an index greater than the rightmost index (mostly to check
// for crashes).
toolbar_model()->MovePinnedAction(id_a, 0);
EXPECT_THAT(prefs->GetPinnedExtensions(),
testing::ElementsAre(id_a, id_b, id_c));
EXPECT_THAT(toolbar_model()->pinned_action_ids(),
testing::ElementsAre(id_a, id_b, id_c, extension_id));
toolbar_model()->MovePinnedAction(id_a, 4);
EXPECT_THAT(prefs->GetPinnedExtensions(),
testing::ElementsAre(id_b, id_c, id_a));
EXPECT_THAT(toolbar_model()->pinned_action_ids(),
testing::ElementsAre(id_b, id_c, id_a, extension_id));
}
// Tests that the pin state (and position) for extensions that are unloaded
// (but *not* uninstalled) is preserved, even if the pinning order was modified
// while they were unloaded.
// Regression test for crbug.com/1203899.
TEST_F(ToolbarActionsModelUnitTest, UnloadedExtensionsPinnedStatePreserved) {
Init();
ASSERT_TRUE(AddBrowserActionExtensions());
EXPECT_THAT(toolbar_model()->action_ids(),
::testing::UnorderedElementsAre(browser_action_a()->id(),
browser_action_b()->id(),
browser_action_c()->id()));
EXPECT_THAT(toolbar_model()->pinned_action_ids(), ::testing::IsEmpty());
// Pin all of them.
toolbar_model()->SetActionVisibility(browser_action_a()->id(), true);
toolbar_model()->SetActionVisibility(browser_action_b()->id(), true);
toolbar_model()->SetActionVisibility(browser_action_c()->id(), true);
EXPECT_THAT(
toolbar_model()->pinned_action_ids(),
::testing::ElementsAre(browser_action_a()->id(), browser_action_b()->id(),
browser_action_c()->id()));
// Disable extension A. It should no longer be reflected in the pinned
// extensions (or the actions at all).
registrar()->DisableExtension(
browser_action_a()->id(),
{extensions::disable_reason::DISABLE_USER_ACTION});
EXPECT_THAT(toolbar_model()->action_ids(),
::testing::UnorderedElementsAre(browser_action_b()->id(),
browser_action_c()->id()));
EXPECT_THAT(toolbar_model()->pinned_action_ids(),
::testing::ElementsAre(browser_action_b()->id(),
browser_action_c()->id()));
// Re-enable extension A. It should retain it's pinned status (and position,
// at index 0).
registrar()->EnableExtension(browser_action_a()->id());
EXPECT_THAT(toolbar_model()->action_ids(),
::testing::UnorderedElementsAre(browser_action_a()->id(),
browser_action_b()->id(),
browser_action_c()->id()));
EXPECT_THAT(
toolbar_model()->pinned_action_ids(),
::testing::ElementsAre(browser_action_a()->id(), browser_action_b()->id(),
browser_action_c()->id()));
// Repeat the unload, reload flow, but move a pinned action
// (https://crbug.com/1203899) and unpin an action
// (https://crbug.com/1205561) between the unload and the reload.
registrar()->DisableExtension(
browser_action_a()->id(),
{extensions::disable_reason::DISABLE_USER_ACTION});
toolbar_model()->MovePinnedAction(browser_action_b()->id(), 1u);
toolbar_model()->SetActionVisibility(browser_action_b()->id(), false);
// Interim: state should include both B and C, but only C should be pinned.
EXPECT_THAT(toolbar_model()->action_ids(),
::testing::UnorderedElementsAre(browser_action_b()->id(),
browser_action_c()->id()));
EXPECT_THAT(toolbar_model()->pinned_action_ids(),
::testing::ElementsAre(browser_action_c()->id()));
// Reload - state should include all of A, B, C, with pinned order of A, C.
registrar()->EnableExtension(browser_action_a()->id());
EXPECT_THAT(toolbar_model()->action_ids(),
::testing::UnorderedElementsAre(browser_action_a()->id(),
browser_action_b()->id(),
browser_action_c()->id()));
EXPECT_THAT(toolbar_model()->pinned_action_ids(),
::testing::ElementsAre(browser_action_a()->id(),
browser_action_c()->id()));
}
TEST_F(ToolbarActionsModelUnitTest, InitActionList_EmitUserHistograms) {
InitializeEmptyExtensionService();
ASSERT_NO_FATAL_FAILURE(MaybeSetUpTestUser(
/*is_guest=*/false));
RunEmitUserHistogramsTest(/*incremented_histogram_count=*/1);
}
TEST_F(ToolbarActionsModelUnitTest, InitActionList_NonUserEmitHistograms) {
InitializeEmptyExtensionService();
ASSERT_NO_FATAL_FAILURE(MaybeSetUpTestUser(
/*is_guest=*/true));
RunEmitUserHistogramsTest(/*incremented_histogram_count=*/0);
}