[Extensions] Sync the 'allowed scripting on all urls' preference

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 24 matching lines @@
 #include "extensions/common/image_util.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/manifest_handlers/icons_handler.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_error_factory.h"
 #include "ui/gfx/image/image_family.h"
 
 using extensions::Extension;
 using extensions::ExtensionPrefs;
 using extensions::ExtensionRegistry;
+using extensions::ExtensionSyncData;
 using extensions::FeatureSwitch;
 
 namespace {
 
 void OnWebApplicationInfoLoaded(
     WebApplicationInfo synced_info,
     base::WeakPtr<ExtensionService> extension_service,
     const WebApplicationInfo& loaded_info) {
   DCHECK_EQ(synced_info.app_url, loaded_info.app_url);
 
   if (!extension_service)
     return;
 
   // Use the old icons if they exist.
   synced_info.icons = loaded_info.icons;
   CreateOrUpdateBookmarkApp(extension_service.get(), &synced_info);
 }
 
+// Returns the pref value for "all urls enabled" for the given extension id.
+ExtensionSyncData::OptionalBoolean GetAllowedOnAllUrlsOptionalBoolean(
+    const std::string& extension_id,
+    content::BrowserContext* context) {
+  bool allowed_on_all_urls =
+      extensions::util::AllowedScriptingOnAllUrls(extension_id, context);
+  // If the extension is not allowed on all urls (which is not the default),
+  // then we have to sync the preference.
+  if (!allowed_on_all_urls)
+    return ExtensionSyncData::BOOLEAN_FALSE;
+
+  // If the user has explicitly set a value, then we sync it.
+  if (extensions::util::HasSetAllowedScriptingOnAllUrls(extension_id, context))
+    return ExtensionSyncData::BOOLEAN_TRUE;
+
+  // Otherwise, unset.
+  return ExtensionSyncData::BOOLEAN_UNSET;
+}
+
 }  // namespace
 
 ExtensionSyncService::ExtensionSyncService(Profile* profile,
                                            ExtensionPrefs* extension_prefs,
                                            ExtensionService* extension_service)
     : profile_(profile),
       extension_prefs_(extension_prefs),
       extension_service_(extension_service),
       app_sync_bundle_(this),
       extension_sync_bundle_(this),
@@ skipping 160 matching lines @@
   return syncer::SyncDataList();
 }
 
 syncer::SyncError ExtensionSyncService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const syncer::SyncChangeList& change_list) {
   for (syncer::SyncChangeList::const_iterator i = change_list.begin();
       i != change_list.end();
       ++i) {
     syncer::ModelType type = i->sync_data().GetDataType();
-    if (type == syncer::EXTENSIONS) {
-      extension_sync_bundle_.ProcessSyncChange(
-          extensions::ExtensionSyncData(*i));
-    } else if (type == syncer::APPS) {
+    if (type == syncer::EXTENSIONS)
+      extension_sync_bundle_.ProcessSyncChange(ExtensionSyncData(*i));
+    else if (type == syncer::APPS)
       app_sync_bundle_.ProcessSyncChange(extensions::AppSyncData(*i));
-    }
   }
 
   extension_prefs_->app_sorting()->FixNTPOrdinalCollisions();
 
   return syncer::SyncError();
 }
 
-extensions::ExtensionSyncData ExtensionSyncService::GetExtensionSyncData(
+ExtensionSyncData ExtensionSyncService::GetExtensionSyncData(
     const Extension& extension) const {
-  return extensions::ExtensionSyncData(
+  return ExtensionSyncData(
       extension,
       extension_service_->IsExtensionEnabled(extension.id()),
       extensions::util::IsIncognitoEnabled(extension.id(), profile_),
       extension_prefs_->HasDisableReason(extension.id(),
-                                         Extension::DISABLE_REMOTE_INSTALL));
+                                         Extension::DISABLE_REMOTE_INSTALL),
+      GetAllowedOnAllUrlsOptionalBoolean(extension.id(), profile_));
 }
 
 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),
