Componentize spellcheck [2]: move common/ files to component.

chrome/browser/spellchecker/spellcheck_custom_dictionary_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/spellchecker/spellcheck_custom_dictionary.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/spellchecker/spellcheck_factory.h"
 #include "chrome/browser/spellchecker/spellcheck_host_metrics.h"
 #include "chrome/browser/spellchecker/spellcheck_service.h"
 #include "chrome/common/chrome_constants.h"
-#include "chrome/common/spellcheck_common.h"
 #include "chrome/test/base/testing_profile.h"
+#include "components/spellcheck/common/spellcheck_common.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_change_processor_wrapper_for_test.h"
 #include "sync/api/sync_data.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/api/sync_error_factory_mock.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 290 matching lines @@
   data = dictionary->GetAllSyncData(syncer::DICTIONARY);
   EXPECT_TRUE(data.empty());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, GetAllSyncDataHasLimit) {
   SpellcheckCustomDictionary* dictionary =
       SpellcheckServiceFactory::GetForContext(
           &profile_)->GetCustomDictionary();
 
   SpellcheckCustomDictionary::Change change;
-  for (size_t i = 0;
-       i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS - 1;
-       i++) {
+  for (size_t i = 0; i < spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS - 1; i++) {
     change.AddWord("foo" + base::Uint64ToString(i));
   }
   Apply(*dictionary, change);
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS - 1,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS - 1,
             dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS - 1,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS - 1,
             dictionary->GetAllSyncData(syncer::DICTIONARY).size());
 
   dictionary->AddWord("baz");
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             dictionary->GetAllSyncData(syncer::DICTIONARY).size());
 
   dictionary->AddWord("bar");
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             dictionary->GetAllSyncData(syncer::DICTIONARY).size());
 
   dictionary->AddWord("snafoo");
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 2,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS + 2,
             dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             dictionary->GetAllSyncData(syncer::DICTIONARY).size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, ProcessSyncChanges) {
   SpellcheckService* spellcheck_service =
       SpellcheckServiceFactory::GetForContext(&profile_);
   SpellcheckCustomDictionary* dictionary =
       spellcheck_service->GetCustomDictionary();
 
   dictionary->AddWord("foo");
@@ skipping 68 matching lines @@
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
   SpellcheckCustomDictionary::Change change;
-  for (size_t i = 0;
-       i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2;
-       ++i) {
+  for (size_t i = 0; i < spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS / 2; ++i) {
     change.AddWord("foo" + base::Uint64ToString(i));
   }
   Apply(*custom_dictionary, change);
 
   SpellcheckCustomDictionary::Change change2;
-  for (size_t i = 0;
-       i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2;
-       ++i) {
+  for (size_t i = 0; i < spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS / 2; ++i) {
     change2.AddWord("bar" + base::Uint64ToString(i));
   }
   Apply(*custom_dictionary2, change2);
 
   int error_counter = 0;
   EXPECT_FALSE(custom_dictionary
                    ->MergeDataAndStartSyncing(
                        syncer::DICTIONARY,
                        custom_dictionary2->GetAllSyncData(syncer::DICTIONARY),
                        std::unique_ptr<syncer::SyncChangeProcessor>(
@@ skipping 70 matching lines @@
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
   SpellcheckCustomDictionary::Change change;
-  for (size_t i = 0;
-       i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1;
-       ++i) {
+  for (size_t i = 0; i < spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS + 1; ++i) {
     change.AddWord("foo" + base::Uint64ToString(i));
   }
   Apply(*custom_dictionary, change);
 
   int error_counter = 0;
   EXPECT_FALSE(custom_dictionary
                    ->MergeDataAndStartSyncing(
                        syncer::DICTIONARY,
                        custom_dictionary2->GetAllSyncData(syncer::DICTIONARY),
                        std::unique_ptr<syncer::SyncChangeProcessor>(
                            new syncer::SyncChangeProcessorWrapperForTest(
                                custom_dictionary2)),
                        std::unique_ptr<syncer::SyncErrorFactory>(
                            new SyncErrorFactoryStub(&error_counter)))
                    .error()
                    .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_FALSE(custom_dictionary->IsSyncing());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetWords().size());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, DictionaryTooBigAndServerFull) {
   SpellcheckService* spellcheck_service =
       SpellcheckServiceFactory::GetForContext(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
   SpellcheckCustomDictionary::Change change;
   SpellcheckCustomDictionary::Change change2;
-  for (size_t i = 0;
-       i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS;
-       ++i) {
+  for (size_t i = 0; i < spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS; ++i) {
     change.AddWord("foo" + base::Uint64ToString(i));
     change2.AddWord("bar" + base::Uint64ToString(i));
   }
   change.AddWord("foo");
   Apply(*custom_dictionary, change);
   Apply(*custom_dictionary2, change2);
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetWords().size());
 
   int error_counter = 0;
   EXPECT_FALSE(custom_dictionary
                    ->MergeDataAndStartSyncing(
                        syncer::DICTIONARY,
                        custom_dictionary2->GetAllSyncData(syncer::DICTIONARY),
                        std::unique_ptr<syncer::SyncChangeProcessor>(
                            new syncer::SyncChangeProcessorWrapperForTest(
                                custom_dictionary2)),
                        std::unique_ptr<syncer::SyncErrorFactory>(
                            new SyncErrorFactoryStub(&error_counter)))
                    .error()
                    .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_FALSE(custom_dictionary->IsSyncing());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS * 2 + 1,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS * 2 + 1,
             custom_dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetWords().size());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, ServerTooBig) {
   SpellcheckService* spellcheck_service =
       SpellcheckServiceFactory::GetForContext(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
   SpellcheckCustomDictionary::Change change;
   SpellcheckCustomDictionary::Change change2;
-  for (size_t i = 0;
-       i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1;
-       ++i) {
+  for (size_t i = 0; i < spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS + 1; ++i) {
     change.AddWord("foo" + base::Uint64ToString(i));
     change2.AddWord("bar" + base::Uint64ToString(i));
   }
   Apply(*custom_dictionary, change);
   Apply(*custom_dictionary2, change2);
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary2->GetWords().size());
 
   int error_counter = 0;
   EXPECT_FALSE(custom_dictionary
                    ->MergeDataAndStartSyncing(
                        syncer::DICTIONARY,
                        GetAllSyncDataNoLimit(custom_dictionary2),
                        std::unique_ptr<syncer::SyncChangeProcessor>(
                            new syncer::SyncChangeProcessorWrapperForTest(
                                custom_dictionary2)),
                        std::unique_ptr<syncer::SyncErrorFactory>(
                            new SyncErrorFactoryStub(&error_counter)))
                    .error()
                    .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_FALSE(custom_dictionary->IsSyncing());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS * 2 + 2,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS * 2 + 2,
             custom_dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary2->GetWords().size());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, DictionaryTooBigToStartSyncing) {
   SpellcheckService* spellcheck_service =
       SpellcheckServiceFactory::GetForContext(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
   SpellcheckCustomDictionary::Change change;
-  for (size_t i = 0;
-       i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS - 1;
-       ++i) {
+  for (size_t i = 0; i < spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS - 1; ++i) {
     change.AddWord("foo" + base::Uint64ToString(i));
   }
   Apply(*custom_dictionary, change);
 
   custom_dictionary2->AddWord("bar");
   custom_dictionary2->AddWord("baz");
 
   int error_counter = 0;
   EXPECT_FALSE(custom_dictionary
                    ->MergeDataAndStartSyncing(
                        syncer::DICTIONARY,
                        custom_dictionary2->GetAllSyncData(syncer::DICTIONARY),
                        std::unique_ptr<syncer::SyncChangeProcessor>(
                            new syncer::SyncChangeProcessorWrapperForTest(
                                custom_dictionary2)),
                        std::unique_ptr<syncer::SyncErrorFactory>(
                            new SyncErrorFactoryStub(&error_counter)))
                    .error()
                    .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_FALSE(custom_dictionary->IsSyncing());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetWords().size());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, DictionaryTooBigToContiueSyncing) {
   SpellcheckService* spellcheck_service =
       SpellcheckServiceFactory::GetForContext(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
   SpellcheckCustomDictionary::Change change;
-  for (size_t i = 0;
-       i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS - 1;
-       ++i) {
+  for (size_t i = 0; i < spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS - 1; ++i) {
     change.AddWord("foo" + base::Uint64ToString(i));
   }
   Apply(*custom_dictionary, change);
 
   int error_counter = 0;
   EXPECT_FALSE(custom_dictionary
                    ->MergeDataAndStartSyncing(
                        syncer::DICTIONARY,
                        custom_dictionary2->GetAllSyncData(syncer::DICTIONARY),
                        std::unique_ptr<syncer::SyncChangeProcessor>(
                            new syncer::SyncChangeProcessorWrapperForTest(
                                custom_dictionary2)),
                        std::unique_ptr<syncer::SyncErrorFactory>(
                            new SyncErrorFactoryStub(&error_counter)))
                    .error()
                    .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
   custom_dictionary->AddWord("bar");
   EXPECT_EQ(0, error_counter);
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
   custom_dictionary->AddWord("baz");
   EXPECT_EQ(0, error_counter);
   EXPECT_FALSE(custom_dictionary->IsSyncing());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetWords().size());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, LoadAfterSyncStart) {
   SpellcheckService* spellcheck_service =
       SpellcheckServiceFactory::GetForContext(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
@@ skipping 58 matching lines @@
                                custom_dictionary2)),
                        std::unique_ptr<syncer::SyncErrorFactory>(
                            new SyncErrorFactoryStub(&error_counter)))
                    .error()
                    .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
   std::unique_ptr<std::set<std::string>> custom_words(
       new std::set<std::string>);
-  for (size_t i = 0;
-       i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS;
-       ++i) {
+  for (size_t i = 0; i < spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS; ++i) {
     custom_words->insert(custom_words->end(), "foo" + base::Uint64ToString(i));
   }
   OnLoaded(*custom_dictionary, std::move(custom_words));
   EXPECT_EQ(0, error_counter);
   EXPECT_FALSE(custom_dictionary->IsSyncing());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetWords().size());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, LoadDuplicatesAfterSync) {
   SpellcheckService* spellcheck_service =
       SpellcheckServiceFactory::GetForContext(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
   SpellcheckCustomDictionary::Change change;
-  for (size_t i = 0;
-       i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2;
-       ++i) {
+  for (size_t i = 0; i < spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS / 2; ++i) {
     change.AddWord("foo" + base::Uint64ToString(i));
   }
   Apply(*custom_dictionary, change);
 
   int error_counter = 0;
   EXPECT_FALSE(custom_dictionary
                    ->MergeDataAndStartSyncing(
                        syncer::DICTIONARY,
                        custom_dictionary2->GetAllSyncData(syncer::DICTIONARY),
                        std::unique_ptr<syncer::SyncChangeProcessor>(
                            new syncer::SyncChangeProcessorWrapperForTest(
                                custom_dictionary2)),
                        std::unique_ptr<syncer::SyncErrorFactory>(
                            new SyncErrorFactoryStub(&error_counter)))
                    .error()
                    .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
   OnLoaded(*custom_dictionary,
            base::WrapUnique(new std::set<std::string>(change.to_add())));
   EXPECT_EQ(0, error_counter);
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
             custom_dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
             custom_dictionary2->GetWords().size());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
             custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, DictionaryLoadNotification) {
   SpellcheckService* spellcheck_service =
       SpellcheckServiceFactory::GetForContext(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
 
   DictionaryObserverCounter observer;
@@ skipping 120 matching lines @@
       server_spellcheck_service->GetCustomDictionary();
 
   // Upload the maximum number of words to the sync server.
   {
     SpellcheckService* spellcheck_service =
         SpellcheckServiceFactory::GetForContext(&profile_);
     SpellcheckCustomDictionary* custom_dictionary =
         spellcheck_service->GetCustomDictionary();
 
     SpellcheckCustomDictionary::Change change;
-    for (size_t i = 0;
-         i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS;
-         ++i) {
+    for (size_t i = 0; i < spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS; ++i) {
       change.AddWord("foo" + base::Uint64ToString(i));
     }
     Apply(*custom_dictionary, change);
 
     int error_counter = 0;
     EXPECT_FALSE(
         custom_dictionary
             ->MergeDataAndStartSyncing(
                 syncer::DICTIONARY,
                 server_custom_dictionary->GetAllSyncData(syncer::DICTIONARY),
                 std::unique_ptr<syncer::SyncChangeProcessor>(
                     new syncer::SyncChangeProcessorWrapperForTest(
                         server_custom_dictionary)),
                 std::unique_ptr<syncer::SyncErrorFactory>(
                     new SyncErrorFactoryStub(&error_counter)))
             .error()
             .IsSet());
     EXPECT_EQ(0, error_counter);
     EXPECT_TRUE(custom_dictionary->IsSyncing());
-    EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+    EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
               custom_dictionary->GetWords().size());
   }
 
   // The sync server now has the maximum number of words.
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             server_custom_dictionary->GetWords().size());
 
   // Associate the sync server with a client that also has the maximum number of
   // words, but all of these words are different from the ones on the sync
   // server.
   {
     TestingProfile client_profile;
     SpellcheckService* client_spellcheck_service =
         static_cast<SpellcheckService*>(
             SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
                 &client_profile, &BuildSpellcheckService));
 
     // Here, |client_custom_dictionary| plays the role of the client.
     SpellcheckCustomDictionary* client_custom_dictionary =
         client_spellcheck_service->GetCustomDictionary();
 
     // Add the maximum number of words to the client. These words are all
     // different from those on the server.
     SpellcheckCustomDictionary::Change change;
-    for (size_t i = 0;
-         i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS;
-         ++i) {
+    for (size_t i = 0; i < spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS; ++i) {
       change.AddWord("bar" + base::Uint64ToString(i));
     }
     Apply(*client_custom_dictionary, change);
 
     // Associate the server and the client.
     int error_counter = 0;
     EXPECT_FALSE(
         client_custom_dictionary
             ->MergeDataAndStartSyncing(
                 syncer::DICTIONARY,
                 server_custom_dictionary->GetAllSyncData(syncer::DICTIONARY),
                 std::unique_ptr<syncer::SyncChangeProcessor>(
                     new syncer::SyncChangeProcessorWrapperForTest(
                         server_custom_dictionary)),
                 std::unique_ptr<syncer::SyncErrorFactory>(
                     new SyncErrorFactoryStub(&error_counter)))
             .error()
             .IsSet());
     EXPECT_EQ(0, error_counter);
     EXPECT_FALSE(client_custom_dictionary->IsSyncing());
-    EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS * 2,
+    EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS * 2,
               client_custom_dictionary->GetWords().size());
   }
 
   // The sync server should not receive more words, because it has the maximum
   // number of words already.
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck::MAX_SYNCABLE_DICTIONARY_WORDS,
             server_custom_dictionary->GetWords().size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, RecordSizeStatsCorrectly) {
 #if defined(OS_WIN)
 // Failing consistently on Win7. See crbug.com/230534.
   if (base::win::GetVersion() >= base::win::VERSION_VISTA)
     return;
 #endif
   // Record a baseline.
@@ skipping 45 matching lines @@
       SpellcheckServiceFactory::GetForContext(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   OnLoaded(*custom_dictionary, base::WrapUnique(new std::set<std::string>));
   EXPECT_FALSE(custom_dictionary->HasWord("foo"));
   EXPECT_FALSE(custom_dictionary->HasWord("bar"));
   custom_dictionary->AddWord("foo");
   EXPECT_TRUE(custom_dictionary->HasWord("foo"));
   EXPECT_FALSE(custom_dictionary->HasWord("bar"));
 }