[Extenisons UI] Remove extension_action_redesign logic from the toolbar

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 18 matching lines @@
 #include "chrome/browser/ui/toolbar/toolbar_actions_model_factory.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_util.h"
 #include "extensions/browser/pref_names.h"
 #include "extensions/common/extension_set.h"
-#include "extensions/common/feature_switch.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/one_shot_event.h"
 
 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,
                             weak_ptr_factory_.GetWeakPtr()));
   visible_icon_count_ =
       prefs_->GetInteger(extensions::pref_names::kToolbarSize);
@@ skipping 116 matching lines @@
       const extensions::Extension* extension = GetExtensionById(item.id);
       DCHECK(extension);
 
       // Create and add an ExtensionActionViewController for the extension.
       result = base::MakeUnique<ExtensionActionViewController>(
           extension, browser,
           extension_action_manager_->GetExtensionAction(*extension), bar);
       break;
     }
     case COMPONENT_ACTION: {
-      DCHECK(use_redesign_);
       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(
-    const std::string& extension_id,
-    bool is_now_visible) {
-  if (use_redesign_)
-    return;
-  const extensions::Extension* extension = GetExtensionById(extension_id);
-  if (is_now_visible)
-    AddExtension(extension);
-  else
-    RemoveExtension(extension);
-}
-
 void ToolbarActionsModel::OnExtensionLoaded(
     content::BrowserContext* browser_context,
     const extensions::Extension* extension) {
   // We don't want to add the same extension twice. It may have already been
   // added by EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED below, if the user
   // hides the browser action and then disables and enables the extension.
   if (!HasItem(ToolbarItem(extension->id(), EXTENSION_ACTION)))
     AddExtension(extension);
 }
 
@@ skipping 36 matching lines @@
   // Wait until the extension system is ready before observing any further
   // 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_) {
-    component_actions_factory_->UnloadMigratedExtensions(
-        extensions::ExtensionSystem::Get(profile_)->extension_service(),
-        extension_registry_);
-  }
+  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
   // visible action icons preceding |action|'s id.
   for (const std::string& last_pos_id : last_known_positions_) {
     if (last_pos_id == action.id)
@@ skipping 12 matching lines @@
   return toolbar_items_.size();
 }
 
 bool ToolbarActionsModel::ShouldAddExtension(
     const extensions::Extension* extension) {
   // In incognito mode, don't add any extensions that aren't incognito-enabled.
   if (profile_->IsOffTheRecord() &&
       !extensions::util::IsIncognitoEnabled(extension->id(), profile_))
     return false;
 
-  if (use_redesign_) {
-    // In this case, we don't care about the browser action visibility, because
-    // we want to show each extension regardless.
-    return extension_action_manager_->GetExtensionAction(*extension) != nullptr;
-  }
-
-  return extension_action_manager_->GetBrowserAction(*extension) &&
-         extension_action_api_->GetBrowserActionVisibility(extension->id());
+  // In this case, we don't care about the browser action visibility, because
+  // we want to show each extension regardless.
+  return extension_action_manager_->GetExtensionAction(*extension) != nullptr;
 }
 
 void ToolbarActionsModel::AddExtension(const extensions::Extension* extension) {
   if (!ShouldAddExtension(extension))
     return;
 
   AddItem(ToolbarItem(extension->id(), EXTENSION_ACTION));
 }
 
 void ToolbarActionsModel::AddItem(const ToolbarItem& item) {
@@ skipping 272 matching lines @@
   if (!toolbar_items_.empty()) {
     // Visible count can be -1, meaning: 'show all'. Since UMA converts negative
     // values to 0, this would be counted as 'show none' unless we convert it to
     // max.
     UMA_HISTOGRAM_COUNTS_100(
         "ExtensionToolbarModel.BrowserActionsVisible",
         visible_icon_count_ == -1
             ? base::HistogramBase::kSampleType_MAX
             : visible_icon_count_ - component_actions_count);
 
-    if (use_redesign_) {
-      // The only time this will useful and possibly vary from
-      // BrowserActionsVisible is when the redesign has been enabled.
-      UMA_HISTOGRAM_COUNTS_100("Toolbar.ActionsModel.ToolbarActionsVisible",
-                               visible_icon_count_ == -1
-                                   ? base::HistogramBase::kSampleType_MAX
-                                   : visible_icon_count_);
-    }
+    UMA_HISTOGRAM_COUNTS_100("Toolbar.ActionsModel.ToolbarActionsVisible",
+                             visible_icon_count_ == -1
+                                 ? base::HistogramBase::kSampleType_MAX
+                                 : visible_icon_count_);
   }
 }
 
 bool ToolbarActionsModel::HasItem(const ToolbarItem& item) const {
   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_) {
     component_actions_factory_->OnAddComponentActionBeforeInit(action_id);
     return;
   }
 
   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);
