Added Instant preference syncing and tests.

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2011 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_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 879 matching lines @@
   }
 
   // Extract the data we need for sync now, but don't actually sync until we've
   // completed the uninstallation.
   SyncBundle* sync_bundle = GetSyncBundleForExtension(*extension);
 
   SyncChange sync_change;
   if (sync_bundle) {
     ExtensionSyncData extension_sync_data(*extension,
                                           IsExtensionEnabled(extension_id),
-                                          IsIncognitoEnabled(extension_id));
+                                          IsIncognitoEnabled(extension_id),
+                                          GetAppLaunchIndex(extension_id),
+                                          GetPageIndex(extension_id));
     sync_change = extension_sync_data.GetSyncChange(SyncChange::ACTION_DELETE);
   }
 
   UninstalledExtensionInfo uninstalled_extension_info(*extension);
 
   UMA_HISTOGRAM_ENUMERATION("Extensions.UninstallType",
                             extension->GetType(), 100);
   RecordPermissionMessagesHistogram(
       extension, "Extensions.Permissions_Uninstall");
 
@@ skipping 817 matching lines @@
 bool ExtensionService::SyncBundle::HasPendingExtensionId(const std::string& id)
     const {
   return pending_sync_data.find(id) != pending_sync_data.end();
 }
 
 void ExtensionService::SyncExtensionChangeIfNeeded(const Extension& extension) {
   SyncBundle* sync_bundle = GetSyncBundleForExtension(extension);
   if (sync_bundle) {
     ExtensionSyncData extension_sync_data(extension,
                                           IsExtensionEnabled(extension.id()),
-                                          IsIncognitoEnabled(extension.id()));
+                                          IsIncognitoEnabled(extension.id()),
+                                          GetAppLaunchIndex(extension.id()),
+                                          GetPageIndex(extension.id()));
 
     SyncChangeList sync_change_list(1, extension_sync_data.GetSyncChange(
         sync_bundle->HasExtensionId(extension.id()) ?
             SyncChange::ACTION_UPDATE : SyncChange::ACTION_ADD));
     sync_bundle->sync_processor->ProcessSyncChanges(
         FROM_HERE, sync_change_list);
     sync_bundle->synced_extensions.insert(extension.id());
     sync_bundle->pending_sync_data.erase(extension.id());
   }
 }
@@ skipping 124 matching lines @@
     SyncBundle* bundle = GetSyncBundleForExtensionSyncData(extension_sync_data);
     CHECK(bundle);
 
     if (extension_sync_data.uninstalled())
       bundle->synced_extensions.erase(extension_sync_data.id());
     else
       bundle->synced_extensions.insert(extension_sync_data.id());
     ProcessExtensionSyncData(extension_sync_data, *bundle);
   }
 
+  // Because the sync data includes the positions of applications it is
+  // possible for the applications to have been reordered due to the sync.
+  NotificationService::current()->Notify(
+      chrome::NOTIFICATION_EXTENSION_LAUNCHER_REORDERED,
+      Source<ExtensionService>(this),
+      NotificationService::NoDetails());
+
   return SyncError();
 }
 
 void ExtensionService::GetSyncDataListHelper(
     const ExtensionList& extensions,
     const SyncBundle& bundle,
     std::vector<ExtensionSyncData>* sync_data_list) const {
   for (ExtensionList::const_iterator it = extensions.begin();
        it != extensions.end(); ++it) {
     const Extension& extension = **it;
     if (bundle.filter(extension) &&
         // If we have pending extension data for this extension, then this
         // version is out of date.  We'll sync back the version we got from
         // sync.
         !bundle.HasPendingExtensionId(extension.id())) {
       sync_data_list->push_back(
           ExtensionSyncData(extension,
                             IsExtensionEnabled(extension.id()),
-                            IsIncognitoEnabled(extension.id())));
+                            IsIncognitoEnabled(extension.id()),
+                            GetAppLaunchIndex(extension.id()),
+                            GetPageIndex(extension.id())));
     }
   }
 }
 
 std::vector<ExtensionSyncData> ExtensionService::GetSyncDataList(
     const SyncBundle& bundle) const {
   std::vector<ExtensionSyncData> extension_sync_list;
   GetSyncDataListHelper(extensions_, bundle, &extension_sync_list);
   GetSyncDataListHelper(disabled_extensions_, bundle, &extension_sync_list);
   GetSyncDataListHelper(terminated_extensions_, bundle, &extension_sync_list);
@@ skipping 30 matching lines @@
     return;
   }
 
   // Set user settings.
   if (extension_sync_data.enabled()) {
     EnableExtension(id);
   } else {
     DisableExtension(id);
   }
   SetIsIncognitoEnabled(id, extension_sync_data.incognito_enabled());
