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

chrome/browser/extensions/settings/settings_backend.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/settings/settings_backend.h"
 
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
@@ skipping 15 matching lines @@
 
 SettingsBackend::SettingsBackend(
     const scoped_refptr<SettingsStorageFactory>& storage_factory,
     const FilePath& base_path,
     const SettingsStorageQuotaEnforcer::Limits& quota,
     const scoped_refptr<SettingsObserverList>& observers)
     : storage_factory_(storage_factory),
       base_path_(base_path),
       quota_(quota),
       observers_(observers),
-      sync_type_(syncable::UNSPECIFIED) {
+      sync_type_(syncer::UNSPECIFIED) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
 SettingsBackend::~SettingsBackend() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
 ValueStore* SettingsBackend::GetStorage(
     const std::string& extension_id) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
@@ skipping 81 matching lines @@
       result.insert(maybe_as_ascii);
     }
   }
 
   return result;
 }
 
 static void AddAllSyncData(
     const std::string& extension_id,
     const DictionaryValue& src,
-    syncable::ModelType type,
+    syncer::ModelType type,
     syncer::SyncDataList* dst) {
   for (DictionaryValue::Iterator it(src); it.HasNext(); it.Advance()) {
     dst->push_back(settings_sync_util::CreateData(
         extension_id, it.key(), it.value(), type));
   }
 }
 
 syncer::SyncDataList SettingsBackend::GetAllSyncData(
-    syncable::ModelType type) const {
+    syncer::ModelType type) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   // Ignore the type, it's just for sanity checking; assume that whatever base
   // path we're constructed with is correct for the sync type.
-  DCHECK(type == syncable::EXTENSION_SETTINGS ||
-         type == syncable::APP_SETTINGS);
+  DCHECK(type == syncer::EXTENSION_SETTINGS ||
+         type == syncer::APP_SETTINGS);
 
   // For all extensions, get all their settings.  This has the effect
   // of bringing in the entire state of extension settings in memory; sad.
   syncer::SyncDataList all_sync_data;
   std::set<std::string> known_extension_ids(GetKnownExtensionIDs());
 
   for (std::set<std::string>::const_iterator it = known_extension_ids.begin();
       it != known_extension_ids.end(); ++it) {
     ValueStore::ReadResult maybe_settings = GetStorage(*it)->Get();
     if (maybe_settings->HasError()) {
       LOG(WARNING) << "Failed to get settings for " << *it << ": " <<
           maybe_settings->error();
       continue;
     }
     AddAllSyncData(*it, *maybe_settings->settings().get(),
                    type, &all_sync_data);
   }
 
   return all_sync_data;
 }
 
 syncer::SyncError SettingsBackend::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) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DCHECK(type == syncable::EXTENSION_SETTINGS ||
-         type == syncable::APP_SETTINGS);
-  DCHECK_EQ(sync_type_, syncable::UNSPECIFIED);
+  DCHECK(type == syncer::EXTENSION_SETTINGS ||
+         type == syncer::APP_SETTINGS);
+  DCHECK_EQ(sync_type_, syncer::UNSPECIFIED);
   DCHECK(!sync_processor_.get());
   DCHECK(sync_processor.get());
   DCHECK(sync_error_factory.get());
 
   sync_type_ = type;
   sync_processor_ = sync_processor.Pass();
   sync_error_factory_ = sync_error_factory.Pass();
 
   // Group the initial sync data by extension id.
   std::map<std::string, linked_ptr<DictionaryValue> > grouped_sync_data;
@@ skipping 65 matching lines @@
     SyncableSettingsStorage* storage =
         GetOrCreateStorageWithSyncData(it->first, empty);
     syncer::SyncError error = storage->ProcessSyncChanges(it->second);
     if (error.IsSet())
       storage->StopSyncing();
   }
 
   return syncer::SyncError();
 }
 
-void SettingsBackend::StopSyncing(syncable::ModelType type) {
+void SettingsBackend::StopSyncing(syncer::ModelType type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DCHECK(type == syncable::EXTENSION_SETTINGS ||
-         type == syncable::APP_SETTINGS);
-  DCHECK(sync_type_ == type || sync_type_ == syncable::UNSPECIFIED);
+  DCHECK(type == syncer::EXTENSION_SETTINGS ||
+         type == syncer::APP_SETTINGS);
+  DCHECK(sync_type_ == type || sync_type_ == syncer::UNSPECIFIED);
 
   for (StorageObjMap::iterator it = storage_objs_.begin();
       it != storage_objs_.end(); ++it) {
     // Some storage areas may have already stopped syncing if they had areas
     // and syncing was disabled, but StopSyncing is safe to call multiple times.
     it->second->StopSyncing();
   }
 
-  sync_type_ = syncable::UNSPECIFIED;
+  sync_type_ = syncer::UNSPECIFIED;
   sync_processor_.reset();
   sync_error_factory_.reset();
 }
 
 scoped_ptr<SettingsSyncProcessor> SettingsBackend::CreateSettingsSyncProcessor(
     const std::string& extension_id) const {
   CHECK(sync_processor_.get());
   return scoped_ptr<SettingsSyncProcessor>(
       new SettingsSyncProcessor(extension_id,
                                 sync_type_,
                                 sync_processor_.get()));
 }
 
 }  // namespace extensions