[Extensions UI] Highlight toolbar extensions when the redesign bubble is active

chrome/browser/extensions/extension_toolbar_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/extensions/extension_toolbar_model.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_base.h"
 #include "base/prefs/pref_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/extension_toolbar_model_factory.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/extensions/extension_toolbar_icon_surfacing_bubble_delegate.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.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_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/pref_names.h"
 #include "extensions/common/extension.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"
 
 namespace extensions {
 
 ExtensionToolbarModel::ExtensionToolbarModel(Profile* profile,
                                              ExtensionPrefs* extension_prefs)
     : profile_(profile),
       extension_prefs_(extension_prefs),
       prefs_(profile_->GetPrefs()),
       extension_action_api_(ExtensionActionAPI::Get(profile_)),
       extensions_initialized_(false),
-      include_all_extensions_(
-          FeatureSwitch::extension_action_redesign()->IsEnabled()),
-      is_highlighting_(false),
+      include_all_extensions_(FeatureSwitch::extension_action_redesign()
+                                  ->IsEnabled()),
+      highlight_type_(HIGHLIGHT_NONE),
       extension_action_observer_(this),
       extension_registry_observer_(this),
       weak_ptr_factory_(this) {
   ExtensionSystem::Get(profile_)->ready().Post(
       FROM_HERE,
       base::Bind(&ExtensionToolbarModel::OnReady,
                  weak_ptr_factory_.GetWeakPtr()));
   visible_icon_count_ = prefs_->GetInteger(pref_names::kToolbarSize);
 
   // We only care about watching the prefs if not in incognito mode.
@@ skipping 64 matching lines @@
   UpdatePrefs();
 }
 
 void ExtensionToolbarModel::SetVisibleIconCount(size_t count) {
   visible_icon_count_ = (count >= toolbar_items_.size()) ? -1 : count;
 
   // Only set the prefs if we're not in highlight mode and the profile is not
   // incognito. Highlight mode is designed to be a transitory state, and should
   //  not persist across browser restarts (though it may be re-entered), and we
   // don't store anything in incognito.
-  if (!is_highlighting_ && !profile_->IsOffTheRecord()) {
+  if (!is_highlighting() && !profile_->IsOffTheRecord()) {
     // Additionally, if we are using the new toolbar, any icons which are in the
     // overflow menu are considered "hidden". But it so happens that the times
     // we are likely to call SetVisibleIconCount() are also those when we are
     // in flux. So wait for things to cool down before setting the prefs.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&ExtensionToolbarModel::MaybeUpdateVisibilityPrefs,
                    weak_ptr_factory_.GetWeakPtr()));
     prefs_->SetInteger(pref_names::kToolbarSize, visible_icon_count_);
   }
@@ skipping 95 matching lines @@
 }
 
 void ExtensionToolbarModel::OnReady() {
   ExtensionRegistry* registry = ExtensionRegistry::Get(profile_);
   InitializeExtensionList();
   // 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(registry);
   extension_action_observer_.Add(extension_action_api_);
+
+  if (ExtensionToolbarIconSurfacingBubbleDelegate::ShouldShowForProfile(
+          profile_)) {
+    ExtensionIdList ids;
+    for (const auto& extension : toolbar_items_)
+      ids.push_back(extension->id());
+    HighlightExtensions(ids, HIGHLIGHT_INFO);
+  }
+
+  extensions_initialized_ = true;
+  FOR_EACH_OBSERVER(Observer, observers_, OnToolbarModelInitialized());
 }
 
 size_t ExtensionToolbarModel::FindNewPositionFromLastKnownGood(
     const Extension* extension) {
   // See if we have last known good position for this extension.
   size_t new_index = 0;
   // Loop through the ID list of known positions, to count the number of visible
   // extension icons preceding |extension|.
   for (ExtensionIdList::const_iterator iter_id = last_known_positions_.begin();
        iter_id < last_known_positions_.end(); ++iter_id) {
@@ skipping 73 matching lines @@
     UpdatePrefs();
   } else {
     new_index = FindNewPositionFromLastKnownGood(extension);
   }
 
   toolbar_items_.insert(toolbar_items_.begin() + new_index, extension);
 
   // If we're currently highlighting, then even though we add a browser action
   // to the full list (|toolbar_items_|, there won't be another *visible*
   // browser action, which was what the observers care about.
-  if (!is_highlighting_) {
+  if (!is_highlighting()) {
     FOR_EACH_OBSERVER(Observer, observers_,
                       OnToolbarExtensionAdded(extension, new_index));
 
     int visible_count_delta = 0;
     if (is_new_extension && !all_icons_visible()) {
       // If this is a new extension (and not all extensions are visible), we
       // expand the toolbar out so that the new one can be seen.
       visible_count_delta = 1;
     } else if (profile_->IsOffTheRecord()) {
       // If this is an incognito profile, we also have to check to make sure the
@@ skipping 29 matching lines @@
     return;
 
   // If our visible count is set to the current size, we need to decrement it.
   if (visible_icon_count_ == static_cast<int>(toolbar_items_.size()))
     SetVisibleIconCount(toolbar_items_.size() - 1);
 
   toolbar_items_.erase(pos);
 
   // If we're in highlight mode, we also have to remove the extension from
   // the highlighted list.
-  if (is_highlighting_) {
+  if (is_highlighting()) {
     pos = std::find(highlighted_items_.begin(),
                     highlighted_items_.end(),
                     extension);
     if (pos != highlighted_items_.end()) {
       highlighted_items_.erase(pos);
       FOR_EACH_OBSERVER(Observer, observers_,
                         OnToolbarExtensionRemoved(extension));
       // If the highlighted list is now empty, we stop highlighting.
       if (highlighted_items_.empty())
         StopHighlighting();
@@ skipping 15 matching lines @@
 // 3. Remove holes from the sorted vector and append the unsorted vector.
 void ExtensionToolbarModel::InitializeExtensionList() {
   DCHECK(toolbar_items_.empty());  // We shouldn't have any items yet.
 
   last_known_positions_ = extension_prefs_->GetToolbarOrder();
   if (profile_->IsOffTheRecord())
     IncognitoPopulate();
   else
     Populate(&last_known_positions_);
 
-  extensions_initialized_ = true;
   MaybeUpdateVisibilityPrefs();
-  FOR_EACH_OBSERVER(Observer, observers_, OnToolbarModelInitialized());
 }
 
 void ExtensionToolbarModel::Populate(ExtensionIdList* positions) {
   DCHECK(!profile_->IsOffTheRecord());
   const ExtensionSet& extensions =
       ExtensionRegistry::Get(profile_)->enabled_extensions();
   // Items that have explicit positions.
   ExtensionList sorted(positions->size(), NULL);
   // The items that don't have explicit positions.
   ExtensionList unsorted;
@@ skipping 207 matching lines @@
         if (extension - toolbar_items_.begin() >=
                 static_cast<int>(visible_icon_count()))
           MoveExtensionIcon((*extension)->id(), 0);
         break;
       }
     }
   }
 }
 
 bool ExtensionToolbarModel::HighlightExtensions(
-    const ExtensionIdList& extension_ids) {
+    const ExtensionIdList& extension_ids,
+    HighlightType highlight_type) {
   highlighted_items_.clear();
 
   for (ExtensionIdList::const_iterator id = extension_ids.begin();
        id != extension_ids.end();
        ++id) {
     for (ExtensionList::const_iterator extension = toolbar_items_.begin();
          extension != toolbar_items_.end();
          ++extension) {
       if (*id == (*extension)->id())
         highlighted_items_.push_back(*extension);
     }
   }
 
   // If we have any items in |highlighted_items_|, then we entered highlighting
   // mode.
   if (highlighted_items_.size()) {
-    old_visible_icon_count_ = visible_icon_count_;
+    // It's important that is_highlighting_ is changed immediately before the
+    // observers are notified since it changes the result of toolbar_items().
+    highlight_type_ = highlight_type;
+    FOR_EACH_OBSERVER(Observer, observers_,
+                      OnToolbarHighlightModeChanged(true));
+
+    // We set the visible icon count after the highlight mode change because
+    // the UI actions are created/destroyed during highlight, and doing that
+    // prior to changing the size allows us to still have smooth animations.
     if (visible_icon_count() < extension_ids.size())
       SetVisibleIconCount(extension_ids.size());
 
-    // It's important that is_highlighting_ is changed immediately before the
-    // observers are notified since it changes the result of toolbar_items().
-    is_highlighting_ = true;
-    FOR_EACH_OBSERVER(Observer, observers_,
-                      OnToolbarHighlightModeChanged(true));
     return true;
   }
 
   // Otherwise, we didn't enter highlighting mode (and, in fact, exited it if
   // we were otherwise in it).
-  if (is_highlighting_)
+  if (is_highlighting())
     StopHighlighting();
   return false;
 }
 
 void ExtensionToolbarModel::StopHighlighting() {
-  if (is_highlighting_) {
-    if (old_visible_icon_count_ != visible_icon_count_)
-      SetVisibleIconCount(old_visible_icon_count_);
-
+  if (is_highlighting()) {
     // It's important that is_highlighting_ is changed immediately before the
     // observers are notified since it changes the result of toolbar_items().
-    is_highlighting_ = false;
+    highlight_type_ = HIGHLIGHT_NONE;
     FOR_EACH_OBSERVER(Observer, observers_,
                       OnToolbarHighlightModeChanged(false));
+
     // For the same reason, we don't clear highlighted_items_ until after the
     // mode changed.
     highlighted_items_.clear();
+
+    // We set the visible icon count after the highlight mode change because
+    // the UI actions are created/destroyed during highlight, and doing that
+    // prior to changing the size allows us to still have smooth animations.
+    int saved_icon_count = prefs_->GetInteger(pref_names::kToolbarSize);
+    if (saved_icon_count != visible_icon_count_)
+      SetVisibleIconCount(saved_icon_count);
   }
 }
 
 bool ExtensionToolbarModel::RedesignIsShowingNewIcons() const {
   for (const scoped_refptr<const Extension>& extension : toolbar_items_) {
     // Without the redesign, we only show extensions with browser actions.
     // Any extension without a browser action is an indication that we're
     // showing something new.
     if (!extension->manifest()->HasKey(manifest_keys::kBrowserAction))
       return true;
   }
   return false;
 }
 
 }  // namespace extensions