Persist the order of extensions in the browser action toolbar across sessions...

chrome/browser/extensions/extension_prefs.cc

 // Copyright (c) 2009 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_util.h"
 #include "chrome/common/extensions/extension.h"
 
 namespace {
@@ skipping 18 matching lines @@
 
 // The version number.
 const wchar_t kPrefVersion[] = L"manifest.version";
 
 // Indicates if an extension is blacklisted:
 const wchar_t kPrefBlacklist[] = L"blacklist";
 
 // A preference that tracks extension shelf configuration.  This is a list
 // object read from the Preferences file, containing a list of toolstrip URLs.
 const wchar_t kExtensionShelf[] = L"extensions.shelf";
+
+// 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 wchar_t kExtensionToolbar[] = L"extensions.toolbar";
+
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 InstalledExtensions::InstalledExtensions(ExtensionPrefs* prefs) {
   extension_data_.reset(prefs->CopyCurrentExtensions());
 }
 
 InstalledExtensions::~InstalledExtensions() {
 }
@@ skipping 49 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
 ExtensionPrefs::ExtensionPrefs(PrefService* prefs, const FilePath& root_dir)
     : prefs_(prefs),
       install_directory_(root_dir) {
   if (!prefs_->FindPreference(kExtensionsPref))
     prefs_->RegisterDictionaryPref(kExtensionsPref);
   if (!prefs->FindPreference(kExtensionShelf))
     prefs->RegisterListPref(kExtensionShelf);
+  if (!prefs->FindPreference(kExtensionToolbar))
+    prefs->RegisterListPref(kExtensionToolbar);
   MakePathsRelative();
 }
 
 static FilePath::StringType MakePathRelative(const FilePath& parent,
                                              const FilePath& child,
                                              bool *dirty) {
   if (!parent.IsParent(child))
     return child.value();
 
   if (dirty)
@@ skipping 189 matching lines @@
 void ExtensionPrefs::SetShelfToolstripOrder(const URLList& urls) {
   ListValue* toolstrip_urls = prefs_->GetMutableList(kExtensionShelf);
   toolstrip_urls->Clear();
   for (size_t i = 0; i < urls.size(); ++i) {
     GURL url = urls[i];
     toolstrip_urls->Append(new StringValue(url.spec()));
   }
   prefs_->ScheduleSavePersistentPrefs();
 }
 
+std::vector<std::string> ExtensionPrefs::GetToolbarOrder() {
+  std::vector<std::string> 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;
+}
+
+void ExtensionPrefs::SetToolbarOrder(
+    const std::vector<std::string>& extension_ids) {
+  ListValue* toolbar_order = prefs_->GetMutableList(kExtensionToolbar);
+  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));
+  }
+  prefs_->ScheduleSavePersistentPrefs();
+}
+
 void ExtensionPrefs::OnExtensionInstalled(Extension* extension) {
   const std::string& id = extension->id();
   // Make sure we don't enable a disabled extension.
   if (GetExtensionState(extension->id()) != Extension::DISABLED) {
     UpdateExtensionPref(id, kPrefState,
                         Value::CreateIntegerValue(Extension::ENABLED));
   }
   UpdateExtensionPref(id, kPrefLocation,
                       Value::CreateIntegerValue(extension->location()));
   FilePath::StringType path = MakePathRelative(install_directory_,
@@ skipping 106 matching lines @@
 }
 
 DictionaryValue* ExtensionPrefs::GetExtensionPref(
     const std::string& extension_id) {
   const DictionaryValue* dict = prefs_->GetDictionary(kExtensionsPref);
   DictionaryValue* extension = NULL;
   std::wstring id = ASCIIToWide(extension_id);
   dict->GetDictionary(id, &extension);
   return extension;
 }