Support remote installation of extensions and apps.

chrome/browser/extensions/extension_sync_service.cc

 // Copyright 2013 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_sync_service.h"
 
 #include <iterator>
 
 #include "base/basictypes.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 236 matching lines @@
   extension_prefs_->app_sorting()->FixNTPOrdinalCollisions();
 
   return syncer::SyncError();
 }
 
 extensions::ExtensionSyncData ExtensionSyncService::GetExtensionSyncData(
     const Extension& extension) const {
   return extensions::ExtensionSyncData(
       extension,
       extension_service_->IsExtensionEnabled(extension.id()),
-      extensions::util::IsIncognitoEnabled(extension.id(), profile_));
+      extensions::util::IsIncognitoEnabled(extension.id(), profile_),
+      extension_prefs_->HasDisableReason(extension.id(),
+                                         Extension::DISABLE_REMOTE_INSTALL));
 }
 
 extensions::AppSyncData ExtensionSyncService::GetAppSyncData(
     const Extension& extension) const {
   return extensions::AppSyncData(
       extension,
       extension_service_->IsExtensionEnabled(extension.id()),
       extensions::util::IsIncognitoEnabled(extension.id(), profile_),
+      extension_prefs_->HasDisableReason(extension.id(),
+                                         Extension::DISABLE_REMOTE_INSTALL),
       extension_prefs_->app_sorting()->GetAppLaunchOrdinal(extension.id()),
       extension_prefs_->app_sorting()->GetPageOrdinal(extension.id()),
       extensions::GetLaunchTypePrefValue(extension_prefs_, extension.id()));
 }
 
 std::vector<extensions::ExtensionSyncData>
   ExtensionSyncService::GetExtensionSyncDataList() const {
   ExtensionRegistry* registry = ExtensionRegistry::Get(profile_);
   std::vector<extensions::ExtensionSyncData> extension_sync_list;
   extension_sync_bundle_.GetExtensionSyncDataListHelper(
@@ skipping 182 matching lines @@
     LOG(WARNING) << "Extension with id " << id
                  << " from sync was uninstalled as external extension";
     return true;
   }
 
   // Set user settings.
   // If the extension has been disabled from sync, it may not have
   // been installed yet, so we don't know if the disable reason was a
   // permissions increase.  That will be updated once CheckPermissionsIncrease
   // is called for it.
+  // However if the extension is marked as a remote install in sync, we know
+  // what the disable reason is, so set it to that directly. Note that when
+  // CheckPermissionsIncrease runs, it might still add permissions increase
+  // as a disable reason for the extension.
   if (extension_sync_data.enabled())
     extension_service_->EnableExtension(id);
-  else if (!IsPendingEnable(id))
-    extension_service_->DisableExtension(
-        id, Extension::DISABLE_UNKNOWN_FROM_SYNC);
+  else if (!IsPendingEnable(id)) {
+    if (extension_sync_data.remote_install()) {
+      extension_service_->DisableExtension(id,
+                                           Extension::DISABLE_REMOTE_INSTALL);
+    } else {
+      extension_service_->DisableExtension(
+          id, Extension::DISABLE_UNKNOWN_FROM_SYNC);
+    }
+  }
 
   // We need to cache some version information here because setting the
   // incognito flag invalidates the |extension| pointer (it reloads the
   // extension).
   bool extension_installed = (extension != NULL);
   int result = extension ?
       extension->version()->CompareTo(extension_sync_data.version()) : 0;
   extensions::util::SetIsIncognitoEnabled(
       id, profile_, extension_sync_data.incognito_enabled());
   extension = NULL;  // No longer safe to use.
@@ skipping 11 matching lines @@
 
     CHECK(type == syncer::EXTENSIONS || type == syncer::APPS);
     extensions::PendingExtensionInfo::ShouldAllowInstallPredicate filter =
         (type == syncer::APPS) ? extensions::sync_helper::IsSyncableApp :
                                  extensions::sync_helper::IsSyncableExtension;
 
     if (!extension_service_->pending_extension_manager()->AddFromSync(
             id,
             extension_sync_data.update_url(),
             filter,
-            kInstallSilently)) {
+            kInstallSilently,
+            extension_sync_data.remote_install())) {
       LOG(WARNING) << "Could not add pending extension for " << id;
       // This means that the extension is already pending installation, with a
       // non-INTERNAL location.  Add to pending_sync_data, even though it will
       // never be removed (we'll never install a syncable version of the
       // extension), so that GetAllSyncData() continues to send it.
     }
     // Track pending extensions so that we can return them in GetAllSyncData().
     return false;
   }
 
   return true;
 }
 
 void ExtensionSyncService::SyncExtensionChangeIfNeeded(
     const Extension& extension) {
   if (extensions::sync_helper::IsSyncableApp(&extension)) {
     if (app_sync_bundle_.IsSyncing())
       app_sync_bundle_.SyncChangeIfNeeded(extension);
     else if (extension_service_->is_ready() && !flare_.is_null())
       flare_.Run(syncer::APPS);
   } else if (extensions::sync_helper::IsSyncableExtension(&extension)) {
     if (extension_sync_bundle_.IsSyncing())
       extension_sync_bundle_.SyncChangeIfNeeded(extension);
     else if (extension_service_->is_ready() && !flare_.is_null())
       flare_.Run(syncer::EXTENSIONS);
   }
 }