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

chrome/browser/extensions/settings/settings_sync_unittest.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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
-#include "chrome/browser/value_store/failing_value_store.h"
 #include "chrome/browser/extensions/settings/leveldb_settings_storage_factory.h"
 #include "chrome/browser/extensions/settings/settings_frontend.h"
 #include "chrome/browser/extensions/settings/settings_storage_factory.h"
 #include "chrome/browser/extensions/settings/settings_sync_util.h"
 #include "chrome/browser/extensions/settings/settings_test_util.h"
 #include "chrome/browser/extensions/settings/syncable_settings_storage.h"
+#include "chrome/browser/value_store/failing_value_store.h"
 #include "chrome/browser/value_store/testing_value_store.h"
 #include "content/public/test/test_browser_thread.h"
 #include "sync/api/sync_change_processor.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/api/sync_error_factory_mock.h"
 
 using content::BrowserThread;
 
 namespace extensions {
 
@@ skipping 159 matching lines @@
   // SettingsStorageFactory is refcounted.
   virtual ~TestingValueStoreFactory() {}
 
   // None of these storage areas are owned by this factory, so care must be
   // taken when calling GetExisting.
   std::map<std::string, TestingValueStore*> created_;
 };
 
 void AssignSettingsService(syncer::SyncableService** dst,
                            const SettingsFrontend* frontend,
-                           syncable::ModelType type) {
+                           syncer::ModelType type) {
   *dst = frontend->GetBackendForSync(type);
 }
 
 }  // namespace
 
 class ExtensionSettingsSyncTest : public testing::Test {
  public:
   ExtensionSettingsSyncTest()
       : ui_thread_(BrowserThread::UI, MessageLoop::current()),
         file_thread_(BrowserThread::FILE, MessageLoop::current()),
@@ skipping 18 matching lines @@
  protected:
   // Adds a record of an extension or app to the extension service, then returns
   // its storage area.
   ValueStore* AddExtensionAndGetStorage(
       const std::string& id, Extension::Type type) {
     profile_->GetMockExtensionService()->AddExtensionWithId(id, type);
     return util::GetStorage(id, frontend_.get());
   }
 
   // Gets the syncer::SyncableService for the given sync type.
-  syncer::SyncableService* GetSyncableService(syncable::ModelType model_type) {
+  syncer::SyncableService* GetSyncableService(syncer::ModelType model_type) {
     MessageLoop::current()->RunAllPending();
     return frontend_->GetBackendForSync(model_type);
   }
 
   // Gets all the sync data from the SyncableService for a sync type as a map
   // from extension id to its sync data.
   std::map<std::string, SettingSyncDataList> GetAllSyncData(
-      syncable::ModelType model_type) {
+      syncer::ModelType model_type) {
     syncer::SyncDataList as_list =
         GetSyncableService(model_type)->GetAllSyncData(model_type);
     std::map<std::string, SettingSyncDataList> as_map;
     for (syncer::SyncDataList::iterator it = as_list.begin();
         it != as_list.end(); ++it) {
       SettingSyncData sync_data(*it);
       as_map[sync_data.extension_id()].push_back(sync_data);
     }
     return as_map;
   }
 
   // Need these so that the DCHECKs for running on FILE or UI threads pass.
   MessageLoop message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
 
   ScopedTempDir temp_dir_;
   scoped_ptr<util::MockProfile> profile_;
   scoped_ptr<SettingsFrontend> frontend_;
   scoped_refptr<util::ScopedSettingsStorageFactory> storage_factory_;
   scoped_ptr<MockSyncChangeProcessor> sync_processor_;
   scoped_ptr<SyncChangeProcessorDelegate> sync_processor_delegate_;
 };
 
 // Get a semblance of coverage for both EXTENSION_SETTINGS and APP_SETTINGS
 // sync by roughly alternative which one to test.
 
 TEST_F(ExtensionSettingsSyncTest, NoDataDoesNotInvokeSync) {
-  syncable::ModelType model_type = syncable::EXTENSION_SETTINGS;
+  syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Extension::Type type = Extension::TYPE_EXTENSION;
 
   EXPECT_EQ(0u, GetAllSyncData(model_type).size());
 
   // Have one extension created before sync is set up, the other created after.
   AddExtensionAndGetStorage("s1", type);
   EXPECT_EQ(0u, GetAllSyncData(model_type).size());
 
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type,
       syncer::SyncDataList(),
       sync_processor_delegate_.PassAs<syncer::SyncChangeProcessor>(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   AddExtensionAndGetStorage("s2", type);
   EXPECT_EQ(0u, GetAllSyncData(model_type).size());
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 
   EXPECT_EQ(0u, sync_processor_->changes().size());
   EXPECT_EQ(0u, GetAllSyncData(model_type).size());
 }
 
 TEST_F(ExtensionSettingsSyncTest, InSyncDataDoesNotInvokeSync) {
-  syncable::ModelType model_type = syncable::APP_SETTINGS;
+  syncer::ModelType model_type = syncer::APP_SETTINGS;
   Extension::Type type = Extension::TYPE_PACKAGED_APP;
 
   StringValue value1("fooValue");
   ListValue value2;
   value2.Append(StringValue::CreateStringValue("barValue"));
 
   ValueStore* storage1 = AddExtensionAndGetStorage("s1", type);
   ValueStore* storage2 = AddExtensionAndGetStorage("s2", type);
 
   storage1->Set(DEFAULTS, "foo", value1);
@@ skipping 29 matching lines @@
   storage1->Set(DEFAULTS, "foo", value2);
   EXPECT_EQ(1u, sync_processor_->changes().size());
   SettingSyncData change = sync_processor_->GetOnlyChange("s1", "foo");
   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change.change_type());
   EXPECT_TRUE(value2.Equals(&change.value()));
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 }
 
 TEST_F(ExtensionSettingsSyncTest, LocalDataWithNoSyncDataIsPushedToSync) {
-  syncable::ModelType model_type = syncable::EXTENSION_SETTINGS;
+  syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Extension::Type type = Extension::TYPE_EXTENSION;
 
   StringValue value1("fooValue");
   ListValue value2;
   value2.Append(StringValue::CreateStringValue("barValue"));
 
   ValueStore* storage1 = AddExtensionAndGetStorage("s1", type);
   ValueStore* storage2 = AddExtensionAndGetStorage("s2", type);
 
   storage1->Set(DEFAULTS, "foo", value1);
@@ skipping 11 matching lines @@
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change.change_type());
   EXPECT_TRUE(value1.Equals(&change.value()));
   change = sync_processor_->GetOnlyChange("s2", "bar");
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change.change_type());
   EXPECT_TRUE(value2.Equals(&change.value()));
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 }
 
 TEST_F(ExtensionSettingsSyncTest, AnySyncDataOverwritesLocalData) {
-  syncable::ModelType model_type = syncable::APP_SETTINGS;
+  syncer::ModelType model_type = syncer::APP_SETTINGS;
   Extension::Type type = Extension::TYPE_PACKAGED_APP;
 
   StringValue value1("fooValue");
   ListValue value2;
   value2.Append(StringValue::CreateStringValue("barValue"));
 
   // Maintain dictionaries mirrored to the expected values of the settings in
   // each storage area.
   DictionaryValue expected1, expected2;
 
@@ skipping 19 matching lines @@
   EXPECT_EQ(0u, sync_processor_->changes().size());
 
   // Sync settings should have been pushed to local settings.
   EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
   EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 }
 
 TEST_F(ExtensionSettingsSyncTest, ProcessSyncChanges) {
-  syncable::ModelType model_type = syncable::EXTENSION_SETTINGS;
+  syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Extension::Type type = Extension::TYPE_EXTENSION;
 
   StringValue value1("fooValue");
   ListValue value2;
   value2.Append(StringValue::CreateStringValue("barValue"));
 
   // Maintain dictionaries mirrored to the expected values of the settings in
   // each storage area.
   DictionaryValue expected1, expected2;
 
@@ skipping 52 matching lines @@
   expected1.Remove("foo", NULL);
   expected2.Remove("foo", NULL);
 
   EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
   EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 }
 
 TEST_F(ExtensionSettingsSyncTest, PushToSync) {
-  syncable::ModelType model_type = syncable::APP_SETTINGS;
+  syncer::ModelType model_type = syncer::APP_SETTINGS;
   Extension::Type type = Extension::TYPE_PACKAGED_APP;
 
   StringValue value1("fooValue");
   ListValue value2;
   value2.Append(StringValue::CreateStringValue("barValue"));
 
   // Make storage1/2 initialised from local data, storage3/4 initialised from
   // sync.
   ValueStore* storage1 = AddExtensionAndGetStorage("s1", type);
   ValueStore* storage2 = AddExtensionAndGetStorage("s2", type);
@@ skipping 135 matching lines @@
   // storage1 is an extension, storage2 is an app.
   ValueStore* storage1 = AddExtensionAndGetStorage(
       "s1", Extension::TYPE_EXTENSION);
   ValueStore* storage2 = AddExtensionAndGetStorage(
       "s2", Extension::TYPE_PACKAGED_APP);
 
   storage1->Set(DEFAULTS, "foo", value1);
   storage2->Set(DEFAULTS, "bar", value2);
 
   std::map<std::string, SettingSyncDataList> extension_sync_data =
-      GetAllSyncData(syncable::EXTENSION_SETTINGS);
+      GetAllSyncData(syncer::EXTENSION_SETTINGS);
   EXPECT_EQ(1u, extension_sync_data.size());
   EXPECT_EQ(1u, extension_sync_data["s1"].size());
   EXPECT_PRED_FORMAT2(ValuesEq, &value1, &extension_sync_data["s1"][0].value());
 
   std::map<std::string, SettingSyncDataList> app_sync_data =
-      GetAllSyncData(syncable::APP_SETTINGS);
+      GetAllSyncData(syncer::APP_SETTINGS);
   EXPECT_EQ(1u, app_sync_data.size());
   EXPECT_EQ(1u, app_sync_data["s2"].size());
   EXPECT_PRED_FORMAT2(ValuesEq, &value2, &app_sync_data["s2"][0].value());
 
   // Stop each separately, there should be no changes either time.
   syncer::SyncDataList sync_data;
   sync_data.push_back(settings_sync_util::CreateData(
-      "s1", "foo", value1, syncable::EXTENSION_SETTINGS));
+      "s1", "foo", value1, syncer::EXTENSION_SETTINGS));
 
