Componentize spellcheck [4]: spellcheck/browser and android java-side.

chrome/browser/spellchecker/spelling_service_client_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/spelling_service_client.h"
+#include "components/spellcheck/browser/spelling_service_client.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
-#include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/prefs/pref_service.h"
+#include "components/spellcheck/browser/pref_names.h"
 #include "components/spellcheck/common/spellcheck_result.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // A mock URL fetcher used in the TestingSpellingServiceClient class. This class
 // verifies JSON-RPC requests when the SpellingServiceClient class sends them to
@@ skipping 292 matching lines @@
       "    }\n"
       "  }\n"
       "}",
       true,
       "I'm at the In'N'Out.",
       "en",
     },
   };
 
   PrefService* pref = profile_.GetPrefs();
-  pref->SetBoolean(prefs::kEnableContinuousSpellcheck, true);
-  pref->SetBoolean(prefs::kSpellCheckUseSpellingService, true);
+  pref->SetBoolean(spellcheck::prefs::kEnableContinuousSpellcheck, true);
+  pref->SetBoolean(spellcheck::prefs::kSpellCheckUseSpellingService, true);
 
   for (size_t i = 0; i < arraysize(kTests); ++i) {
     client_.SetHTTPRequest(kTests[i].request_type,
                            kTests[i].sanitized_request_text,
                            kTests[i].language);
     client_.SetHTTPResponse(kTests[i].response_status, kTests[i].response_data);
     client_.SetExpectedTextCheckResult(kTests[i].success,
                                        kTests[i].corrected_text);
     base::ListValue dictionary;
     dictionary.AppendString(kTests[i].language);
-    pref->Set(prefs::kSpellCheckDictionaries, dictionary);
+    pref->Set(spellcheck::prefs::kSpellCheckDictionaries, dictionary);
 
     client_.RequestTextCheck(
         &profile_,
         kTests[i].request_type,
         base::WideToUTF16(kTests[i].request_text),
         base::Bind(&SpellingServiceClientTest::OnTextCheckComplete,
                    base::Unretained(this), 0));
     client_.CallOnURLFetchComplete();
   }
 }
 
 // Verify that SpellingServiceClient::IsAvailable() returns true only when it
 // can send suggest requests or spellcheck requests.
 TEST_F(SpellingServiceClientTest, AvailableServices) {
   const SpellingServiceClient::ServiceType kSuggest =
       SpellingServiceClient::SUGGEST;
   const SpellingServiceClient::ServiceType kSpellcheck =
       SpellingServiceClient::SPELLCHECK;
 
   // When a user disables spellchecking or prevent using the Spelling service,
   // this function should return false both for suggestions and for spellcheck.
   PrefService* pref = profile_.GetPrefs();
-  pref->SetBoolean(prefs::kEnableContinuousSpellcheck, false);
-  pref->SetBoolean(prefs::kSpellCheckUseSpellingService, false);
+  pref->SetBoolean(spellcheck::prefs::kEnableContinuousSpellcheck, false);
+  pref->SetBoolean(spellcheck::prefs::kSpellCheckUseSpellingService, false);
   EXPECT_FALSE(client_.IsAvailable(&profile_, kSuggest));
   EXPECT_FALSE(client_.IsAvailable(&profile_, kSpellcheck));
 
-  pref->SetBoolean(prefs::kEnableContinuousSpellcheck, true);
-  pref->SetBoolean(prefs::kSpellCheckUseSpellingService, true);
+  pref->SetBoolean(spellcheck::prefs::kEnableContinuousSpellcheck, true);
+  pref->SetBoolean(spellcheck::prefs::kSpellCheckUseSpellingService, true);
 
   // For locales supported by the SpellCheck service, this function returns
   // false for suggestions and true for spellcheck. (The comment in
   // SpellingServiceClient::IsAvailable() describes why this function returns
   // false for suggestions.) If there is no language set, then we
   // do not allow any remote.
-  pref->Set(prefs::kSpellCheckDictionaries, base::ListValue());
+  pref->Set(spellcheck::prefs::kSpellCheckDictionaries, base::ListValue());
 
   EXPECT_FALSE(client_.IsAvailable(&profile_, kSuggest));
   EXPECT_FALSE(client_.IsAvailable(&profile_, kSpellcheck));
 
   static const char* kSupported[] = {
       "en-AU", "en-CA", "en-GB", "en-US", "da-DK", "es-ES",
   };
   // If spellcheck is allowed, then suggest is not since spellcheck is a
   // superset of suggest.
   for (size_t i = 0; i < arraysize(kSupported); ++i) {
     base::ListValue dictionary;
     dictionary.AppendString(kSupported[i]);
-    pref->Set(prefs::kSpellCheckDictionaries, dictionary);
+    pref->Set(spellcheck::prefs::kSpellCheckDictionaries, dictionary);
 
     EXPECT_FALSE(client_.IsAvailable(&profile_, kSuggest));
     EXPECT_TRUE(client_.IsAvailable(&profile_, kSpellcheck));
   }
 
   // This function returns true for suggestions for all and false for
   // spellcheck for unsupported locales.
   static const char* kUnsupported[] = {
       "af-ZA", "bg-BG", "ca-ES", "cs-CZ", "de-DE", "el-GR", "et-EE", "fo-FO",
       "fr-FR", "he-IL", "hi-IN", "hr-HR", "hu-HU", "id-ID", "it-IT", "lt-LT",
       "lv-LV", "nb-NO", "nl-NL", "pl-PL", "pt-BR", "pt-PT", "ro-RO", "ru-RU",
       "sk-SK", "sl-SI", "sh",    "sr",    "sv-SE", "tr-TR", "uk-UA", "vi-VN",
   };
   for (size_t i = 0; i < arraysize(kUnsupported); ++i) {
     SCOPED_TRACE(std::string("Expected language ") + kUnsupported[i]);
     base::ListValue dictionary;
     dictionary.AppendString(kUnsupported[i]);
-    pref->Set(prefs::kSpellCheckDictionaries, dictionary);
+    pref->Set(spellcheck::prefs::kSpellCheckDictionaries, dictionary);
 
     EXPECT_TRUE(client_.IsAvailable(&profile_, kSuggest));
     EXPECT_FALSE(client_.IsAvailable(&profile_, kSpellcheck));
   }
 }
 
 // Verify that an error in JSON response from spelling service will result in
 // ParseResponse returning false.
 TEST_F(SpellingServiceClientTest, ResponseErrorTest) {
   EXPECT_TRUE(client_.ParseResponseSuccess("{\"result\": {}}"));
   EXPECT_FALSE(client_.ParseResponseSuccess("{\"error\": {}}"));
 }