Removed WebTextCheckingResult legacy API use.

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 "webkit/glue/webkit_glue.h"
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/platform_file.h"
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/renderer/spellchecker/spellcheck.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/spellcheck_common.h"
+#include "chrome/common/spellcheck_result.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebTextCheckingResult.h"
+
 
 namespace {
 
 FilePath GetHunspellDirectory() {
   FilePath hunspell_directory;
   if (!PathService::Get(base::DIR_SOURCE_ROOT, &hunspell_directory))
     return FilePath();
 
   hunspell_directory = hunspell_directory.AppendASCII("third_party");
   hunspell_directory = hunspell_directory.AppendASCII("hunspell_dictionaries");
@@ skipping 22 matching lines @@
 
   virtual ~SpellCheckTest() {
   }
 
   SpellCheck* spell_check() { return spell_check_.get(); }
 
 #if !defined(OS_MACOSX)
  protected:
   void TestSpellCheckParagraph(
       const string16& input,
-      const std::vector<WebKit::WebTextCheckingResult>& expected) {
-    std::vector<WebKit::WebTextCheckingResult> results;
+      const std::vector<SpellCheckResult>& expected) {
+    std::vector<SpellCheckResult> results;
     spell_check()->SpellCheckParagraph(input,
                                        0,
                                        &results);
 
     EXPECT_EQ(results.size(), expected.size());
     size_t size = std::min(results.size(), expected.size());
     for (size_t j = 0; j < size; ++j) {
-      EXPECT_EQ(results[j].type, WebKit::WebTextCheckingTypeSpelling);
+      EXPECT_EQ(results[j].type, SpellCheckResult::SPELLING);
       EXPECT_EQ(results[j].location, expected[j].location);
       EXPECT_EQ(results[j].length, expected[j].length);
     }
   }
 #endif
 
  private:
   scoped_ptr<SpellCheck> spell_check_;
 };
 
@@ skipping 646 matching lines @@
     EXPECT_EQ(expected_autocorrect_word, autocorrect_word);
   }
 }
 
 // Since SpellCheck::SpellCheckParagraph is not implemented on Mac,
 // we skip these SpellCheckParagraph tests on Mac.
 #if !defined(OS_MACOSX)
 
 // Make sure SpellCheckParagraph does not crash if the input is empty.
 TEST_F(SpellCheckTest, SpellCheckParagraphEmptyParagraph) {
-  std::vector<WebKit::WebTextCheckingResult> expected;
+  std::vector<SpellCheckResult> expected;
   TestSpellCheckParagraph(UTF8ToUTF16(""), expected);
 }
 
 // A simple test case having no misspellings.
 TEST_F(SpellCheckTest, SpellCheckParagraphNoMisspellings) {
   const string16 text = UTF8ToUTF16("apple");
-  std::vector<WebKit::WebTextCheckingResult> expected;
+  std::vector<SpellCheckResult> expected;
   TestSpellCheckParagraph(text, expected);
 }
 
 // A simple test case having one misspelling.
 TEST_F(SpellCheckTest, SpellCheckParagraphSingleMisspellings) {
   const string16 text = UTF8ToUTF16("zz");
-  std::vector<WebKit::WebTextCheckingResult> expected;
-  expected.push_back(WebKit::WebTextCheckingResult(
-      WebKit::WebTextCheckingTypeSpelling, 0, 2));
+  std::vector<SpellCheckResult> expected;
+  expected.push_back(SpellCheckResult(
+      SpellCheckResult::SPELLING, 0, 2));
 
   TestSpellCheckParagraph(text, expected);
 }
 
 // A simple test case having multiple misspellings.
 TEST_F(SpellCheckTest, SpellCheckParagraphMultipleMisspellings) {
   const string16 text = UTF8ToUTF16("zz, zz");
-  std::vector<WebKit::WebTextCheckingResult> expected;
-  expected.push_back(WebKit::WebTextCheckingResult(
-      WebKit::WebTextCheckingTypeSpelling, 0, 2));
-  expected.push_back(WebKit::WebTextCheckingResult(
-      WebKit::WebTextCheckingTypeSpelling, 4, 2));
+  std::vector<SpellCheckResult> expected;
+  expected.push_back(SpellCheckResult(
+      SpellCheckResult::SPELLING, 0, 2));
+  expected.push_back(SpellCheckResult(
+      SpellCheckResult::SPELLING, 4, 2));
 
   TestSpellCheckParagraph(text, expected);
 }
 
 // Make sure a relatively long (correct) sentence can be spellchecked.
 TEST_F(SpellCheckTest, SpellCheckParagraphLongSentence) {
-  std::vector<WebKit::WebTextCheckingResult> expected;
+  std::vector<SpellCheckResult> expected;
   // The text is taken from US constitution preamble.
   const string16 text = UTF8ToUTF16(
       "We the people of the United States, in order to form a more perfect "
       "union, establish justice, insure domestic tranquility, provide for "
       "the common defense, promote the general welfare, and secure the "
       "blessings of liberty to ourselves and our posterity, do ordain and "
       "establish this Constitution for the United States of America.");
 
   TestSpellCheckParagraph(text, expected);
 }
 
 // Make sure all misspellings can be found in a relatively long sentence.
 TEST_F(SpellCheckTest, SpellCheckParagraphLongSentenceMultipleMisspellings) {
-  std::vector<WebKit::WebTextCheckingResult> expected;
+  std::vector<SpellCheckResult> expected;
 
   // All 'the' are converted to 'hte' in US consitition preamble.
   const string16 text = UTF8ToUTF16(
       "We hte people of hte United States, in order to form a more perfect "
       "union, establish justice, insure domestic tranquility, provide for "
       "hte common defense, promote hte general welfare, and secure hte "
       "blessings of liberty to ourselves and our posterity, do ordain and "
       "establish this Constitution for hte United States of America.");
 
-  expected.push_back(WebKit::WebTextCheckingResult(
-      WebKit::WebTextCheckingTypeSpelling, 3, 3));
-  expected.push_back(WebKit::WebTextCheckingResult(
-      WebKit::WebTextCheckingTypeSpelling, 17, 3));
-  expected.push_back(WebKit::WebTextCheckingResult(
-      WebKit::WebTextCheckingTypeSpelling, 135, 3));
-  expected.push_back(WebKit::WebTextCheckingResult(
-      WebKit::WebTextCheckingTypeSpelling, 163, 3));
-  expected.push_back(WebKit::WebTextCheckingResult(
-      WebKit::WebTextCheckingTypeSpelling, 195, 3));
-  expected.push_back(WebKit::WebTextCheckingResult(
-      WebKit::WebTextCheckingTypeSpelling, 298, 3));
+  expected.push_back(SpellCheckResult(
+      SpellCheckResult::SPELLING, 3, 3));
+  expected.push_back(SpellCheckResult(
+      SpellCheckResult::SPELLING, 17, 3));
+  expected.push_back(SpellCheckResult(
+      SpellCheckResult::SPELLING, 135, 3));
+  expected.push_back(SpellCheckResult(
+      SpellCheckResult::SPELLING, 163, 3));
+  expected.push_back(SpellCheckResult(
+      SpellCheckResult::SPELLING, 195, 3));
+  expected.push_back(SpellCheckResult(
+      SpellCheckResult::SPELLING, 298, 3));
 
   TestSpellCheckParagraph(text, expected);
 }
 #endif