Massive refactoring of extensions sync code

chrome/browser/sync/glue/extension_util.cc

 // Copyright (c) 2010 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/sync/glue/extension_util.h"
 
 #include <sstream>
 
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
+#include "base/stl_util-inl.h"
 #include "base/version.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/sync/protocol/extension_specifics.pb.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "googleurl/src/gurl.h"
 
 namespace browser_sync {
 
-bool IsExtensionSyncable(const Extension& extension) {
+ExtensionType GetExtensionType(const Extension& extension) {
   if (extension.is_theme()) {
-    return false;
+    return THEME;
   }
 
   // TODO(akalin): Add Extensions::is_app().
   if (!extension.GetFullLaunchURL().is_empty()) {
-    // We have an app.
-    return false;
+    return APP;
   }
 
+  if (extension.converted_from_user_script()) {
+    return USER_SCRIPT;
+  }
+
+  // Otherwise, we just have a regular extension.
+  return EXTENSION;
+}
+
+bool IsExtensionValid(const Extension& extension) {
   // TODO(akalin): Figure out if we need to allow some other types.
   if (extension.location() != Extension::INTERNAL) {
     // We have a non-standard location.
     return false;
   }
 
   // Disallow extensions with non-gallery auto-update URLs for now.
   //
   // TODO(akalin): Relax this restriction once we've put in UI to
   // approve synced extensions.
   if (!extension.update_url().is_empty() &&
       (extension.update_url() !=
        GURL(extension_urls::kGalleryUpdateHttpUrl)) &&
       (extension.update_url() !=
        GURL(extension_urls::kGalleryUpdateHttpsUrl))) {
     return false;
   }
 
   // Disallow extensions with native code plugins.
   //
   // TODO(akalin): Relax this restriction once we've put in UI to
   // approve synced extensions.
   if (!extension.plugins().empty()) {
     return false;
   }
 
   return true;
 }
 
+bool IsExtensionValidAndSyncable(const Extension& extension,
+                                 const ExtensionTypeSet& allowed_types) {
+  return
+      IsExtensionValid(extension) &&
+      ContainsKey(allowed_types, GetExtensionType(extension));
+}
+
 std::string ExtensionSpecificsToString(
     const sync_pb::ExtensionSpecifics& specifics) {
   std::stringstream ss;
   ss << "{ ";
   ss << "id: "                   << specifics.id()                << ", ";
   ss << "version: "              << specifics.version()           << ", ";
   ss << "update_url: "           << specifics.update_url()        << ", ";
   ss << "enabled: "              << specifics.enabled()           << ", ";
   ss << "incognito_enabled: "    << specifics.incognito_enabled() << ", ";
   ss << "name: "                 << specifics.name();
@@ skipping 90 matching lines @@
       extensions_service->GetExtensionById(id, false) != NULL;
   bool incognito_enabled =
       extensions_service->IsIncognitoEnabled(&extension);
   GetExtensionSpecificsHelper(extension, enabled, incognito_enabled,
                               specifics);
 }
 
 void GetExtensionSpecificsHelper(const Extension& extension,
                                  bool enabled, bool incognito_enabled,
                                  sync_pb::ExtensionSpecifics* specifics) {
-  DCHECK(IsExtensionSyncable(extension));
+  DCHECK(IsExtensionValid(extension));
   const std::string& id = extension.id();
   specifics->set_id(id);
   specifics->set_version(extension.VersionString());
   specifics->set_update_url(extension.update_url().spec());
   specifics->set_enabled(enabled);
   specifics->set_incognito_enabled(incognito_enabled);
   specifics->set_name(extension.name());
   DcheckIsExtensionSpecificsValid(*specifics);
 }
 
 bool IsExtensionOutdated(const Extension& extension,
                          const sync_pb::ExtensionSpecifics& specifics) {
-  DCHECK(IsExtensionSyncable(extension));
+  DCHECK(IsExtensionValid(extension));
   DcheckIsExtensionSpecificsValid(specifics);
   scoped_ptr<Version> specifics_version(
       Version::GetVersionFromString(specifics.version()));
   if (!specifics_version.get()) {
     // If version is invalid, assume we're up-to-date.
     return false;
   }
   return extension.version()->CompareTo(*specifics_version) < 0;
 }
 
 void SetExtensionProperties(
     const sync_pb::ExtensionSpecifics& specifics,
     ExtensionsService* extensions_service, Extension* extension) {
   DcheckIsExtensionSpecificsValid(specifics);
   CHECK(extensions_service);
   CHECK(extension);
-  DCHECK(IsExtensionSyncable(*extension));
+  DCHECK(IsExtensionValid(*extension));
   const std::string& id = extension->id();
   GURL update_url(specifics.update_url());
   if (update_url != extension->update_url()) {
     LOG(WARNING) << "specifics for extension " << id
                  << "has a different update URL than the extension: "
                  << update_url.spec() << " vs. " << extension->update_url();
   }
   bool enabled = extensions_service->GetExtensionById(id, false) != NULL;
   if (enabled && !specifics.enabled()) {
     extensions_service->DisableExtension(id);
@@ skipping 31 matching lines @@
     // |specifics| has a more recent or the same version, so merge it
     // in.
     CopyNonUserProperties(specifics, merged_specifics);
     if (merge_user_properties) {
       CopyUserProperties(specifics, merged_specifics);
     }
   }
 }
 
 }  // namespace browser_sync