[Sync] Add support for enabling/disabling an extension before it's installed

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 731 matching lines @@
 }
 
 bool ExtensionService::IsExternalExtensionUninstalled(
     const std::string& extension_id) const {
   return extension_prefs_->IsExternalExtensionUninstalled(extension_id);
 }
 
 void ExtensionService::EnableExtension(const std::string& extension_id) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  const Extension* extension =
-      GetExtensionByIdInternal(extension_id, false, true, false);
-  if (!extension)
+  if (IsExtensionEnabled(extension_id))
     return;
 
   extension_prefs_->SetExtensionState(extension_id, Extension::ENABLED);
 
+  const Extension* extension =
+      GetExtensionByIdInternal(extension_id, false, true, false);
+  // This can happen if sync enables an extension that is not
+  // installed yet.
+  if (!extension)
+    return;
+
   // Move it over to the enabled list.
   extensions_.push_back(make_scoped_refptr(extension));
   ExtensionList::iterator iter = std::find(disabled_extensions_.begin(),
                                            disabled_extensions_.end(),
                                            extension);
   disabled_extensions_.erase(iter);
 
   // Make sure any browser action contained within it is not hidden.
   extension_prefs_->SetBrowserActionVisibility(extension, true);
 
   NotifyExtensionLoaded(extension);
 }
 
 void ExtensionService::DisableExtension(const std::string& extension_id) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  const Extension* extension =
-      GetExtensionByIdInternal(extension_id, true, false, false);
   // The extension may have been disabled already.
-  if (!extension)
+  if (!IsExtensionEnabled(extension_id))
     return;
 
-  if (!Extension::UserMayDisable(extension->location()))
+  const Extension* extension = GetInstalledExtension(extension_id);
+  // |extension| can be NULL if sync disables an extension that is not
+  // installed yet.
+  if (extension && !Extension::UserMayDisable(extension->location()))
     return;
 
   extension_prefs_->SetExtensionState(extension_id, Extension::DISABLED);
 
+  extension = GetExtensionByIdInternal(extension_id, true, false, true);
+  if (!extension)
+    return;
+
   // Move it over to the disabled list.
   disabled_extensions_.push_back(make_scoped_refptr(extension));
   ExtensionList::iterator iter = std::find(extensions_.begin(),
                                            extensions_.end(),
                                            extension);
-  extensions_.erase(iter);
+  if (iter != extensions_.end()) {
+    extensions_.erase(iter);
+  } else {
+    iter = std::find(terminated_extensions_.begin(),
+                     terminated_extensions_.end(),
+                     extension);
+    terminated_extensions_.erase(iter);
+  }
 
   NotifyExtensionUnloaded(extension, UnloadedExtensionInfo::DISABLE);
 }
 
 void ExtensionService::GrantPermissions(const Extension* extension) {
   CHECK(extension);
 
   // We only maintain the granted permissions prefs for INTERNAL extensions.
   CHECK_EQ(Extension::INTERNAL, extension->location());
 
@@ skipping 543 matching lines @@
   // Handle uninstalls first.
   if (extension_sync_data.uninstalled) {
     std::string error;
     if (!UninstallExtensionHelper(this, id)) {
       LOG(WARNING) << "Could not uninstall extension " << id
                    << " for sync";
     }
     return;
   }
 
+  // Set user settings.
+  if (extension_sync_data.enabled) {
+    EnableExtension(id);
+  } else {
+    DisableExtension(id);
+  }
   SetIsIncognitoEnabled(id, extension_sync_data.incognito_enabled);
 
-  const Extension* extension =
-      GetExtensionByIdInternal(id, true, true, false);
-  // TODO(akalin): Figure out what to do with terminated extensions.
-
-  // Handle already-installed extensions.
+  const Extension* extension = GetInstalledExtension(id);
   if (extension) {
-    // TODO(akalin): Make it so we can enable/disable an extension
-    // even if it's not installed yet.
-    if (extension_sync_data.enabled) {
-      EnableExtension(id);
-    } else {
-      DisableExtension(id);
-    }
+    // 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.
       CheckForUpdatesSoon();
     } else if (result > 0) {
       // Sync version is outdated.  Do nothing for now, as sync code
       // in other places will eventually update the sync data.
       //
       // TODO(akalin): Move that code here.
     }
     return;
+  } else {
+    // TODO(akalin): Remove need to pass the enabled flag.
+    //
+    // TODO(akalin): Replace silent update with a list of enabled
+    // permissions.
+    if (!pending_extension_manager()->AddFromSync(
+            id,
+            extension_sync_data.update_url,
+            filter,
+            true,  // install_silently
+            extension_sync_data.enabled)) {
+      LOG(WARNING) << "Could not add pending extension for " << id;
+      return;
+    }
+    CheckForUpdatesSoon();
   }
-
-  // Handle not-yet-installed extensions.
-  //
-  // TODO(akalin): Replace silent update with a list of enabled
-  // permissions.
-  if (!pending_extension_manager()->AddFromSync(
-          id,
-          extension_sync_data.update_url,
-          filter,
-          true,  // install_silently
-          extension_sync_data.enabled)) {
-    LOG(WARNING) << "Could not add pending extension for " << id;
-    return;
-  }
-  CheckForUpdatesSoon();
 }
 
 bool ExtensionService::IsIncognitoEnabled(
     const std::string& extension_id) const {
   // If this is an existing component extension we always allow it to
   // work in incognito mode.
   const Extension* extension = GetInstalledExtension(extension_id);
   if (extension && extension->location() == Extension::COMPONENT)
     return true;
 
@@ skipping 784 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();
 }