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

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/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 45 matching lines @@
       base::TrimWhitespaceASCII(contents, base::TRIM_ALL), "\n",
       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 &&
+         word.size() <= spellcheck::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 232 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::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 119 matching lines @@
 syncer::SyncError SpellcheckCustomDictionary::Sync(
     const Change& dictionary_change) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   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) -
-          server_size);
+  int max_upload_size =
+      std::max(0, static_cast<int>(spellcheck::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)
       break;
@@ skipping 13 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::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));
 }