Make ToolbarActionsModel own ComponentToolbarActionsFactory

chrome/browser/ui/toolbar/toolbar_actions_model_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // 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 <memory>
 
@@ skipping 105 matching lines @@
 
 }  // namespace
 
 class ToolbarActionsModelUnitTest
     : public extensions::ExtensionServiceTestBase {
  public:
   ToolbarActionsModelUnitTest() {}
   ~ToolbarActionsModelUnitTest() override {}
 
  protected:
-  // Initialize the ExtensionService, ToolbarActionsModel, and
-  // ExtensionSystem.
+  // Initialize the ExtensionService, ToolbarActionsModel, and ExtensionSystem.
   void Init();
 
+  // Initializes the ExtensionService, ToolbarActionsModel, and ExtensionSystem,
+  // making ToolbarActionsModel use a MockComponentToolbarActionsFactory.
+  void InitWithMockActionsFactory();
+
   void TearDown() override;
 
   // Adds or removes the given |extension| and verify success.
   testing::AssertionResult AddExtension(
       const scoped_refptr<const extensions::Extension>& extension)
       WARN_UNUSED_RESULT;
   testing::AssertionResult RemoveExtension(
       const scoped_refptr<const extensions::Extension>& extension)
       WARN_UNUSED_RESULT;
 
   // Adds three extensions, all with browser actions.
   testing::AssertionResult AddBrowserActionExtensions() WARN_UNUSED_RESULT;
 
   // Adds three extensions, one each for browser action, page action, and no
   // action, and are added in that order.
   testing::AssertionResult AddActionExtensions() WARN_UNUSED_RESULT;
 
   // Returns the action's id at the given index in the toolbar model, or empty
   // if one does not exist.
   // If |model| is specified, it is used. Otherwise, this defaults to
   // |toolbar_model_|.
   const std::string GetActionIdAtIndex(size_t index,
                                        const ToolbarActionsModel* model) const;
   const std::string GetActionIdAtIndex(size_t index) const;
 
   // Returns true if the |toobar_model_| has an action with the given |id|.
   bool ModelHasActionForId(const std::string& id) const;
 
-  void SetMockActionsFactory(MockComponentToolbarActionsFactory* factory);
-
   ToolbarActionsModel* toolbar_model() { return toolbar_model_; }
 
   const ToolbarActionsModelTestObserver* observer() const {
     return model_observer_.get();
   }
   size_t num_toolbar_items() const {
     return toolbar_model_->toolbar_items().size();
   }
   const extensions::Extension* browser_action_a() const {
     return browser_action_a_.get();
@@ skipping 34 matching lines @@
   // 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_;
 
-  std::unique_ptr<MockComponentToolbarActionsFactory> mock_actions_factory_;
-
   DISALLOW_COPY_AND_ASSIGN(ToolbarActionsModelUnitTest);
 };
 
 void ToolbarActionsModelUnitTest::Init() {
   InitializeEmptyExtensionService();
   toolbar_model_ =
       extensions::extension_action_test_util::CreateToolbarModelForProfile(
           profile());
-  model_observer_.reset(new ToolbarActionsModelTestObserver(toolbar_model_));
+  model_observer_ =
+      base::MakeUnique<ToolbarActionsModelTestObserver>(toolbar_model_);
+}
+
+void ToolbarActionsModelUnitTest::InitWithMockActionsFactory() {
+  InitializeEmptyExtensionService();
+  toolbar_model_ = extensions::extension_action_test_util::
+      CreateToolbarModelForProfileWithoutWaitingForReady(profile());
+  toolbar_model_->SetMockActionsFactoryForTest(
+      base::MakeUnique<MockComponentToolbarActionsFactory>(profile()));
+
+  // Trigger ToolbarActionsModel::OnReady() after the actions factory has been
+  // swapped out for a mock one.
+  static_cast<extensions::TestExtensionSystem*>(
+      extensions::ExtensionSystem::Get(profile()))
+      ->SetReady();
+  base::RunLoop().RunUntilIdle();
+
+  model_observer_ =
+      base::MakeUnique<ToolbarActionsModelTestObserver>(toolbar_model_);
 }
 
 void ToolbarActionsModelUnitTest::TearDown() {
   model_observer_.reset();
   extensions::ExtensionServiceTestBase::TearDown();
 }
 
 testing::AssertionResult ToolbarActionsModelUnitTest::AddExtension(
     const scoped_refptr<const extensions::Extension>& extension) {
   if (registry()->enabled_extensions().GetByID(extension->id())) {
@@ skipping 93 matching lines @@
   for (extensions::ExtensionList::const_iterator iter = extensions.begin();
        iter != extensions.end(); ++iter) {
     if (!AddExtension(*iter)) {
       return testing::AssertionFailure() << "Failed to install extension: "
                                          << (*iter)->name();
     }
   }
   return testing::AssertionSuccess();
 }
 
-void ToolbarActionsModelUnitTest::SetMockActionsFactory(
-    MockComponentToolbarActionsFactory* factory) {
-  mock_actions_factory_.reset(factory);
-}
-
 // A basic test for component actions and extensions with browser actions
 // showing up in the toolbar.
 TEST_F(ToolbarActionsModelUnitTest, BasicToolbarActionsModelTest) {
   Init();
 
   // Load an extension with a browser action.
   scoped_refptr<const extensions::Extension> extension =
       extensions::extension_action_test_util::CreateActionExtension(
           "browser_action",
           extensions::extension_action_test_util::BROWSER_ACTION);
@@ skipping 878 matching lines @@
   EXPECT_EQ(inserted_and_removed_difference,
             observer()->inserted_count() - observer()->removed_count());
 }
 
 // Test various different reorderings, removals, and reinsertions of the
 // toolbar with component actions.
 TEST_F(ToolbarActionsModelUnitTest,
        ActionsToolbarReorderAndReinsertWithSwitchAndComponentActions) {
   extensions::FeatureSwitch::ScopedOverride enable_redesign(
       extensions::FeatureSwitch::extension_action_redesign(), true);
-  SetMockActionsFactory(new MockComponentToolbarActionsFactory(nullptr));
-  Init();
+  InitWithMockActionsFactory();
 
   // One component action was added when the model was initialized.
   EXPECT_EQ(1u, num_toolbar_items());
   EXPECT_EQ(component_action_id(), GetActionIdAtIndex(0u));
   EXPECT_TRUE(toolbar_model()->HasComponentAction(component_action_id()));
 
   // Add the three browser action extensions.
   ASSERT_TRUE(AddBrowserActionExtensions());
 
   // Verify the four actions are in the model in the proper order.
@@ skipping 199 matching lines @@
   InitializeEmptyExtensionService();
   ToolbarActionsModel* toolbar_model = extensions::extension_action_test_util::
       CreateToolbarModelForProfileWithoutWaitingForReady(profile());
   ASSERT_FALSE(toolbar_model->actions_initialized());
 
   // AddComponentAction() should be a no-op if actions_initialized() is false.
   toolbar_model->AddComponentAction(component_action_id());
   EXPECT_EQ(0u, toolbar_model->toolbar_items().size());
   EXPECT_FALSE(toolbar_model->HasComponentAction(component_action_id()));
 }