[WIP][DO NOT LAND] Componentize spellcheck

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 "components/spellcheck/browser/spellcheck_host_metrics.h"
+#include "components/spellcheck/common/spellcheck_common.h"
 #include "chrome/browser/spellchecker/spellcheck_service.h"
-#include "chrome/common/chrome_constants.h"
-#include "chrome/common/spellcheck_common.h"
+//#include "chrome/common/chrome_constants.h"
+#include "components/spellcheck/common/spellcheck_common.h"
 #include "chrome/test/base/testing_profile.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"
@@ skipping 127 matching lines @@
   }
 
  private:
   int loads_;
   int changes_;
   DISALLOW_COPY_AND_ASSIGN(DictionaryObserverCounter);
 };
 
 TEST_F(SpellcheckCustomDictionaryTest, SaveAndLoad) {
   base::FilePath path =
-      profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
+      profile_.GetPath().Append(SpellcheckCustomDictionary::kCustomDictionaryFileName);
 
   // The custom word list should be empty now.
   EXPECT_TRUE(LoadDictionaryFile(path)->words.empty());
 
   std::unique_ptr<SpellcheckCustomDictionary::Change> change(
       new SpellcheckCustomDictionary::Change);
   change->AddWord("bar");
   change->AddWord("foo");
 
   UpdateDictionaryFile(std::move(change), path);
@@ skipping 41 matching lines @@
   std::set<std::string> actual1 = custom_dictionary->GetWords();
   EXPECT_EQ(actual1, expected1);
 
   std::set<std::string> actual2 = custom_dictionary2->GetWords();
   EXPECT_EQ(actual2, expected2);
 }
 
 // Legacy empty dictionary should be converted to new format empty dictionary.
 TEST_F(SpellcheckCustomDictionaryTest, LegacyEmptyDictionaryShouldBeConverted) {
   base::FilePath path =
-      profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
+      profile_.GetPath().Append(SpellcheckCustomDictionary::kCustomDictionaryFileName);
 
   std::string content;
   base::WriteFile(path, content.c_str(), content.length());
   EXPECT_TRUE(LoadDictionaryFile(path)->words.empty());
 }
 
 // Legacy dictionary with two words should be converted to new format dictionary
 // with two words.
 TEST_F(SpellcheckCustomDictionaryTest,
        LegacyDictionaryWithTwoWordsShouldBeConverted) {
   base::FilePath path =
-      profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
+      profile_.GetPath().Append(SpellcheckCustomDictionary::kCustomDictionaryFileName);
 
   std::string content = "foo\nbar\nfoo\n";
   base::WriteFile(path, content.c_str(), content.length());
   std::set<std::string> expected;
   expected.insert("bar");
   expected.insert("foo");
   EXPECT_EQ(expected, LoadDictionaryFile(path)->words);
 }
 
 // Illegal words should be removed. Leading and trailing whitespace should be
 // trimmed.
 TEST_F(SpellcheckCustomDictionaryTest,
        IllegalWordsShouldBeRemovedFromDictionary) {
   base::FilePath path =
-      profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
+      profile_.GetPath().Append(SpellcheckCustomDictionary::kCustomDictionaryFileName);
 
   std::string content = "foo\n foo bar \n\n \nbar\n"
       "01234567890123456789012345678901234567890123456789"
       "01234567890123456789012345678901234567890123456789";
   base::WriteFile(path, content.c_str(), content.length());
   std::set<std::string> expected;
   expected.insert("bar");
   expected.insert("foo");
   expected.insert("foo bar");
   EXPECT_EQ(expected, LoadDictionaryFile(path)->words);
 }
 
 // Write to dictionary should backup previous version and write the word to the
 // end of the dictionary. If the dictionary file is corrupted on disk, the
 // previous version should be reloaded.
 TEST_F(SpellcheckCustomDictionaryTest, CorruptedWriteShouldBeRecovered) {
   base::FilePath path =
-      profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
+      profile_.GetPath().Append(SpellcheckCustomDictionary::kCustomDictionaryFileName);
 
   std::string content = "foo\nbar";
   base::WriteFile(path, content.c_str(), content.length());
   std::set<std::string> expected;
   expected.insert("bar");
   expected.insert("foo");
   EXPECT_EQ(expected, LoadDictionaryFile(path)->words);
 
   std::unique_ptr<SpellcheckCustomDictionary::Change> change(
       new SpellcheckCustomDictionary::Change);
@@ skipping 37 matching lines @@
   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 < spellcheck_common::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_common::MAX_SYNCABLE_DICTIONARY_WORDS - 1,
             dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS - 1,
+  EXPECT_EQ(spellcheck_common::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_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::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_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::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_common::MAX_SYNCABLE_DICTIONARY_WORDS + 2,
             dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::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 69 matching lines @@
   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 < spellcheck_common::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 < spellcheck_common::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),
@@ skipping 23 matching lines @@
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService))
           ->GetCustomDictionary();
 
   std::unique_ptr<SpellcheckCustomDictionary::Change> change(
       new SpellcheckCustomDictionary::Change);
   change->AddWord("foo");
   Apply(*custom_dictionary2, *change);
 
   base::FilePath path =
