Added flag --extensions-in-action-box to split Action Box and Extensions in it.

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 262 matching lines @@
     case kExtensionPrefsScopeIncognitoPersistent:
       *result = kPrefIncognitoPreferences;
       return true;
     case kExtensionPrefsScopeIncognitoSessionOnly:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
+const char* GetToolbarOrderKeyName() {
+  return switch_utils::IsExtensionsInActionBoxEnabled() ?
+      kExtensionActionBoxBar : kExtensionToolbar;
+}
+
+const char* GetToolbarVisibilityKeyName() {
+  return switch_utils::IsExtensionsInActionBoxEnabled() ?
+      kBrowserActionPinned : kBrowserActionVisible;
+}
+
 }  // namespace
 
 ExtensionPrefs::ExtensionPrefs(
     PrefService* prefs,
     const FilePath& root_dir,
     ExtensionPrefValueMap* extension_pref_value_map)
     : prefs_(prefs),
       install_directory_(root_dir),
       extension_pref_value_map_(extension_pref_value_map),
       ALLOW_THIS_IN_INITIALIZER_LIST(extension_sorting_(
@@ skipping 1018 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);
 }
 
 ExtensionPrefs::ExtensionIdSet ExtensionPrefs::GetToolbarOrder() {
-  bool action_box_enabled = extensions::switch_utils::IsActionBoxEnabled();
-  return GetExtensionPrefAsVector(
-      action_box_enabled ? kExtensionActionBoxBar : kExtensionToolbar);
+  return GetExtensionPrefAsVector(GetToolbarOrderKeyName());
 }
 
 void ExtensionPrefs::SetToolbarOrder(const ExtensionIdSet& extension_ids) {
-  SetExtensionPrefFromVector(extensions::switch_utils::IsActionBoxEnabled() ?
-      kExtensionActionBoxBar : kExtensionToolbar, extension_ids);
+  SetExtensionPrefFromVector(GetToolbarOrderKeyName(), extension_ids);
 }
 
 ExtensionPrefs::ExtensionIdSet ExtensionPrefs::GetActionBoxOrder() {
   return GetExtensionPrefAsVector(kExtensionActionBox);
 }
 
 void ExtensionPrefs::SetActionBoxOrder(const ExtensionIdSet& extension_ids) {
   SetExtensionPrefFromVector(kExtensionActionBox, extension_ids);
 }
 
@@ skipping 75 matching lines @@
 void ExtensionPrefs::SetExtensionState(const std::string& extension_id,
                                        Extension::State state) {
   UpdateExtensionPref(extension_id, kPrefState,
                       Value::CreateIntegerValue(state));
   bool enabled = (state == Extension::ENABLED);
   extension_pref_value_map_->SetExtensionState(extension_id, enabled);
   content_settings_store_->SetExtensionState(extension_id, enabled);
 }
 
 bool ExtensionPrefs::GetBrowserActionVisibility(const Extension* extension) {
-  bool action_box_enabled = switch_utils::IsActionBoxEnabled();
-  bool default_value = !action_box_enabled;
+  bool extensions_in_action_box_enabled =
+      switch_utils::IsExtensionsInActionBoxEnabled();
+  bool default_value = !extensions_in_action_box_enabled;
 
   const DictionaryValue* extension_prefs = GetExtensionPref(extension->id());
   if (!extension_prefs)
     return default_value;
 
   bool visible = false;
-  const char* browser_action_pref = action_box_enabled ? kBrowserActionPinned :
-                                                         kBrowserActionVisible;
-  bool pref_exists = extension_prefs->GetBoolean(browser_action_pref, &visible);
+  bool pref_exists = extension_prefs->GetBoolean(GetToolbarVisibilityKeyName(),
+                                                 &visible);
   if (!pref_exists)
     return default_value;
 
   return visible;
 }
 
 void ExtensionPrefs::SetBrowserActionVisibility(const Extension* extension,
                                                 bool visible) {
   if (GetBrowserActionVisibility(extension) == visible)
     return;
 
-  bool action_box_enabled = switch_utils::IsActionBoxEnabled();
-  const char* browser_action_pref = action_box_enabled ? kBrowserActionPinned :
-                                                         kBrowserActionVisible;
-  UpdateExtensionPref(extension->id(), browser_action_pref,
+  UpdateExtensionPref(extension->id(), GetToolbarVisibilityKeyName(),
                       Value::CreateBooleanValue(visible));
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED,
       content::Source<ExtensionPrefs>(this),
       content::Details<const Extension>(extension));
 }
 
 std::string ExtensionPrefs::GetVersionString(const std::string& extension_id) {
   const DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension)
@@ skipping 638 matching lines @@
                                                 const ExtensionIdSet& strings) {
   ListPrefUpdate update(prefs_, pref);
   ListValue* list_of_values = update.Get();
   list_of_values->Clear();
   for (ExtensionIdSet::const_iterator iter = strings.begin();
        iter != strings.end(); ++iter)
     list_of_values->Append(new StringValue(*iter));
 }
 
 }  // namespace extensions