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

chrome/browser/ui/webui/sync_setup_handler_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 "chrome/browser/ui/webui/sync_setup_handler.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/pref_service.h"
+#include "chrome/browser/signin/signin_manager_factory.h"
+#include "chrome/browser/signin/signin_manager_fake.h"
+#include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/profile_sync_service_mock.h"
-#include "chrome/browser/signin/signin_manager_fake.h"
-#include "chrome/browser/signin/signin_manager_factory.h"
-#include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service_factory.h"
 #include "chrome/browser/ui/webui/sync_promo/sync_promo_ui.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/web_ui.h"
 #include "grit/generated_resources.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 10 matching lines @@
 
 MATCHER_P(ModelTypeSetMatches, value, "") { return arg.Equals(value); }
 
 const char kTestUser[] = "chrome.p13n.test@gmail.com";
 const char kTestPassword[] = "passwd";
 const char kTestCaptcha[] = "pizzamyheart";
 const char kTestCaptchaImageUrl[] = "http://pizzamyheart/image";
 const char kTestCaptchaUnlockUrl[] = "http://pizzamyheart/unlock";
 
 // List of all the types a user can select in the sync config dialog.
-const syncable::ModelType kUserSelectableTypes[] = {
-  syncable::APPS,
-  syncable::AUTOFILL,
-  syncable::BOOKMARKS,
-  syncable::EXTENSIONS,
-  syncable::PASSWORDS,
-  syncable::PREFERENCES,
-  syncable::SESSIONS,
-  syncable::THEMES,
-  syncable::TYPED_URLS
+const syncer::ModelType kUserSelectableTypes[] = {
+  syncer::APPS,
+  syncer::AUTOFILL,
+  syncer::BOOKMARKS,
+  syncer::EXTENSIONS,
+  syncer::PASSWORDS,
+  syncer::PREFERENCES,
+  syncer::SESSIONS,
+  syncer::THEMES,
+  syncer::TYPED_URLS
 };
 
 // Returns a ModelTypeSet with all user selectable types set.
-syncable::ModelTypeSet GetAllTypes() {
-  syncable::ModelTypeSet types;
+syncer::ModelTypeSet GetAllTypes() {
+  syncer::ModelTypeSet types;
   for (size_t i = 0; i < arraysize(kUserSelectableTypes); ++i)
     types.Put(kUserSelectableTypes[i]);
   return types;
 }
 
 enum SyncAllDataConfig {
   SYNC_ALL_DATA,
   CHOOSE_WHAT_TO_SYNC
 };
 
 enum EncryptAllConfig {
   ENCRYPT_ALL_DATA,
   ENCRYPT_PASSWORDS
 };
 
 // Create a json-format string with the key/value pairs appropriate for a call
 // to HandleConfigure(). If |extra_values| is non-null, then the values from
 // the passed dictionary are added to the json.
 std::string GetConfiguration(const DictionaryValue* extra_values,
                              SyncAllDataConfig sync_all,
-                             syncable::ModelTypeSet types,
+                             syncer::ModelTypeSet types,
                              const std::string& passphrase,
                              EncryptAllConfig encrypt_all) {
   DictionaryValue result;
   if (extra_values)
     result.MergeDictionary(extra_values);
   result.SetBoolean("syncAllDataTypes", sync_all == SYNC_ALL_DATA);
   result.SetBoolean("encryptAllData", encrypt_all == ENCRYPT_ALL_DATA);
   result.SetBoolean("usePassphrase", !passphrase.empty());
   if (!passphrase.empty())
     result.SetString("passphrase", passphrase);
   // Add all of our data types.
-  result.SetBoolean("appsSynced", types.Has(syncable::APPS));
-  result.SetBoolean("autofillSynced", types.Has(syncable::AUTOFILL));
-  result.SetBoolean("bookmarksSynced", types.Has(syncable::BOOKMARKS));
-  result.SetBoolean("extensionsSynced", types.Has(syncable::EXTENSIONS));
-  result.SetBoolean("passwordsSynced", types.Has(syncable::PASSWORDS));
-  result.SetBoolean("preferencesSynced", types.Has(syncable::PREFERENCES));
-  result.SetBoolean("sessionsSynced", types.Has(syncable::SESSIONS));
-  result.SetBoolean("themesSynced", types.Has(syncable::THEMES));
-  result.SetBoolean("typedUrlsSynced", types.Has(syncable::TYPED_URLS));
+  result.SetBoolean("appsSynced", types.Has(syncer::APPS));
+  result.SetBoolean("autofillSynced", types.Has(syncer::AUTOFILL));
+  result.SetBoolean("bookmarksSynced", types.Has(syncer::BOOKMARKS));
+  result.SetBoolean("extensionsSynced", types.Has(syncer::EXTENSIONS));
+  result.SetBoolean("passwordsSynced", types.Has(syncer::PASSWORDS));
+  result.SetBoolean("preferencesSynced", types.Has(syncer::PREFERENCES));
+  result.SetBoolean("sessionsSynced", types.Has(syncer::SESSIONS));
+  result.SetBoolean("themesSynced", types.Has(syncer::THEMES));
+  result.SetBoolean("typedUrlsSynced", types.Has(syncer::TYPED_URLS));
   std::string args;
   base::JSONWriter::Write(&result, &args);
   return args;
 }
 
 void CheckInt(const DictionaryValue* dictionary,
               const std::string& key,
               int expected_value) {
   int actual_value;
   EXPECT_TRUE(dictionary->GetInteger(key, &actual_value)) <<
@@ skipping 68 matching lines @@
   CheckInt(dictionary, "error", error);
   CheckBool(dictionary, "fatalError", fatal_error, true);
   CheckBool(dictionary, "editableUser", user_is_editable);
 }
 
 // Checks to make sure that the values stored in |dictionary| match the values
 // expected by the showSyncSetupPage() JS function for a given set of data
 // types.
 void CheckConfigDataTypeArguments(DictionaryValue* dictionary,
                                   SyncAllDataConfig config,
-                                  syncable::ModelTypeSet types) {
+                                  syncer::ModelTypeSet types) {
   CheckBool(dictionary, "syncAllDataTypes", config == SYNC_ALL_DATA);
-  CheckBool(dictionary, "appsSynced", types.Has(syncable::APPS));
-  CheckBool(dictionary, "autofillSynced", types.Has(syncable::AUTOFILL));
-  CheckBool(dictionary, "bookmarksSynced", types.Has(syncable::BOOKMARKS));
-  CheckBool(dictionary, "extensionsSynced", types.Has(syncable::EXTENSIONS));
-  CheckBool(dictionary, "passwordsSynced", types.Has(syncable::PASSWORDS));
-  CheckBool(dictionary, "preferencesSynced", types.Has(syncable::PREFERENCES));
-  CheckBool(dictionary, "sessionsSynced", types.Has(syncable::SESSIONS));
-  CheckBool(dictionary, "themesSynced", types.Has(syncable::THEMES));
-  CheckBool(dictionary, "typedUrlsSynced", types.Has(syncable::TYPED_URLS));
+  CheckBool(dictionary, "appsSynced", types.Has(syncer::APPS));
+  CheckBool(dictionary, "autofillSynced", types.Has(syncer::AUTOFILL));
+  CheckBool(dictionary, "bookmarksSynced", types.Has(syncer::BOOKMARKS));
+  CheckBool(dictionary, "extensionsSynced", types.Has(syncer::EXTENSIONS));
+  CheckBool(dictionary, "passwordsSynced", types.Has(syncer::PASSWORDS));
+  CheckBool(dictionary, "preferencesSynced", types.Has(syncer::PREFERENCES));
+  CheckBool(dictionary, "sessionsSynced", types.Has(syncer::SESSIONS));
+  CheckBool(dictionary, "themesSynced", types.Has(syncer::THEMES));
+  CheckBool(dictionary, "typedUrlsSynced", types.Has(syncer::TYPED_URLS));
 }
 
 
 }  // namespace
 
 // Test instance of WebUI that tracks the data passed to
 // CallJavascriptFunction().
 class TestWebUI : public content::WebUI {
  public:
   virtual ~TestWebUI() {
@@ skipping 660 matching lines @@
   const TestWebUI::CallData& data = web_ui_.call_data()[0];
   DictionaryValue* dictionary;
   ASSERT_TRUE(data.arg2->GetAsDictionary(&dictionary));
   CheckBool(dictionary, "passphraseFailed", true);
 }
 
 // Walks through each user selectable type, and tries to sync just that single
 // data type.
 TEST_P(SyncSetupHandlerTest, TestSyncIndividualTypes) {
   for (size_t i = 0; i < arraysize(kUserSelectableTypes); ++i) {
-    syncable::ModelTypeSet type_to_set;
+    syncer::ModelTypeSet type_to_set;
     type_to_set.Put(kUserSelectableTypes[i]);
     std::string args = GetConfiguration(
         NULL, CHOOSE_WHAT_TO_SYNC, type_to_set, "", ENCRYPT_PASSWORDS);
     ListValue list_args;
     list_args.Append(new StringValue(args));
     EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
         .WillRepeatedly(Return(false));
     EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
         .WillRepeatedly(Return(false));
     SetupInitializedProfileSyncService();
@@ skipping 129 matching lines @@
 TEST_P(SyncSetupHandlerTest, ShowSetupSyncForAllTypesIndividually) {
   for (size_t i = 0; i < arraysize(kUserSelectableTypes); ++i) {
     EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
         .WillRepeatedly(Return(false));
     EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
         .WillRepeatedly(Return(false));
     SetupInitializedProfileSyncService();
     browser_sync::SyncPrefs sync_prefs(profile_->GetPrefs());
     sync_prefs.SetKeepEverythingSynced(false);
     SetDefaultExpectationsForConfigPage();
-    syncable::ModelTypeSet types;
+    syncer::ModelTypeSet types;
     types.Put(kUserSelectableTypes[i]);
     EXPECT_CALL(*mock_pss_, GetPreferredDataTypes()).
         WillRepeatedly(Return(types));
 
     // This should display the sync setup dialog (not login).
     handler_->OpenSyncSetup(false);
 
     ExpectConfig();
     // Close the config overlay.
     LoginUIServiceFactory::GetForProfile(profile_.get())->LoginUIClosed(
@@ skipping 105 matching lines @@
   CheckShowSyncSetupArgs(
       dictionary, err, false, GoogleServiceAuthError::NONE, "", true, "");
   handler_->CloseSyncSetup();
   EXPECT_EQ(NULL,
             LoginUIServiceFactory::GetForProfile(
                 profile_.get())->current_login_ui());
 }
 
 INSTANTIATE_TEST_CASE_P(SyncSetupHandlerTest, SyncSetupHandlerTest,
                         Values(true, false));