+  SetAppLaunchIndex(id, extension_sync_data.app_launch_index());
+  SetPageIndex(id, extension_sync_data.page_index());
 
   if (extension) {
     // If the extension is already installed, check if it's outdated.
     int result = extension->version()->CompareTo(extension_sync_data.version());
     if (result < 0) {
       // Extension is outdated.
       bundle.pending_sync_data[extension_sync_data.id()] = extension_sync_data;
       CheckForUpdatesSoon();
     }
   } else {
@@ skipping 71 matching lines @@
 
 bool ExtensionService::CanLoadInIncognito(const Extension* extension) const {
   if (extension->is_hosted_app())
     return true;
   // Packaged apps and regular extensions need to be enabled specifically for
   // incognito (and split mode should be set).
   return extension->incognito_split_mode() &&
          IsIncognitoEnabled(extension->id());
 }
 
+void ExtensionService::SetAppLauncherOrder(
+    const std::vector<std::string>& extension_ids) {
+  extension_prefs_->SetAppLauncherOrder(extension_ids);
+
+  for (size_t i=0; i < extension_ids.size(); ++i) {
+    SetAppLaunchIndex(extension_ids[i], i);
+  }
+}
+
+int32 ExtensionService::GetAppLaunchIndex(const std::string& extension_id)
+    const {
+  return extension_prefs_->GetAppLaunchIndex(extension_id);
+}
+
+void ExtensionService::SetAppLaunchIndex(const std::string& extension_id,
+                                         int32 app_launch_index) {
+  extension_prefs_->SetAppLaunchIndex(extension_id, app_launch_index);
+
+  const Extension* extension = GetInstalledExtension(extension_id);
+  if (extension) {
+    SyncExtensionChangeIfNeeded(*extension);
+  }
+}
+
+int32 ExtensionService::GetPageIndex(const std::string& extension_id) const {
+  return extension_prefs_->GetPageIndex(extension_id);
+}
+
+void ExtensionService::SetPageIndex(const std::string& extension_id,
+                                    int32 page_index) {
+  extension_prefs_->SetPageIndex(extension_id, page_index);
+
+  const Extension* extension = GetInstalledExtension(extension_id);
+  if (extension) {
+    SyncExtensionChangeIfNeeded(*extension);
+  }
+}
+
 bool ExtensionService::AllowFileAccess(const Extension* extension) {
   return (CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kDisableExtensionsFileAccessCheck) ||
           extension_prefs_->AllowFileAccess(extension->id()));
 }
 
 void ExtensionService::SetAllowFileAccess(const Extension* extension,
                                           bool allow) {
   // Reload to update browser state. Only bother if the value changed and the
   // extension is actually enabled, since there is no UI otherwise.
@@ skipping 847 matching lines @@
 
 ExtensionService::NaClModuleInfoList::iterator
     ExtensionService::FindNaClModule(const GURL& url) {
   for (NaClModuleInfoList::iterator iter = nacl_module_list_.begin();
        iter != nacl_module_list_.end(); ++iter) {
     if (iter->url == url)
       return iter;
   }
   return nacl_module_list_.end();
 }