+      GetAllowedOnAllUrlsOptionalBoolean(extension.id(), profile_),
       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 {
+std::vector<ExtensionSyncData>
+    ExtensionSyncService::GetExtensionSyncDataList() const {
   ExtensionRegistry* registry = ExtensionRegistry::Get(profile_);
-  std::vector<extensions::ExtensionSyncData> extension_sync_list;
+  std::vector<ExtensionSyncData> extension_sync_list;
   extension_sync_bundle_.GetExtensionSyncDataListHelper(
       registry->enabled_extensions(), &extension_sync_list);
   extension_sync_bundle_.GetExtensionSyncDataListHelper(
       registry->disabled_extensions(), &extension_sync_list);
   extension_sync_bundle_.GetExtensionSyncDataListHelper(
       registry->terminated_extensions(), &extension_sync_list);
 
-  std::vector<extensions::ExtensionSyncData> pending_extensions =
+  std::vector<ExtensionSyncData> pending_extensions =
       extension_sync_bundle_.GetPendingData();
   extension_sync_list.insert(extension_sync_list.begin(),
                              pending_extensions.begin(),
                              pending_extensions.end());
 
   return extension_sync_list;
 }
 
 std::vector<extensions::AppSyncData> ExtensionSyncService::GetAppSyncDataList()
     const {
   ExtensionRegistry* registry = ExtensionRegistry::Get(profile_);
   std::vector<extensions::AppSyncData> app_sync_list;
   app_sync_bundle_.GetAppSyncDataListHelper(
       registry->enabled_extensions(), &app_sync_list);
   app_sync_bundle_.GetAppSyncDataListHelper(
       registry->disabled_extensions(), &app_sync_list);
   app_sync_bundle_.GetAppSyncDataListHelper(
       registry->terminated_extensions(), &app_sync_list);
 
   std::vector<extensions::AppSyncData> pending_apps =
       app_sync_bundle_.GetPendingData();
   app_sync_list.insert(app_sync_list.begin(),
                        pending_apps.begin(),
                        pending_apps.end());
 
   return app_sync_list;
 }
 
 bool ExtensionSyncService::ProcessExtensionSyncData(
-    const extensions::ExtensionSyncData& extension_sync_data) {
+    const ExtensionSyncData& extension_sync_data) {
   if (!ProcessExtensionSyncDataHelper(extension_sync_data,
                                       syncer::EXTENSIONS)) {
     extension_sync_bundle_.AddPendingExtension(extension_sync_data.id(),
                                                extension_sync_data);
     extension_service_->CheckForUpdatesSoon();
     return false;
   }
 
   return true;
 }
@@ skipping 105 matching lines @@
   return false;
 }
 
 bool ExtensionSyncService::IsPendingEnable(
     const std::string& extension_id) const {
   return pending_app_enables_.Contains(extension_id) ||
       pending_extension_enables_.Contains(extension_id);
 }
 
 bool ExtensionSyncService::ProcessExtensionSyncDataHelper(
-    const extensions::ExtensionSyncData& extension_sync_data,
+    const ExtensionSyncData& extension_sync_data,
     syncer::ModelType type) {
   const std::string& id = extension_sync_data.id();
   const Extension* extension = extension_service_->GetInstalledExtension(id);
 
   // TODO(bolms): we should really handle this better.  The particularly bad
   // case is where an app becomes an extension or vice versa, and we end up with
   // a zombie extension that won't go away.
   if (extension && !IsCorrectSyncType(*extension, type))
     return true;
 
@@ skipping 48 matching lines @@
   // be promoted to a regular installed extension and downloading from the Web
   // Store is not necessary.
   if (extension && extensions::util::IsEphemeralApp(id, profile_))
     extension_service_->PromoteEphemeralApp(extension, true);
 
   // Update the incognito flag.
   extensions::util::SetIsIncognitoEnabled(
       id, profile_, extension_sync_data.incognito_enabled());
   extension = NULL;  // No longer safe to use.
 
+  // Update the all urls flag.
+  if (extension_sync_data.all_urls_enabled() !=
+          ExtensionSyncData::BOOLEAN_UNSET) {
+    bool allowed = extension_sync_data.all_urls_enabled() ==
+        ExtensionSyncData::BOOLEAN_TRUE;
+    extensions::util::SetAllowedScriptingOnAllUrls(id, profile_, allowed);
+  }
+
   if (extension_installed) {
     // If the extension is already installed, check if it's outdated.
     if (version_compare_result < 0) {
       // Extension is outdated.
       return false;
     }
   } else {
     CHECK(type == syncer::EXTENSIONS || type == syncer::APPS);
     extensions::PendingExtensionInfo::ShouldAllowInstallPredicate filter =
         (type == syncer::APPS) ? extensions::sync_helper::IsSyncableApp :
@@ skipping 25 matching lines @@
       app_sync_bundle_.SyncChangeIfNeeded(extension);
     else if (extension_service_->is_ready() && !flare_.is_null())
       flare_.Run(syncer::APPS);
   } else if (extensions::util::ShouldSyncExtension(&extension, profile_)) {
     if (extension_sync_bundle_.IsSyncing())
       extension_sync_bundle_.SyncChangeIfNeeded(extension);
     else if (extension_service_->is_ready() && !flare_.is_null())
       flare_.Run(syncer::EXTENSIONS);
   }
 }