@@ skipping 52 matching lines @@
   // Don't observe change caused by self.
   pref_change_registrar_.Remove(extensions::pref_names::kToolbar);
   extension_prefs_->SetToolbarOrder(last_known_positions_);
   pref_change_registrar_.Add(extensions::pref_names::kToolbar,
                              pref_change_callback_);
 }
 
 void ToolbarActionsModel::SetActionVisibility(const std::string& action_id,
                                               bool is_now_visible) {
   // Hiding works differently with the new and old toolbars.
-  if (use_redesign_) {
-    DCHECK(HasItem(ToolbarItem(action_id, EXTENSION_ACTION)));
+  DCHECK(HasItem(ToolbarItem(action_id, EXTENSION_ACTION)));
 
-    int new_size = 0;
-    int new_index = 0;
-    if (is_now_visible) {
-      // If this action used to be hidden, we can't possibly be showing all.
-      DCHECK_LT(visible_icon_count(), toolbar_items_.size());
-      // Grow the bar by one and move the action to the end of the visibles.
-      new_size = visible_icon_count() + 1;
-      new_index = new_size - 1;
-    } else {
-      // If we're hiding one, we must be showing at least one.
-      DCHECK_GE(visible_icon_count(), 0u);
-      // Shrink the bar by one and move the action to the beginning of the
-      // overflow menu.
-      new_size = visible_icon_count() - 1;
-      new_index = new_size;
-    }
-    SetVisibleIconCount(new_size);
-    MoveActionIcon(action_id, new_index);
-  } else {  // Legacy toolbar; hiding removes it from the toolbar.
-    if (!profile_->IsOffTheRecord()) {
-      extension_action_api_->SetBrowserActionVisibility(action_id,
-                                                        is_now_visible);
-    } else {
-      OnExtensionActionVisibilityChanged(action_id, is_now_visible);
-    }
+  int new_size = 0;
+  int new_index = 0;
+  if (is_now_visible) {
+    // If this action used to be hidden, we can't possibly be showing all.
+    DCHECK_LT(visible_icon_count(), toolbar_items_.size());
+    // Grow the bar by one and move the action to the end of the visibles.
+    new_size = visible_icon_count() + 1;
+    new_index = new_size - 1;
+  } else {
+    // If we're hiding one, we must be showing at least one.
+    DCHECK_GE(visible_icon_count(), 0u);
+    // Shrink the bar by one and move the action to the beginning of the
+    // overflow menu.
+    new_size = visible_icon_count() - 1;
+    new_index = new_size;
   }
+  SetVisibleIconCount(new_size);
+  MoveActionIcon(action_id, new_index);
 }
 
 void ToolbarActionsModel::OnActionToolbarPrefChange() {
   // If extensions are not ready, defer to later Populate() call.
   if (!actions_initialized_)
     return;
 
   // Recalculate |last_known_positions_| to be |pref_positions| followed by
   // ones that are only in |last_known_positions_|.
   std::vector<std::string> pref_positions = extension_prefs_->GetToolbarOrder();
@@ skipping 104 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();
 }