-      profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
+      profile_.GetPath().Append(SpellcheckCustomDictionary::kCustomDictionaryFileName);
   UpdateDictionaryFile(std::move(change), path);
   EXPECT_TRUE(custom_dictionary->GetWords().empty());
 
   int error_counter = 0;
   EXPECT_FALSE(custom_dictionary
                    ->MergeDataAndStartSyncing(
                        syncer::DICTIONARY,
                        custom_dictionary2->GetAllSyncData(syncer::DICTIONARY),
                        std::unique_ptr<syncer::SyncChangeProcessor>(
                            new syncer::SyncChangeProcessorWrapperForTest(
@@ skipping 28 matching lines @@
   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 < spellcheck_common::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_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetWords().size());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::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 < spellcheck_common::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_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::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_common::MAX_SYNCABLE_DICTIONARY_WORDS * 2 + 1,
             custom_dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetWords().size());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::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 < spellcheck_common::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_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
+  EXPECT_EQ(spellcheck_common::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_common::MAX_SYNCABLE_DICTIONARY_WORDS * 2 + 2,
             custom_dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
+  EXPECT_EQ(spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary2->GetWords().size());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::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 < spellcheck_common::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_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetWords().size());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::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 < spellcheck_common::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_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetWords().size());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::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 59 matching lines @@
                        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 < spellcheck_common::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_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetWords().size());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
+  EXPECT_EQ(spellcheck_common::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 < spellcheck_common::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_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
             custom_dictionary->GetWords().size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
+  EXPECT_EQ(spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
             custom_dictionary2->GetWords().size());
 
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
+  EXPECT_EQ(spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
-  EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
+  EXPECT_EQ(spellcheck_common::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 121 matching lines @@
 
   // 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 < spellcheck_common::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_common::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_common::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 < spellcheck_common::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_common::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_common::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.
   SpellCheckHostMetrics::RecordCustomWordCountStats(123);
 
   // Determine if test failures are due the statistics recorder not being
   // available or because the histogram just isn't there: crbug.com/230534.
   EXPECT_TRUE(StatisticsRecorder::IsActive());
 
   HistogramBase* histogram =
       StatisticsRecorder::FindHistogram("SpellCheck.CustomWords");
   ASSERT_TRUE(histogram != NULL);
   std::unique_ptr<HistogramSamples> baseline = histogram->SnapshotSamples();
 
   // Load the dictionary which should be empty.
   base::FilePath path =
-      profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
+      profile_.GetPath().Append(SpellcheckCustomDictionary::kCustomDictionaryFileName);
   EXPECT_TRUE(LoadDictionaryFile(path)->words.empty());
 
   // We expect there to be an entry with 0.
   histogram =
       StatisticsRecorder::FindHistogram("SpellCheck.CustomWords");
   ASSERT_TRUE(histogram != NULL);
   std::unique_ptr<HistogramSamples> samples = histogram->SnapshotSamples();
 
   samples->Subtract(*baseline);
   EXPECT_EQ(0,samples->sum());
@@ skipping 21 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"));
 }