Action box menu

chrome/browser/extensions/extension_prefs.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_prefs.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/admin_policy.h"
@@ skipping 59 matching lines @@
 // Indicates whether to show an install warning when the user enables.
 const char kExtensionDidEscalatePermissions[] = "install_warning_on_enable";
 
 // Indicates whether the extension was updated while it was disabled.
 const char kPrefDisableReason[] = "disable_reason";
 
 // A preference that tracks browser action toolbar configuration. This is a list
 // object stored in the Preferences file. The extensions are stored by ID.
 const char kExtensionToolbar[] = "extensions.toolbar";
 
+const char kExtensionActionBox[] = "extensions.action_box_order";

[Aaron Boodman, 2012/07/02 22:41:34]

Comment these.

[yefimt, 2012/07/11 22:34:34]

Done.

+
+const char kExtensionActionBoxBar[] = "extensions.toolbar_order";

[Aaron Boodman, 2012/07/02 22:41:34]

I still think this should be toolbar_order_with_action_box. It's more
characters, but I think the clarity is worth it.

[yefimt, 2012/07/11 22:34:34]

Done.

+
 // The key for a serialized Time value indicating the start of the day (from the
 // server's perspective) an extension last included a "ping" parameter during
 // its update check.
 const char kLastPingDay[] = "lastpingday";
 
 // Similar to kLastPingDay, but for "active" instead of "rollcall" pings.
 const char kLastActivePingDay[] = "last_active_pingday";
 
 // A bit we use to keep track of whether we need to do an "active" ping.
 const char kActiveBit[] = "active_bit";
@@ skipping 1055 matching lines @@
     const std::string& id) const {
   return DoesExtensionHaveState(id, Extension::EXTERNAL_EXTENSION_UNINSTALLED);
 }
 
 bool ExtensionPrefs::IsExtensionDisabled(
     const std::string& id) const {
   return DoesExtensionHaveState(id, Extension::DISABLED);
 }
 
 std::vector<std::string> ExtensionPrefs::GetToolbarOrder() {
-  ExtensionIdSet extension_ids;
-  const ListValue* toolbar_order = prefs_->GetList(kExtensionToolbar);
-  if (toolbar_order) {
-    for (size_t i = 0; i < toolbar_order->GetSize(); ++i) {
-      std::string extension_id;
-      if (toolbar_order->GetString(i, &extension_id))
-        extension_ids.push_back(extension_id);
-    }
-  }
-  return extension_ids;
+  bool action_box_enabled = extensions::switch_utils::IsActionBoxEnabled();
+  return GetExtensionsOrder(action_box_enabled ? kExtensionActionBoxBar :
+                                                 kExtensionToolbar);
 }
 
 void ExtensionPrefs::SetToolbarOrder(
     const std::vector<std::string>& extension_ids) {
-  ListPrefUpdate update(prefs_, kExtensionToolbar);
-  ListValue* toolbar_order = update.Get();
-  toolbar_order->Clear();
-  for (std::vector<std::string>::const_iterator iter = extension_ids.begin();
-       iter != extension_ids.end(); ++iter) {
-    toolbar_order->Append(new StringValue(*iter));
-  }
+  bool action_box_enabled = extensions::switch_utils::IsActionBoxEnabled();
+  SetExtensionsOrder(action_box_enabled ? kExtensionActionBoxBar :
+                                          kExtensionToolbar,
+                     extension_ids);
+}
+
+std::vector<std::string> ExtensionPrefs::GetActionBoxOrder() {
+  return GetExtensionsOrder(kExtensionActionBox);
+}
+
+void ExtensionPrefs::SetActionBoxOrder(
+    const std::vector<std::string>& extension_ids) {
+  SetExtensionsOrder(kExtensionActionBox, extension_ids);
 }
 
 void ExtensionPrefs::OnExtensionInstalled(
     const Extension* extension,
     Extension::State initial_state,
     bool from_webstore,
     const StringOrdinal& page_ordinal) {
   const std::string& id = extension->id();
   CHECK(Extension::IdIsValid(id));
   ScopedExtensionPrefUpdate update(prefs_, id);
@@ skipping 696 matching lines @@
     result.AddPattern(entry);
   }
 
   return result;
 }
 
 // static
 void ExtensionPrefs::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(kExtensionsPref, PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(kExtensionToolbar, PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterListPref(kExtensionActionBox, PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterListPref(kExtensionActionBoxBar, PrefService::UNSYNCABLE_PREF);
   prefs->RegisterIntegerPref(prefs::kExtensionToolbarSize,
                              -1,  // default value
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterDictionaryPref(kExtensionsBlacklistUpdate,
                                 PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallAllowList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallDenyList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallForceList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(kWebStoreLogin,
                             std::string(),  // default value
                             PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(prefs::kExtensionBlacklistUpdateVersion,
                             "0",  // default value
                             PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kLastExtensionsUpdateCheck,
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kNextExtensionsUpdateCheck,
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionAllowedInstallSites,
                           PrefService::UNSYNCABLE_PREF);
 }
+
+std::vector<std::string> ExtensionPrefs::GetExtensionsOrder(const char* pref) {
+  ExtensionIdSet extension_ids;
+  const ListValue* list_of_values = prefs_->GetList(pref);
+  if (list_of_values) {

[Aaron Boodman, 2012/07/02 22:41:34]

Reverse check and return early.

[yefimt, 2012/07/11 22:34:34]

Done.

+    for (size_t i = 0; i < list_of_values->GetSize(); ++i) {
+      std::string extension_id;
+      if (list_of_values->GetString(i, &extension_id))
+        extension_ids.push_back(extension_id);
+    }
+  }
+  return extension_ids;
+}
+
+void ExtensionPrefs::SetExtensionsOrder(const char* pref,
+    const std::vector<std::string>& strings) {
+  ListPrefUpdate update(prefs_, pref);
+  ListValue* list_of_values = update.Get();
+  list_of_values->Clear();
+  for (std::vector<std::string>::const_iterator iter = strings.begin();
+       iter != strings.end(); ++iter) {
+    list_of_values->Append(new StringValue(*iter));
+  }
+}