[Sync] Move ModelType and related classes to 'syncer' namespace

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2012 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_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 745 matching lines @@
 
   UntrackTerminatedExtension(extension_id);
 
   // Notify interested parties that we've uninstalled this extension.
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_UNINSTALLED,
       content::Source<Profile>(profile_),
       content::Details<const std::string>(&extension_id));
 
   if (app_sync_bundle_.HasExtensionId(extension_id) &&
-      sync_change.sync_data().GetDataType() == syncable::APPS) {
+      sync_change.sync_data().GetDataType() == syncer::APPS) {
     app_sync_bundle_.ProcessDeletion(extension_id, sync_change);
   } else if (extension_sync_bundle_.HasExtensionId(extension_id) &&
-             sync_change.sync_data().GetDataType() == syncable::EXTENSIONS) {
+             sync_change.sync_data().GetDataType() == syncer::EXTENSIONS) {
     extension_sync_bundle_.ProcessDeletion(extension_id, sync_change);
   }
 
   // Track the uninstallation.
   UMA_HISTOGRAM_ENUMERATION("Extensions.ExtensionUninstalled", 1, 2);
 
   static bool default_apps_trial_exists =
       base::FieldTrialList::TrialExists(kDefaultAppsTrialName);
   if (default_apps_trial_exists) {
     UMA_HISTOGRAM_ENUMERATION(
@@ skipping 405 matching lines @@
       // during startup. Start the update as soon as those providers are ready,
       // but not before.
       update_once_all_providers_are_ready_ = true;
     }
   } else {
     LOG(WARNING) << "CheckForUpdatesSoon() called with auto-update turned off";
   }
 }
 
 syncer::SyncError ExtensionService::MergeDataAndStartSyncing(
-    syncable::ModelType type,
+    syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
     scoped_ptr<syncer::SyncErrorFactory> sync_error_factory) {
   CHECK(sync_processor.get());
   CHECK(sync_error_factory.get());
 
   switch (type) {
-    case syncable::EXTENSIONS:
+    case syncer::EXTENSIONS:
       extension_sync_bundle_.SetupSync(sync_processor.release(),
                                        sync_error_factory.release(),
                                        initial_sync_data);
       break;
 
-    case syncable::APPS:
+    case syncer::APPS:
       app_sync_bundle_.SetupSync(sync_processor.release(),
                                  sync_error_factory.release(),
                                  initial_sync_data);
       break;
 
     default:
       LOG(FATAL) << "Got " << type << " ModelType";
   }
 
   // Process local extensions.
   // TODO(yoz): Determine whether pending extensions should be considered too.
   //            See crbug.com/104399.
   syncer::SyncDataList sync_data_list = GetAllSyncData(type);
   syncer::SyncChangeList sync_change_list;
   for (syncer::SyncDataList::const_iterator i = sync_data_list.begin();
        i != sync_data_list.end();
        ++i) {
     switch (type) {
-        case syncable::EXTENSIONS:
+        case syncer::EXTENSIONS:
           sync_change_list.push_back(
               extension_sync_bundle_.CreateSyncChange(*i));
           break;
-        case syncable::APPS:
+        case syncer::APPS:
           sync_change_list.push_back(app_sync_bundle_.CreateSyncChange(*i));
           break;
       default:
         LOG(FATAL) << "Got " << type << " ModelType";
       }
   }
 
 
-  if (type == syncable::EXTENSIONS) {
+  if (type == syncer::EXTENSIONS) {
     extension_sync_bundle_.ProcessSyncChangeList(sync_change_list);
-  } else if (type == syncable::APPS) {
+  } else if (type == syncer::APPS) {
     app_sync_bundle_.ProcessSyncChangeList(sync_change_list);
   }
 
   return syncer::SyncError();
 }
 
-void ExtensionService::StopSyncing(syncable::ModelType type) {
-  if (type == syncable::APPS) {
+void ExtensionService::StopSyncing(syncer::ModelType type) {
+  if (type == syncer::APPS) {
     app_sync_bundle_.Reset();
-  } else if (type == syncable::EXTENSIONS) {
+  } else if (type == syncer::EXTENSIONS) {
     extension_sync_bundle_.Reset();
   }
 }
 
 syncer::SyncDataList ExtensionService::GetAllSyncData(
-    syncable::ModelType type) const {
-  if (type == syncable::EXTENSIONS) {
+    syncer::ModelType type) const {
+  if (type == syncer::EXTENSIONS) {
     return extension_sync_bundle_.GetAllSyncData();
 
-  } else if (type == syncable::APPS) {
+  } else if (type == syncer::APPS) {
     return app_sync_bundle_.GetAllSyncData();
   }
 
   // We should only get sync data for extensions and apps.
   NOTREACHED();
 
   return syncer::SyncDataList();
 }
 
 syncer::SyncError ExtensionService::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) {
-    syncable::ModelType type = i->sync_data().GetDataType();
-    if (type == syncable::EXTENSIONS) {
+    syncer::ModelType type = i->sync_data().GetDataType();
+    if (type == syncer::EXTENSIONS) {
       extension_sync_bundle_.ProcessSyncChange(
           extensions::ExtensionSyncData(*i));
-    } else if (type == syncable::APPS) {
+    } else if (type == syncer::APPS) {
       app_sync_bundle_.ProcessSyncChange(extensions::AppSyncData(*i));
     }
   }
 
   extension_prefs()->extension_sorting()->FixNTPOrdinalCollisions();
 
   return syncer::SyncError();
 }
 
 extensions::ExtensionSyncData ExtensionService::GetExtensionSyncData(
@@ skipping 49 matching lines @@
   app_sync_list.insert(app_sync_list.begin(),
                        pending_apps.begin(),
                        pending_apps.end());
 
   return app_sync_list;
 }
 
 bool ExtensionService::ProcessExtensionSyncData(
     const extensions::ExtensionSyncData& extension_sync_data) {
   if (!ProcessExtensionSyncDataHelper(extension_sync_data,
-                                      syncable::EXTENSIONS)) {
+                                      syncer::EXTENSIONS)) {
     extension_sync_bundle_.AddPendingExtension(extension_sync_data.id(),
                                                extension_sync_data);
     CheckForUpdatesSoon();
     return false;
   }
 
   return true;
 }
 
 bool ExtensionService::ProcessAppSyncData(
@@ skipping 14 matching lines @@
 
   if (extension_installed) {
     if (app_sync_data.notifications_disabled() !=
         extension_prefs_->IsAppNotificationDisabled(id)) {
       extension_prefs_->SetAppNotificationDisabled(
           id, app_sync_data.notifications_disabled());
     }
   }
 
   if (!ProcessExtensionSyncDataHelper(app_sync_data.extension_sync_data(),
-                                      syncable::APPS)) {
+                                      syncer::APPS)) {
     app_sync_bundle_.AddPendingApp(id, app_sync_data);
     CheckForUpdatesSoon();
     return false;
   }
 
   return true;
 }
 
 bool ExtensionService::IsCorrectSyncType(const Extension& extension,
-                                         syncable::ModelType type) const {
-  if (type == syncable::EXTENSIONS &&
+                                         syncer::ModelType type) const {
+  if (type == syncer::EXTENSIONS &&
       extension.GetSyncType() == Extension::SYNC_TYPE_EXTENSION)
     return true;
 
-  if (type == syncable::APPS &&
+  if (type == syncer::APPS &&
       extension.GetSyncType() == Extension::SYNC_TYPE_APP)
     return true;
 
   return false;
 }
 
 bool ExtensionService::ProcessExtensionSyncDataHelper(
     const extensions::ExtensionSyncData& extension_sync_data,
-    syncable::ModelType type) {
+    syncer::ModelType type) {
   const std::string& id = extension_sync_data.id();
   const Extension* extension = 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;
 
   // Handle uninstalls first.
@@ skipping 34 matching lines @@
     // If the extension is already installed, check if it's outdated.
     if (result < 0) {
       // Extension is outdated.
       return false;
     }
   } else {
     // TODO(akalin): Replace silent update with a list of enabled
     // permissions.
     const bool kInstallSilently = true;
 
-    CHECK(type == syncable::EXTENSIONS || type == syncable::APPS);
+    CHECK(type == syncer::EXTENSIONS || type == syncer::APPS);
     ExtensionFilter filter =
-        (type == syncable::APPS) ? IsSyncableApp : IsSyncableExtension;
+        (type == syncer::APPS) ? IsSyncableApp : IsSyncableExtension;
 
     if (!pending_extension_manager()->AddFromSync(
             id,
             extension_sync_data.update_url(),
             filter,
             kInstallSilently)) {
       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
@@ skipping 1080 matching lines @@
 
   // To coexist with certain unit tests that don't have a work-thread message
   // loop available at ExtensionService shutdown, we lazy-initialize this
   // object so that those cases neither create nor destroy an
   // APIResourceController.
   if (!api_resource_controller_.get()) {
     api_resource_controller_.reset(new extensions::APIResourceController());
   }
   return api_resource_controller_.get();
 }