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_->GetDisableReasons(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_->GetDisableReasons(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 184 matching lines @@
     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.
   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)) {
+    Extension::DisableReason reason = Extension::DISABLE_UNKNOWN_FROM_SYNC;
+    if (extension_sync_data.remote_install())

[Yoyo Zhou, 2014/05/01 22:53:44]

I would prefer that this be written more clearly to indicate that REMOTE_INSTALL
and UNKNOWN_FROM_SYNC are mutually exclusive. You can expand the comments above
as well.

[Marijn Kruisselbrink, 2014/05/05 20:45:36]

Okay, I changed this around a bit.

+      reason = Extension::DISABLE_REMOTE_INSTALL;
+    extension_service_->DisableExtension(id, reason);
+  }
 
   // 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);
   }
 }