Make ToolbarActionsModel own ComponentToolbarActionsFactory

chrome/browser/ui/toolbar/toolbar_actions_model.cc

 // Copyright (c) 2012 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 <algorithm>
 #include <string>
 
 #include "base/location.h"
@@ skipping 32 matching lines @@
 ToolbarActionsModel::ToolbarActionsModel(
     Profile* profile,
     extensions::ExtensionPrefs* extension_prefs)
     : profile_(profile),
       extension_prefs_(extension_prefs),
       prefs_(profile_->GetPrefs()),
       extension_action_api_(extensions::ExtensionActionAPI::Get(profile_)),
       extension_registry_(extensions::ExtensionRegistry::Get(profile_)),
       extension_action_manager_(
           extensions::ExtensionActionManager::Get(profile_)),
+      component_actions_factory_(
+          base::MakeUnique<ComponentToolbarActionsFactory>(profile_)),
       actions_initialized_(false),
       use_redesign_(
           extensions::FeatureSwitch::extension_action_redesign()->IsEnabled()),
       highlight_type_(HIGHLIGHT_NONE),
       has_active_bubble_(false),
       extension_action_observer_(this),
       extension_registry_observer_(this),
       weak_ptr_factory_(this) {
   extensions::ExtensionSystem::Get(profile_)->ready().Post(
       FROM_HERE, base::Bind(&ToolbarActionsModel::OnReady,
@@ skipping 113 matching lines @@
                                          ToolbarActionsBar* bar,
                                          const ToolbarItem& item) {
   std::unique_ptr<ToolbarActionViewController> result;
   switch (item.type) {
     case EXTENSION_ACTION: {
       // Get the extension.
       const extensions::Extension* extension = GetExtensionById(item.id);
       DCHECK(extension);
 
       // Create and add an ExtensionActionViewController for the extension.
-      result.reset(new ExtensionActionViewController(
+      result = base::MakeUnique<ExtensionActionViewController>(
           extension, browser,
-          extension_action_manager_->GetExtensionAction(*extension), bar));
+          extension_action_manager_->GetExtensionAction(*extension), bar);
       break;
     }
     case COMPONENT_ACTION: {
       DCHECK(use_redesign_);
-      result = ComponentToolbarActionsFactory::GetInstance()
-                   ->GetComponentToolbarActionForId(item.id, browser, bar);
+      result = component_actions_factory_->GetComponentToolbarActionForId(
+          item.id, browser, bar);
       break;
     }
     case UNKNOWN_ACTION:
       NOTREACHED();  // Should never have an UNKNOWN_ACTION in toolbar_items.
       break;
   }
   return result;
 }
 
 void ToolbarActionsModel::OnExtensionActionVisibilityChanged(
@@ skipping 58 matching lines @@
   // changes so that the toolbar buttons can be shown in their stable ordering
   // taken from prefs.
   extension_registry_observer_.Add(extension_registry_);
   extension_action_observer_.Add(extension_action_api_);
 
   actions_initialized_ = true;
   for (Observer& observer : observers_)
     observer.OnToolbarModelInitialized();
 
   if (use_redesign_) {
-    ComponentToolbarActionsFactory::GetInstance()->UnloadMigratedExtensions(
+    component_actions_factory_->UnloadMigratedExtensions(
         extensions::ExtensionSystem::Get(profile_)->extension_service(),
         extension_registry_);
   }
 }
 
 size_t ToolbarActionsModel::FindNewPositionFromLastKnownGood(
     const ToolbarItem& action) {
   // See if we have last known good position for this action.
   size_t new_index = 0;
   // Loop through the ID list of known positions, to count the number of
@@ skipping 149 matching lines @@
 ToolbarActionsModel::GetExtensionMessageBubbleController(Browser* browser) {
   std::unique_ptr<extensions::ExtensionMessageBubbleController> controller;
   if (has_active_bubble())
     return controller;
   controller = ExtensionMessageBubbleFactory(browser).GetController();
   if (controller)
     controller->SetIsActiveBubble();
   return controller;
 }
 
+void ToolbarActionsModel::SetMockActionsFactoryForTest(
+    std::unique_ptr<ComponentToolbarActionsFactory> mock_factory) {
+  component_actions_factory_ = std::move(mock_factory);
+}
+
 void ToolbarActionsModel::RemoveExtension(
     const extensions::Extension* extension) {
   RemoveItem(ToolbarItem(extension->id(), EXTENSION_ACTION));
 }
 
 // Combine the currently enabled extensions that have browser actions (which
 // we get from the ExtensionRegistry) and component actions (which we get from
 // ComponentToolbarActionsFactory) with the ordering we get from the pref
 // service. For robustness we use a somewhat inefficient process:
 // 1. Create a vector of actions sorted by their pref values. This vector may
@@ skipping 33 matching lines @@
       if (!extension_action_api_->GetBrowserActionVisibility(extension->id()))
         ++hidden;
       continue;
     }
 
     all_actions.push_back(ToolbarItem(extension->id(), EXTENSION_ACTION));
   }
 
   // Next, add the component action ids.
   std::set<std::string> component_ids =
-      ComponentToolbarActionsFactory::GetInstance()->GetInitialComponentIds(
-          profile_);
+      component_actions_factory_->GetInitialComponentIds();
   for (const std::string& id : component_ids)
     all_actions.push_back(ToolbarItem(id, COMPONENT_ACTION));
 
   // Add each action id to the appropriate list. Since the |sorted| list is
   // created with enough room for each id in |positions| (which helps with
   // proper order insertion), holes can be present if there isn't an action
   // for each id. This is handled below when we add the actions to
   // |toolbar_items_| to ensure that there are never any holes in
   // |toolbar_items_| itself (or, relatedly, CreateActions()).
   for (const ToolbarItem& action : all_actions) {
@@ skipping 109 matching lines @@
   return base::ContainsValue(toolbar_items_, item);
 }
 
 bool ToolbarActionsModel::HasComponentAction(
     const std::string& action_id) const {
   DCHECK(use_redesign_);
   return HasItem(ToolbarItem(action_id, COMPONENT_ACTION));
 }
 
 void ToolbarActionsModel::AddComponentAction(const std::string& action_id) {
+  DCHECK(use_redesign_);
   if (!actions_initialized_) {
-    // TODO(crbug.com/660972): Add these component actions at initialization.
+    component_actions_factory_->OnAddComponentActionBeforeInit(action_id);
     return;
   }
 
-  DCHECK(use_redesign_);
   ToolbarItem component_item(action_id, COMPONENT_ACTION);
   DCHECK(!HasItem(component_item));
   AddItem(component_item);
 }
 
 void ToolbarActionsModel::RemoveComponentAction(const std::string& action_id) {
   DCHECK(use_redesign_);
+  if (!actions_initialized_) {
+    component_actions_factory_->OnRemoveComponentActionBeforeInit(action_id);
+    return;
+  }
   // If the action was visible and there are overflowed actions, we reduce the
   // visible count so that we don't pop out a previously-hidden action.
   if (IsActionVisible(action_id) && !all_icons_visible())
     SetVisibleIconCount(visible_icon_count() - 1);
 
   ToolbarItem component_item(action_id, COMPONENT_ACTION);
   DCHECK(HasItem(component_item));
   RemoveItem(component_item);
   RemovePref(component_item);
 }
 
 void ToolbarActionsModel::IncognitoPopulate() {
   DCHECK(profile_->IsOffTheRecord());
   const ToolbarActionsModel* original_model =
       ToolbarActionsModel::Get(profile_->GetOriginalProfile());
 
   // Find the absolute value of the original model's count.
   int original_visible = original_model->visible_icon_count();
 
   // In incognito mode, we show only those actions that are incognito-enabled
   // Further, any actions that were overflowed in regular mode are still
   // overflowed. Order is the same as in regular mode.
   visible_icon_count_ = 0;
 
   std::set<std::string> component_ids =
-      ComponentToolbarActionsFactory::GetInstance()->GetInitialComponentIds(
-          profile_);
+      component_actions_factory_->GetInitialComponentIds();
   for (std::vector<ToolbarItem>::const_iterator iter =
            original_model->toolbar_items_.begin();
        iter != original_model->toolbar_items_.end(); ++iter) {
     // The extension might not be shown in incognito mode.
     // We may also disable certain component actions in incognito mode.
     bool should_add = false;
     switch (iter->type) {
       case EXTENSION_ACTION:
         should_add = ShouldAddExtension(GetExtensionById(iter->id));
         break;
@@ skipping 175 matching lines @@
   return extension_registry_->enabled_extensions().GetByID(id);
 }
 
 bool ToolbarActionsModel::IsActionVisible(const std::string& action_id) const {
   size_t index = 0u;
   while (toolbar_items().size() > index &&
          toolbar_items()[index].id != action_id)
     ++index;
   return index < visible_icon_count();
 }