Action box menu

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 "chrome/browser/extensions/extension_browser_event_router.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
@@ skipping 99 matching lines @@
 void ExtensionToolbarModel::SetVisibleIconCount(int count) {
   visible_icon_count_ = count == static_cast<int>(size()) ? -1 : count;
   prefs_->SetInteger(prefs::kExtensionToolbarSize, visible_icon_count_);
 }
 
 void ExtensionToolbarModel::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_EXTENSIONS_READY) {
-    InitializeExtensionList();
+    InitializeExtensionLists();
     return;
   }
 
   if (!service_->is_ready())
     return;
 
   const Extension* extension = NULL;
   if (type == chrome::NOTIFICATION_EXTENSION_UNLOADED) {
     extension = content::Details<extensions::UnloadedExtensionInfo>(
         details)->extension;
@@ skipping 63 matching lines @@
   UpdatePrefs();
 }
 
 // Combine the currently enabled extensions that have browser actions (which
 // we get from the ExtensionService) with the ordering we get from the
 // pref service. For robustness we use a somewhat inefficient process:
 // 1. Create a vector of extensions sorted by their pref values. This vector may
 // have holes.
 // 2. Create a vector of extensions that did not have a pref value.
 // 3. Remove holes from the sorted vector and append the unsorted vector.
-void ExtensionToolbarModel::InitializeExtensionList() {
+void ExtensionToolbarModel::InitializeExtensionLists() {

[Aaron Boodman, 2012/06/12 05:53:44]

This is pretty hard to follow. How about something like:

void Populate() {
  if (IsActionBoxEnabled())
    PopulateForActionBoxMode();
  else
    PopulateForNonActionBoxMode();
}

void PopulateForActionBoxMode() {
  // all enabled extensions that have browser actions are shown.
  // there's no way to hide browser actions in action box mode.
  // if an extension is explicitly in the toolbar, put it in
  // the toolbar list. otherwise, it goes in the action box list.
}

void PopulateToolbarForActionBoxMode() {
  // old populate logic here.
}

This would mean undoing some of the visibility changes you did earlier, but it
seems simpler this way.

[yefimt, 2012/06/13 01:24:21]

Done.

   DCHECK(service_->is_ready());
 
   std::vector<std::string> pref_order = service_->extension_prefs()->
       GetToolbarOrder();
+  InitializeExtensionList(pref_order, &toolitems_, true);
+
+  pref_order = service_->extension_prefs()->GetActionboxOrder();
+  InitializeExtensionList(pref_order, &action_box_menu_items_, false);
+
+  UpdatePrefs();
+
+  extensions_initialized_ = true;
+  FOR_EACH_OBSERVER(Observer, observers_, ModelLoaded());
+}
+
+void ExtensionToolbarModel::InitializeExtensionList(
+    const std::vector<std::string>& pref_order,
+    extensions::ExtensionList* extension_list,
+    bool bar) {
   // Items that have a pref for their position.
   ExtensionList sorted;
   sorted.resize(pref_order.size(), NULL);
   // The items that don't have a pref for their position.
   ExtensionList unsorted;
 
   // Create the lists.
   for (ExtensionSet::const_iterator it = service_->extensions()->begin();
-       it != service_->extensions()->end(); ++it) {
-    const Extension* extension = *it;
-    if (!extension->browser_action())
-      continue;
-    if (!service_->extension_prefs()->GetBrowserActionVisibility(extension))
-      continue;
+    it != service_->extensions()->end(); ++it) {
+      const Extension* extension = *it;
+      if (!extension->browser_action())
+        continue;
+      bool action_visibility = service_->extension_prefs()->
+          GetBrowserActionVisibility(extension);
+      if (bar ^ action_visibility)
+          continue;
 
-    std::vector<std::string>::iterator pos =
+      std::vector<std::string>::const_iterator pos =
         std::find(pref_order.begin(), pref_order.end(), extension->id());
-    if (pos != pref_order.end()) {
-      int index = std::distance(pref_order.begin(), pos);
-      sorted[index] = extension;
-    } else {
-      unsorted.push_back(make_scoped_refptr(extension));
-    }
+      if (pos != pref_order.end()) {
+        int index = std::distance(pref_order.begin(), pos);
+        sorted[index] = extension;
+      } else {
+        unsorted.push_back(make_scoped_refptr(extension));
+      }
   }
 
   // Merge the lists.
-  toolitems_.reserve(sorted.size() + unsorted.size());
+  extension_list->reserve(sorted.size() + unsorted.size());
   for (ExtensionList::iterator iter = sorted.begin();
-       iter != sorted.end(); ++iter) {
-    if (*iter != NULL)
-      toolitems_.push_back(*iter);
+    iter != sorted.end(); ++iter) {
+      if (*iter != NULL)
+        extension_list->push_back(*iter);
   }
-  toolitems_.insert(toolitems_.end(), unsorted.begin(), unsorted.end());
+  extension_list->insert(extension_list->end(), unsorted.begin(),
+                         unsorted.end());
 
   // Inform observers.
-  for (size_t i = 0; i < toolitems_.size(); i++) {
+  for (size_t i = 0; i < extension_list->size(); i++) {
     FOR_EACH_OBSERVER(Observer, observers_,
-                      BrowserActionAdded(toolitems_[i], i));
+        BrowserActionAdded(extension_list->at(i), i));
   }
-
-  UpdatePrefs();
-
-  extensions_initialized_ = true;
-  FOR_EACH_OBSERVER(Observer, observers_, ModelLoaded());
 }
 
 void ExtensionToolbarModel::UpdatePrefs() {
   if (!service_->extension_prefs())
     return;
 
   std::vector<std::string> ids;
   ids.reserve(toolitems_.size());
   for (ExtensionList::iterator iter = begin(); iter != end(); ++iter)
     ids.push_back((*iter)->id());
   service_->extension_prefs()->SetToolbarOrder(ids);
+
+  ids.clear();
+  ids.reserve(action_box_menu_items_.size());
+  for (size_t i = 0; i < action_box_menu_items_.size(); ++i)
+    ids.push_back(action_box_menu_items_[i]->id());
+  service_->extension_prefs()->SetActionboxOrder(ids);
 }
 
 const Extension* ExtensionToolbarModel::GetExtensionByIndex(int index) const {
   return toolitems_[index];
 }
 
 int ExtensionToolbarModel::IncognitoIndexToOriginal(int incognito_index) {
   int original_index = 0, i = 0;
   for (ExtensionList::iterator iter = begin(); iter != end();
        ++iter, ++original_index) {
@@ skipping 10 matching lines @@
   int incognito_index = 0, i = 0;
   for (ExtensionList::iterator iter = begin(); iter != end();
        ++iter, ++i) {
     if (original_index == i)
       break;
     if (service_->IsIncognitoEnabled((*iter)->id()))
       ++incognito_index;
   }
   return incognito_index;
 }
+
+const Extension* ExtensionToolbarModel::GetActionBoxExtensionByIndex(
+    int index) const {
+  return action_box_menu_items_[index];
+}