[WIP][DO NOT LAND] Componentize spellcheck

chrome/browser/spellchecker/spellcheck_custom_dictionary.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 <functional>
 #include <utility>
 
 #include "base/files/file_util.h"
 #include "base/files/important_file_writer.h"
 #include "base/md5.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
-#include "chrome/browser/spellchecker/spellcheck_host_metrics.h"
-#include "chrome/common/chrome_constants.h"
-#include "chrome/common/spellcheck_common.h"
+#include "components/spellcheck/browser/spellcheck_host_metrics.h"
+#include "components/spellcheck/common/spellcheck_common.h"
 #include "content/public/browser/browser_thread.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/protocol/sync.pb.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // Filename extension for backup dictionary file.
@@ skipping 46 matching lines @@
       base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   words->insert(word_list.begin(), word_list.end());
   return VALID_CHECKSUM;
 }
 
 // Returns true for valid custom dictionary words.
 bool IsValidWord(const std::string& word) {
   std::string tmp;
   return !word.empty() &&
          word.size() <=
-             chrome::spellcheck_common::MAX_CUSTOM_DICTIONARY_WORD_BYTES &&
+             spellcheck_common::MAX_CUSTOM_DICTIONARY_WORD_BYTES &&
          base::IsStringUTF8(word) &&
          base::TRIM_NONE ==
              base::TrimWhitespaceASCII(word, base::TRIM_ALL, &tmp);
 }
 
 // Removes duplicate and invalid words from |to_add| word list. Looks for
 // duplicates in both |to_add| and |existing| word lists. Returns a bitmap of
 // |ChangeSanitationResult| values.
 int SanitizeWordsToAdd(const std::set<std::string>& existing,
                        std::set<std::string>* to_add) {
@@ skipping 74 matching lines @@
   int result = VALID_CHANGE;
   if (to_remove->size() > found_words.size())
     result |= DETECTED_MISSING_WORDS;
   // Save the sanitized words to be removed.
   std::swap(*to_remove, found_words);
   return result;
 }
 
 }  // namespace
 
+const base::FilePath::CharType SpellcheckCustomDictionary::kCustomDictionaryFileName[] =
+    FILE_PATH_LITERAL("Custom Dictionary.txt");
+
 SpellcheckCustomDictionary::Change::Change() {
 }
 
 SpellcheckCustomDictionary::Change::~Change() {
 }
 
 void SpellcheckCustomDictionary::Change::AddWord(const std::string& word) {
   to_add_.insert(word);
 }
 
@@ skipping 12 matching lines @@
   if (!to_add_.empty())
     result |= SanitizeWordsToAdd(words, &to_add_);
   if (!to_remove_.empty())
     result |= SanitizeWordsToRemove(words, &to_remove_);
   return result;
 }
 
 SpellcheckCustomDictionary::SpellcheckCustomDictionary(
     const base::FilePath& dictionary_directory_name)
     : custom_dictionary_path_(
-          dictionary_directory_name.Append(chrome::kCustomDictionaryFileName)),
+          dictionary_directory_name.Append(kCustomDictionaryFileName)),
       is_loaded_(false),
       weak_ptr_factory_(this) {
 }
 
 SpellcheckCustomDictionary::~SpellcheckCustomDictionary() {
 }
 
 const std::set<std::string>& SpellcheckCustomDictionary::GetWords() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return words_;
@@ skipping 105 matching lines @@
   sync_error_handler_.reset();
 }
 
 syncer::SyncDataList SpellcheckCustomDictionary::GetAllSyncData(
     syncer::ModelType type) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(syncer::DICTIONARY, type);
   syncer::SyncDataList data;
   size_t i = 0;
   for (const auto& word : words_) {
-    if (i++ >= chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS)
+    if (i++ >= spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS)
       break;
     sync_pb::EntitySpecifics specifics;
     specifics.mutable_dictionary()->set_word(word);
     data.push_back(syncer::SyncData::CreateLocalData(word, word, specifics));
   }
   return data;
 }
 
 syncer::SyncError SpellcheckCustomDictionary::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
@@ skipping 122 matching lines @@
   syncer::SyncError error;
   if (!IsSyncing() || dictionary_change.empty())
     return error;
 
   // The number of words on the sync server should not exceed the limits.
   int server_size = static_cast<int>(words_.size()) -
       static_cast<int>(dictionary_change.to_add().size());
   int max_upload_size = std::max(
       0,
       static_cast<int>(
-          chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS) -
+          spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS) -
           server_size);
   int upload_size = std::min(
       static_cast<int>(dictionary_change.to_add().size()),
       max_upload_size);
 
   syncer::SyncChangeList sync_change_list;
   int i = 0;
 
   for (const auto& word : dictionary_change.to_add()) {
     if (i++ >= upload_size)
@@ skipping 14 matching lines @@
         syncer::SyncData::CreateLocalData(word, word, specifics)));
   }
 
   // Send the changes to the sync processor.
   error = sync_processor_->ProcessSyncChanges(FROM_HERE, sync_change_list);
   if (error.IsSet())
     return error;
 
   // Turn off syncing of this dictionary if the server already has the maximum
   // number of words.
-  if (words_.size() > chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS)
+  if (words_.size() > spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS)
     StopSyncing(syncer::DICTIONARY);
 
   return error;
 }
 
 void SpellcheckCustomDictionary::Notify(const Change& dictionary_change) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!IsLoaded() || dictionary_change.empty())
     return;
   FOR_EACH_OBSERVER(Observer,
                     observers_,
                     OnCustomDictionaryChanged(dictionary_change));
 }