Rename WebKit namespace to blink (part 4)

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/message_loop.h"
 #include "base/path_service.h"
 #include "base/platform_file.h"
@@ skipping 71 matching lines @@
   bool CheckSpelling(const std::string& word, int tag) {
     return spell_check_->spellcheck_.platform_spelling_engine_->CheckSpelling(
         ASCIIToUTF16(word), tag);
   }
 
 #if !defined(OS_MACOSX)
  protected:
   void TestSpellCheckParagraph(
       const string16& input,
       const std::vector<SpellCheckResult>& expected) {
-    WebKit::WebVector<WebKit::WebTextCheckingResult> results;
+    blink::WebVector<blink::WebTextCheckingResult> results;
     spell_check()->SpellCheckParagraph(input,
                                        &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].decoration, WebKit::WebTextDecorationTypeSpelling);
+      EXPECT_EQ(results[j].decoration, blink::WebTextDecorationTypeSpelling);
       EXPECT_EQ(results[j].location, expected[j].location);
       EXPECT_EQ(results[j].length, expected[j].length);
     }
   }
 #endif
 
  private:
   scoped_ptr<SpellCheck> spell_check_;
   base::MessageLoop loop;
 };
 
 // A fake completion object for verification.
-class MockTextCheckingCompletion : public WebKit::WebTextCheckingCompletion {
+class MockTextCheckingCompletion : public blink::WebTextCheckingCompletion {
  public:
   MockTextCheckingCompletion()
       : completion_count_(0) {
   }
 
   virtual void didFinishCheckingText(
-      const WebKit::WebVector<WebKit::WebTextCheckingResult>& results)
+      const blink::WebVector<blink::WebTextCheckingResult>& results)
           OVERRIDE {
     completion_count_++;
     last_results_ = results;
   }
 
   virtual void didCancelCheckingText() OVERRIDE {
     completion_count_++;
   }
 
   size_t completion_count_;
-  WebKit::WebVector<WebKit::WebTextCheckingResult> last_results_;
+  blink::WebVector<blink::WebTextCheckingResult> last_results_;
 };
 
 // Operates unit tests for the webkit_glue::SpellCheckWord() function
 // with the US English dictionary.
 // The unit tests in this function consist of:
 //   * Tests for the function with empty strings;
 //   * Tests for the function with a valid English word;
 //   * Tests for the function with a valid non-English word;
 //   * Tests for the function with a valid English word with a preceding
 //     space character;
@@ skipping 975 matching lines @@
 }
 
 TEST_F(SpellCheckTest, CreateTextCheckingResults) {
   // Verify that the SpellCheck class keeps the spelling marker added to a
   // misspelled word "zz".
   {
     string16 text = ASCIIToUTF16("zz");
     std::vector<SpellCheckResult> spellcheck_results;
     spellcheck_results.push_back(SpellCheckResult(
         SpellCheckResult::SPELLING, 0, 2, string16()));
-    WebKit::WebVector<WebKit::WebTextCheckingResult> textcheck_results;
+    blink::WebVector<blink::WebTextCheckingResult> textcheck_results;
     spell_check()->CreateTextCheckingResults(SpellCheck::USE_NATIVE_CHECKER,
                                              0,
                                              text,
                                              spellcheck_results,
                                              &textcheck_results);
     EXPECT_EQ(spellcheck_results.size(), textcheck_results.size());
-    EXPECT_EQ(WebKit::WebTextDecorationTypeSpelling,
+    EXPECT_EQ(blink::WebTextDecorationTypeSpelling,
               textcheck_results[0].decoration);
     EXPECT_EQ(spellcheck_results[0].location, textcheck_results[0].location);
     EXPECT_EQ(spellcheck_results[0].length, textcheck_results[0].length);
   }
 
   // Verify that the SpellCheck class replaces the spelling marker added to a
   // contextually-misspelled word "bean" with a grammar marker.
   {
     string16 text = ASCIIToUTF16("I have bean to USA.");
     std::vector<SpellCheckResult> spellcheck_results;
     spellcheck_results.push_back(SpellCheckResult(
         SpellCheckResult::SPELLING, 7, 4, string16()));
-    WebKit::WebVector<WebKit::WebTextCheckingResult> textcheck_results;
+    blink::WebVector<blink::WebTextCheckingResult> textcheck_results;
     spell_check()->CreateTextCheckingResults(SpellCheck::USE_NATIVE_CHECKER,
                                              0,
                                              text,
                                              spellcheck_results,
                                              &textcheck_results);
     EXPECT_EQ(spellcheck_results.size(), textcheck_results.size());
-    EXPECT_EQ(WebKit::WebTextDecorationTypeGrammar,
+    EXPECT_EQ(blink::WebTextDecorationTypeGrammar,
               textcheck_results[0].decoration);
     EXPECT_EQ(spellcheck_results[0].location, textcheck_results[0].location);
     EXPECT_EQ(spellcheck_results[0].length, textcheck_results[0].length);
   }
 }
 
 #endif
 
 // Checks some words that should be present in all English dictionaries.
 TEST_F(SpellCheckTest, EnglishWords) {
@@ skipping 191 matching lines @@
         strlen(kTestCases[i].misspelled),
         0,
         &misspelling_start,
         &misspelling_length,
         &suggestions));
     EXPECT_GE(suggestions.size(), static_cast<size_t>(1));
     if (suggestions.size() > 0)
       EXPECT_EQ(suggestions[0], ASCIIToUTF16(kTestCases[i].suggestion));
   }
 }