[Sync] Move some extension-sync-related logic to ExtensionService

chrome/browser/sync/glue/extension_util.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/sync/glue/extension_util.h"
 
 #include <sstream>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util-inl.h"
 #include "base/version.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_sync_data.h"
 #include "chrome/browser/sync/protocol/extension_specifics.pb.h"
-#include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 
 namespace browser_sync {
 
 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;
   }
@@ skipping 123 matching lines @@
   bool incognito_enabled = extension_service.IsIncognitoEnabled(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(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 MergeExtensionSpecifics(
     const sync_pb::ExtensionSpecifics& specifics,
     bool merge_user_properties,
     sync_pb::ExtensionSpecifics* merged_specifics) {
   DcheckIsExtensionSpecificsValid(*merged_specifics);
   DcheckIsExtensionSpecificsValid(specifics);
   DCHECK_EQ(specifics.id(), merged_specifics->id());
   // TODO(akalin): Merge enabled permissions when we sync those.
   scoped_ptr<Version> version(
       Version::GetVersionFromString(specifics.version()));
   CHECK(version.get());
   scoped_ptr<Version> merged_version(
       Version::GetVersionFromString(merged_specifics->version()));
   CHECK(merged_version.get());
   if (version->CompareTo(*merged_version) >= 0) {
     // |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);
     }
   }
 }
 
+bool GetExtensionSyncData(
+    const sync_pb::ExtensionSpecifics& specifics,
+    ExtensionSyncData* sync_data) {
+  if (!Extension::IdIsValid(specifics.id())) {
+    return false;
+  }
+
+  scoped_ptr<Version> version(
+      Version::GetVersionFromString(specifics.version()));
+  if (!version.get()) {
+    return false;
+  }
+
+  // The update URL must be either empty or valid.
+  GURL update_url(specifics.update_url());
+  if (!update_url.is_empty() && !update_url.is_valid()) {
+    return false;
+  }
+
+  sync_data->id = specifics.id();
+  sync_data->update_url = update_url;
+  sync_data->version = *version;
+  sync_data->enabled = specifics.enabled();
+  sync_data->incognito_enabled = specifics.incognito_enabled();
+  return true;
+}
+
+bool IsSyncableExtension(Extension::Type type, const GURL& update_url) {
+  switch (type) {
+    case Extension::TYPE_EXTENSION:
+      return true;
+    case Extension::TYPE_USER_SCRIPT:
+      // We only want to sync user scripts with update URLs.
+      return !update_url.is_empty();
+    default:
+      return false;
+  }
+}
+
+bool IsValidAndSyncableExtension(const Extension& extension) {
+  return
+      IsExtensionValid(extension) &&
+      IsSyncableExtension(extension.GetType(), extension.update_url());
+}
+
+bool IsSyncableApp(Extension::Type type) {
+  return
+      (type == Extension::TYPE_HOSTED_APP) ||
+      (type == Extension::TYPE_PACKAGED_APP);
+}
+
+bool IsValidAndSyncableApp(
+    const Extension& extension) {
+  return IsExtensionValid(extension) && IsSyncableApp(extension.GetType());
+}
+
 }  // namespace browser_sync