-  GetSyncableService(syncable::EXTENSION_SETTINGS)->MergeDataAndStartSyncing(
-      syncable::EXTENSION_SETTINGS,
+  GetSyncableService(syncer::EXTENSION_SETTINGS)->MergeDataAndStartSyncing(
+      syncer::EXTENSION_SETTINGS,
       sync_data,
       sync_processor_delegate_.PassAs<syncer::SyncChangeProcessor>(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
-  GetSyncableService(syncable::EXTENSION_SETTINGS)->
-      StopSyncing(syncable::EXTENSION_SETTINGS);
+  GetSyncableService(syncer::EXTENSION_SETTINGS)->
+      StopSyncing(syncer::EXTENSION_SETTINGS);
   EXPECT_EQ(0u, sync_processor_->changes().size());
 
   sync_data.clear();
   sync_data.push_back(settings_sync_util::CreateData(
-      "s2", "bar", value2, syncable::APP_SETTINGS));
+      "s2", "bar", value2, syncer::APP_SETTINGS));
 
   scoped_ptr<SyncChangeProcessorDelegate> app_settings_delegate_(
       new SyncChangeProcessorDelegate(sync_processor_.get()));
-  GetSyncableService(syncable::APP_SETTINGS)->MergeDataAndStartSyncing(
-      syncable::APP_SETTINGS,
+  GetSyncableService(syncer::APP_SETTINGS)->MergeDataAndStartSyncing(
+      syncer::APP_SETTINGS,
       sync_data,
       app_settings_delegate_.PassAs<syncer::SyncChangeProcessor>(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
-  GetSyncableService(syncable::APP_SETTINGS)->
-      StopSyncing(syncable::APP_SETTINGS);
+  GetSyncableService(syncer::APP_SETTINGS)->
+      StopSyncing(syncer::APP_SETTINGS);
   EXPECT_EQ(0u, sync_processor_->changes().size());
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailingStartSyncingDisablesSync) {
-  syncable::ModelType model_type = syncable::EXTENSION_SETTINGS;
+  syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Extension::Type type = Extension::TYPE_EXTENSION;
 
   StringValue fooValue("fooValue");
   StringValue barValue("barValue");
 
   // There is a bit of a convoluted method to get storage areas that can fail;
   // hand out TestingValueStore object then toggle them failing/succeeding
   // as necessary.
   TestingValueStoreFactory* testing_factory = new TestingValueStoreFactory();
   storage_factory_->Reset(testing_factory);
@@ skipping 179 matching lines @@
   {
     DictionaryValue dict;
     dict.Set("bar", fooValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailingProcessChangesDisablesSync) {
   // The test above tests a failing ProcessSyncChanges too, but here test with
   // an initially passing MergeDataAndStartSyncing.
-  syncable::ModelType model_type = syncable::APP_SETTINGS;
+  syncer::ModelType model_type = syncer::APP_SETTINGS;
   Extension::Type type = Extension::TYPE_PACKAGED_APP;
 
   StringValue fooValue("fooValue");
   StringValue barValue("barValue");
 
   TestingValueStoreFactory* testing_factory = new TestingValueStoreFactory();
   storage_factory_->Reset(testing_factory);
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
@@ skipping 77 matching lines @@
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     DictionaryValue dict;
     dict.Set("foo", barValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailingGetAllSyncDataDoesntStopSync) {
-  syncable::ModelType model_type = syncable::EXTENSION_SETTINGS;
+  syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Extension::Type type = Extension::TYPE_EXTENSION;
 
   StringValue fooValue("fooValue");
   StringValue barValue("barValue");
 
   TestingValueStoreFactory* testing_factory = new TestingValueStoreFactory();
   storage_factory_->Reset(testing_factory);
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
@@ skipping 34 matching lines @@
   EXPECT_EQ(
       syncer::SyncChange::ACTION_ADD,
       sync_processor_->GetOnlyChange("good", "bar").change_type());
   EXPECT_EQ(
       syncer::SyncChange::ACTION_ADD,
       sync_processor_->GetOnlyChange("bad", "bar").change_type());
   EXPECT_EQ(2u, sync_processor_->changes().size());
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailureToReadChangesToPushDisablesSync) {
-  syncable::ModelType model_type = syncable::APP_SETTINGS;
+  syncer::ModelType model_type = syncer::APP_SETTINGS;
   Extension::Type type = Extension::TYPE_PACKAGED_APP;
 
   StringValue fooValue("fooValue");
   StringValue barValue("barValue");
 
   TestingValueStoreFactory* testing_factory = new TestingValueStoreFactory();
   storage_factory_->Reset(testing_factory);
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
@@ skipping 83 matching lines @@
   EXPECT_EQ(
       syncer::SyncChange::ACTION_UPDATE,
       sync_processor_->GetOnlyChange("good", "bar").change_type());
   EXPECT_EQ(
       syncer::SyncChange::ACTION_UPDATE,
       sync_processor_->GetOnlyChange("good", "bar").change_type());
   EXPECT_EQ(2u, sync_processor_->changes().size());
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailureToPushLocalStateDisablesSync) {
-  syncable::ModelType model_type = syncable::EXTENSION_SETTINGS;
+  syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Extension::Type type = Extension::TYPE_EXTENSION;
 
   StringValue fooValue("fooValue");
   StringValue barValue("barValue");
 
   TestingValueStoreFactory* testing_factory = new TestingValueStoreFactory();
   storage_factory_->Reset(testing_factory);
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
@@ skipping 70 matching lines @@
   EXPECT_EQ(
       syncer::SyncChange::ACTION_UPDATE,
       sync_processor_->GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(
       syncer::SyncChange::ACTION_UPDATE,
       sync_processor_->GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(2u, sync_processor_->changes().size());
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailureToPushLocalChangeDisablesSync) {
-  syncable::ModelType model_type = syncable::EXTENSION_SETTINGS;
+  syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Extension::Type type = Extension::TYPE_EXTENSION;
 
   StringValue fooValue("fooValue");
   StringValue barValue("barValue");
 
   TestingValueStoreFactory* testing_factory = new TestingValueStoreFactory();
   storage_factory_->Reset(testing_factory);
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
@@ skipping 77 matching lines @@
       syncer::SyncChange::ACTION_UPDATE,
       sync_processor_->GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(
       syncer::SyncChange::ACTION_UPDATE,
       sync_processor_->GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(2u, sync_processor_->changes().size());
 }
 
 TEST_F(ExtensionSettingsSyncTest,
        LargeOutgoingChangeRejectedButIncomingAccepted) {
-  syncable::ModelType model_type = syncable::APP_SETTINGS;
+  syncer::ModelType model_type = syncer::APP_SETTINGS;
   Extension::Type type = Extension::TYPE_PACKAGED_APP;
 
   // This value should be larger than the limit in settings_backend.cc.
   std::string string_5k;
   for (size_t i = 0; i < 5000; ++i) {
     string_5k.append("a");
   }
   StringValue large_value(string_5k);
 
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
@@ skipping 21 matching lines @@
     DictionaryValue expected;
     expected.Set("large_value", large_value.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, expected, storage1->Get());
     EXPECT_PRED_FORMAT2(SettingsEq, expected, storage2->Get());
   }
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 }
 
 }  // namespace extensions