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

chrome/renderer/spellchecker/spellcheck_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/renderer/spellchecker/spellcheck.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
-#include "chrome/common/spellcheck_common.h"
-#include "chrome/common/spellcheck_result.h"
 #include "chrome/renderer/spellchecker/hunspell_engine.h"
 #include "chrome/renderer/spellchecker/spellcheck_language.h"
+#include "components/spellcheck/common/spellcheck_common.h"
+#include "components/spellcheck/common/spellcheck_result.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebTextCheckingCompletion.h"
 #include "third_party/WebKit/public/web/WebTextCheckingResult.h"
 
 #define TYPOGRAPHICAL_APOSTROPHE L"\x2019"
 
 namespace {
 const int kNoOffset = 0;
 const int kNoTag = 0;
@@ skipping 27 matching lines @@
   }
 
   bool InitializeIfNeeded() {
     return spell_check()->InitializeIfNeeded();
   }
 
   void InitializeSpellCheck(const std::string& language) {
     base::FilePath hunspell_directory = GetHunspellDirectory();
     EXPECT_FALSE(hunspell_directory.empty());
     base::File file(
-        chrome::spellcheck_common::GetVersionedFileName(language,
-                                                        hunspell_directory),
+        spellcheck::GetVersionedFileName(language, hunspell_directory),
         base::File::FLAG_OPEN | base::File::FLAG_READ);
 #if defined(OS_MACOSX)
     // TODO(groby): Forcing spellcheck to use hunspell, even on OSX.
     // Instead, tests should exercise individual spelling engines.
     spell_check_->languages_.push_back(new SpellcheckLanguage());
     spell_check_->languages_.front()->platform_spelling_engine_.reset(
         new HunspellEngine);
     spell_check_->languages_.front()->Init(std::move(file), language);
 #else
     spell_check_->AddSpellcheckLanguage(std::move(file), language);
@@ skipping 1276 matching lines @@
         EXPECT_FALSE(compare_result == 0) << kTestCases[t].suggestion <<
             " in " << kTestCases[i].locale;
       }
     }
   }
 }
 
 // Check that the correct dictionary files are checked in.
 TEST_F(SpellCheckTest, DictionaryFiles) {
   std::vector<std::string> spellcheck_languages;
-  chrome::spellcheck_common::SpellCheckLanguages(&spellcheck_languages);
+  spellcheck::SpellCheckLanguages(&spellcheck_languages);
   EXPECT_FALSE(spellcheck_languages.empty());
 
   base::FilePath hunspell = GetHunspellDirectory();
   for (size_t i = 0; i < spellcheck_languages.size(); ++i) {
-    base::FilePath dict = chrome::spellcheck_common::GetVersionedFileName(
-        spellcheck_languages[i], hunspell);
+    base::FilePath dict =
+        spellcheck::GetVersionedFileName(spellcheck_languages[i], hunspell);
     EXPECT_TRUE(base::PathExists(dict)) << dict.value() << " not found";
   }
 }
 
 // TODO(groby): Add a test for hunspell itself, when MAXWORDLEN is exceeded.
 TEST_F(SpellCheckTest, SpellingEngine_CheckSpelling) {
   static const struct {
     const char* word;
     bool expected_result;
   } kTestCases[] = {
@@ skipping 100 matching lines @@
   FillSuggestions(suggestions_list, &suggestion_results);
   ASSERT_EQ(1U, suggestion_results.size());
   EXPECT_EQ(base::ASCIIToUTF16("foo"), suggestion_results[0]);
 }
 
 TEST_F(SpellCheckTest, FillSuggestions_OneLanguageManySuggestions) {
   std::vector<std::vector<base::string16>> suggestions_list;
   std::vector<base::string16> suggestion_results;
 
   suggestions_list.resize(1);
-  for (int i = 0; i < chrome::spellcheck_common::kMaxSuggestions + 2; ++i)
+  for (int i = 0; i < spellcheck::kMaxSuggestions + 2; ++i)
     suggestions_list[0].push_back(base::ASCIIToUTF16(base::IntToString(i)));
 
   FillSuggestions(suggestions_list, &suggestion_results);
-  ASSERT_EQ(static_cast<size_t>(chrome::spellcheck_common::kMaxSuggestions),
+  ASSERT_EQ(static_cast<size_t>(spellcheck::kMaxSuggestions),
             suggestion_results.size());
-  for (int i = 0; i < chrome::spellcheck_common::kMaxSuggestions; ++i)
+  for (int i = 0; i < spellcheck::kMaxSuggestions; ++i)
     EXPECT_EQ(base::ASCIIToUTF16(base::IntToString(i)), suggestion_results[i]);
 }
 
 TEST_F(SpellCheckTest, FillSuggestions_RemoveDuplicates) {
   std::vector<std::vector<base::string16>> suggestions_list;
   std::vector<base::string16> suggestion_results;
 
   suggestions_list.resize(2);
   for (size_t i = 0; i < 2; ++i) {
     suggestions_list[i].push_back(base::ASCIIToUTF16("foo"));
@@ skipping 15 matching lines @@
   suggestions_list.resize(2);
   for (size_t i = 0; i < 2; ++i) {
     std::string prefix = base::IntToString(i);
     suggestions_list[i].push_back(base::ASCIIToUTF16(prefix + "foo"));
     suggestions_list[i].push_back(base::ASCIIToUTF16(prefix + "bar"));
     suggestions_list[i].push_back(base::ASCIIToUTF16(prefix + "baz"));
   }
 
   // Yes, this test assumes kMaxSuggestions is 5. If it isn't, the test needs
   // to be updated accordingly.
-  ASSERT_EQ(5, chrome::spellcheck_common::kMaxSuggestions);
+  ASSERT_EQ(5, spellcheck::kMaxSuggestions);
   FillSuggestions(suggestions_list, &suggestion_results);
   ASSERT_EQ(5U, suggestion_results.size());
   EXPECT_EQ(base::ASCIIToUTF16("0foo"), suggestion_results[0]);
   EXPECT_EQ(base::ASCIIToUTF16("1foo"), suggestion_results[1]);
   EXPECT_EQ(base::ASCIIToUTF16("0bar"), suggestion_results[2]);
   EXPECT_EQ(base::ASCIIToUTF16("1bar"), suggestion_results[3]);
   EXPECT_EQ(base::ASCIIToUTF16("0baz"), suggestion_results[4]);
 }
 
 TEST_F(SpellCheckTest, FillSuggestions_ThreeLanguages) {
   std::vector<std::vector<base::string16>> suggestions_list;
   std::vector<base::string16> suggestion_results;
 
   suggestions_list.resize(3);
   for (size_t i = 0; i < 3; ++i) {
     std::string prefix = base::IntToString(i);
     suggestions_list[i].push_back(base::ASCIIToUTF16(prefix + "foo"));
     suggestions_list[i].push_back(base::ASCIIToUTF16(prefix + "bar"));
     suggestions_list[i].push_back(base::ASCIIToUTF16(prefix + "baz"));
   }
 
   // Yes, this test assumes kMaxSuggestions is 5. If it isn't, the test needs
   // to be updated accordingly.
-  ASSERT_EQ(5, chrome::spellcheck_common::kMaxSuggestions);
+  ASSERT_EQ(5, spellcheck::kMaxSuggestions);
   FillSuggestions(suggestions_list, &suggestion_results);
   ASSERT_EQ(5U, suggestion_results.size());
   EXPECT_EQ(base::ASCIIToUTF16("0foo"), suggestion_results[0]);
   EXPECT_EQ(base::ASCIIToUTF16("1foo"), suggestion_results[1]);
   EXPECT_EQ(base::ASCIIToUTF16("2foo"), suggestion_results[2]);
   EXPECT_EQ(base::ASCIIToUTF16("0bar"), suggestion_results[3]);
   EXPECT_EQ(base::ASCIIToUTF16("1bar"), suggestion_results[4]);
 }