Rename WebKit namespace to blink (part 4)

This CL updates all references to the WebKit namespace in chrome and
components.

TBR=darin@chromium.org
BUG=295096

Review URL: https://codereview.chromium.org/63273002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@233464 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 91 insertions, 91 deletions

diff --git a/chrome/renderer/spellchecker/spellcheck.cc b/chrome/renderer/spellchecker/spellcheck.cc
index f09a11e..9af496b 100644
--- a/chrome/renderer/spellchecker/spellcheck.cc
+++ b/chrome/renderer/spellchecker/spellcheck.cc
@@ -21,9 +21,9 @@
 #include "third_party/WebKit/public/web/WebTextDecorationType.h"
 #include "third_party/WebKit/public/web/WebView.h"
 
-using WebKit::WebVector;
-using WebKit::WebTextCheckingResult;
-using WebKit::WebTextDecorationType;
+using blink::WebVector;
+using blink::WebTextCheckingResult;
+using blink::WebTextDecorationType;
 
 namespace {
 
@@ -72,20 +72,20 @@ bool DocumentMarkersCollector::Visit(content::RenderView* render_view) {
 class SpellCheck::SpellcheckRequest {
  public:
   SpellcheckRequest(const string16& text,
-                    WebKit::WebTextCheckingCompletion* completion)
+                    blink::WebTextCheckingCompletion* completion)
       : text_(text), completion_(completion) {
     DCHECK(completion);
   }
   ~SpellcheckRequest() {}
 
   string16 text() { return text_; }
-  WebKit::WebTextCheckingCompletion* completion() { return completion_; }
+  blink::WebTextCheckingCompletion* completion() { return completion_; }
 
  private:
   string16 text_;  // Text to be checked in this task.
 
   // The interface to send the misspelled ranges to WebKit.
-  WebKit::WebTextCheckingCompletion* completion_;
+  blink::WebTextCheckingCompletion* completion_;
 
   DISALLOW_COPY_AND_ASSIGN(SpellcheckRequest);
 };
@@ -227,7 +227,7 @@ bool SpellCheck::SpellCheckParagraph(
             text, misspelling_start + offset, misspelling_length)) {
       string16 replacement;
       textcheck_results.push_back(WebTextCheckingResult(
-          WebKit::WebTextDecorationTypeSpelling,
+          blink::WebTextDecorationTypeSpelling,
           misspelling_start + offset,
           misspelling_length,
           replacement));
@@ -299,7 +299,7 @@ string16 SpellCheck::GetAutoCorrectionWord(const string16& word, int tag) {
 #if !defined(OS_MACOSX)  // OSX uses its own spell checker
 void SpellCheck::RequestTextChecking(
     const string16& text,
-    WebKit::WebTextCheckingCompletion* completion) {
+    blink::WebTextCheckingCompletion* completion) {
   // Clean up the previous request before starting a new request.
   if (pending_request_param_.get())
     pending_request_param_->completion()->didCancelCheckingText();
@@ -337,7 +337,7 @@ void SpellCheck::PerformSpellCheck(SpellcheckRequest* param) {
   if (!spellcheck_.IsEnabled()) {
     param->completion()->didCancelCheckingText();
   } else {
-    WebVector<WebKit::WebTextCheckingResult> results;
+    WebVector<blink::WebTextCheckingResult> results;
     SpellCheckParagraph(param->text(), &results);
     param->completion()->didFinishCheckingText(results);
   }
diff --git a/chrome/renderer/spellchecker/spellcheck.h b/chrome/renderer/spellchecker/spellcheck.h
index 076a3bc..0ba206a 100644
--- a/chrome/renderer/spellchecker/spellcheck.h
+++ b/chrome/renderer/spellchecker/spellcheck.h
@@ -21,7 +21,7 @@
 
 struct SpellCheckResult;
 
-namespace WebKit {
+namespace blink {
 class WebTextCheckingCompletion;
 struct WebTextCheckingResult;
 }
@@ -78,7 +78,7 @@ class SpellCheck : public content::RenderProcessObserver,
   // If the spellchecker failed to initialize, always returns true.
   bool SpellCheckParagraph(
       const string16& text,
-      WebKit::WebVector<WebKit::WebTextCheckingResult>* results);
+      blink::WebVector<blink::WebTextCheckingResult>* results);
 
   // Find a possible correctly spelled word for a misspelled word. Computes an
   // empty string if input misspelled word is too long, there is ambiguity, or
@@ -92,7 +92,7 @@ class SpellCheck : public content::RenderProcessObserver,
   // posts a background task and calls SpellCheckParagraph() in the task.
 #if !defined (OS_MACOSX)
   void RequestTextChecking(const string16& text,
-                           WebKit::WebTextCheckingCompletion* completion);
+                           blink::WebTextCheckingCompletion* completion);
 #endif
 
   // Creates a list of WebTextCheckingResult objects (used by WebKit) from a
@@ -104,7 +104,7 @@ class SpellCheck : public content::RenderProcessObserver,
       int line_offset,
       const string16& line_text,
       const std::vector<SpellCheckResult>& spellcheck_results,
-      WebKit::WebVector<WebKit::WebTextCheckingResult>* textcheck_results);
+      blink::WebVector<blink::WebTextCheckingResult>* textcheck_results);
 
   bool is_spellcheck_enabled() { return spellcheck_enabled_; }
 
diff --git a/chrome/renderer/spellchecker/spellcheck_provider.cc b/chrome/renderer/spellchecker/spellcheck_provider.cc
index 05c31ad..a612f2e 100644
--- a/chrome/renderer/spellchecker/spellcheck_provider.cc
+++ b/chrome/renderer/spellchecker/spellcheck_provider.cc
@@ -19,18 +19,18 @@
 #include "third_party/WebKit/public/web/WebTextDecorationType.h"
 #include "third_party/WebKit/public/web/WebView.h"
 
-using WebKit::WebFrame;
-using WebKit::WebString;
-using WebKit::WebTextCheckingCompletion;
-using WebKit::WebTextCheckingResult;
-using WebKit::WebTextDecorationType;
-using WebKit::WebVector;
-
-COMPILE_ASSERT(int(WebKit::WebTextDecorationTypeSpelling) ==
+using blink::WebFrame;
+using blink::WebString;
+using blink::WebTextCheckingCompletion;
+using blink::WebTextCheckingResult;
+using blink::WebTextDecorationType;
+using blink::WebVector;
+
+COMPILE_ASSERT(int(blink::WebTextDecorationTypeSpelling) ==
                int(SpellCheckResult::SPELLING), mismatching_enums);
-COMPILE_ASSERT(int(WebKit::WebTextDecorationTypeGrammar) ==
+COMPILE_ASSERT(int(blink::WebTextDecorationTypeGrammar) ==
                int(SpellCheckResult::GRAMMAR), mismatching_enums);
-COMPILE_ASSERT(int(WebKit::WebTextDecorationTypeInvisibleSpellcheck) ==
+COMPILE_ASSERT(int(blink::WebTextDecorationTypeInvisibleSpellcheck) ==
                int(SpellCheckResult::INVISIBLE), mismatching_enums);
 
 SpellCheckProvider::SpellCheckProvider(
@@ -67,7 +67,7 @@ void SpellCheckProvider::RequestTextChecking(
   // Send this text to a browser. A browser checks the user profile and send
   // this text to the Spelling service only if a user enables this feature.
   last_request_.clear();
-  last_results_.assign(WebKit::WebVector<WebKit::WebTextCheckingResult>());
+  last_results_.assign(blink::WebVector<blink::WebTextCheckingResult>());
 
 #if defined(OS_MACOSX)
   // Text check (unified request for grammar and spell check) is only
@@ -106,10 +106,10 @@ bool SpellCheckProvider::OnMessageReceived(const IPC::Message& message) {
   return handled;
 }
 
-void SpellCheckProvider::FocusedNodeChanged(const WebKit::WebNode& unused) {
+void SpellCheckProvider::FocusedNodeChanged(const blink::WebNode& unused) {
 #if defined(OS_MACOSX)
   bool enabled = false;
-  WebKit::WebNode node = render_view()->GetFocusedNode();
+  blink::WebNode node = render_view()->GetFocusedNode();
   if (!node.isNull())
     enabled = render_view()->IsEditableNode(node);
 
@@ -146,13 +146,13 @@ void SpellCheckProvider::spellCheck(
 }
 
 void SpellCheckProvider::checkTextOfParagraph(
-    const WebKit::WebString& text,
-    WebKit::WebTextCheckingTypeMask mask,
-    WebKit::WebVector<WebKit::WebTextCheckingResult>* results) {
+    const blink::WebString& text,
+    blink::WebTextCheckingTypeMask mask,
+    blink::WebVector<blink::WebTextCheckingResult>* results) {
   if (!results)
     return;
 
-  if (!(mask & WebKit::WebTextCheckingTypeSpelling))
+  if (!(mask & blink::WebTextCheckingTypeSpelling))
     return;
 
   // TODO(groby): As far as I can tell, this method is never invoked.
@@ -224,7 +224,7 @@ void SpellCheckProvider::OnRespondSpellingService(
 
   // Double-check the returned spellchecking results with our spellchecker to
   // visualize the differences between ours and the on-line spellchecker.
-  WebKit::WebVector<WebKit::WebTextCheckingResult> textcheck_results;
+  blink::WebVector<blink::WebTextCheckingResult> textcheck_results;
   spellcheck_->CreateTextCheckingResults(SpellCheck::USE_NATIVE_CHECKER,
                                          0,
                                          line,
@@ -271,7 +271,7 @@ void SpellCheckProvider::OnRespondTextCheck(
   if (!completion)
     return;
   text_check_completions_.Remove(identifier);
-  WebKit::WebVector<WebKit::WebTextCheckingResult> textcheck_results;
+  blink::WebVector<blink::WebTextCheckingResult> textcheck_results;
   spellcheck_->CreateTextCheckingResults(SpellCheck::DO_NOT_MODIFY,
                                          0,
                                          string16(),
@@ -344,7 +344,7 @@ bool SpellCheckProvider::SatisfyRequestFromCache(
         ++result_size;
     }
     if (result_size > 0) {
-      WebKit::WebVector<WebKit::WebTextCheckingResult> results(result_size);
+      blink::WebVector<blink::WebTextCheckingResult> results(result_size);
       for (size_t i = 0; i < result_size; ++i) {
         results[i].decoration = last_results_[i].decoration;
         results[i].location = last_results_[i].location;
diff --git a/chrome/renderer/spellchecker/spellcheck_provider.h b/chrome/renderer/spellchecker/spellcheck_provider.h
index d7c7609..e9f0c53 100644
--- a/chrome/renderer/spellchecker/spellcheck_provider.h
+++ b/chrome/renderer/spellchecker/spellcheck_provider.h
@@ -17,7 +17,7 @@ class SpellCheck;
 class SpellCheckMarker;
 struct SpellCheckResult;
 
-namespace WebKit {
+namespace blink {
 class WebString;
 class WebTextCheckingCompletion;
 struct WebTextCheckingResult;
@@ -28,9 +28,9 @@ struct WebTextCheckingResult;
 class SpellCheckProvider
     : public content::RenderViewObserver,
       public content::RenderViewObserverTracker<SpellCheckProvider>,
-      public WebKit::WebSpellCheckClient {
+      public blink::WebSpellCheckClient {
  public:
-  typedef IDMap<WebKit::WebTextCheckingCompletion> WebTextCheckCompletions;
+  typedef IDMap<blink::WebTextCheckingCompletion> WebTextCheckCompletions;
 
   SpellCheckProvider(content::RenderView* render_view,
                      SpellCheck* spellcheck);
@@ -40,7 +40,7 @@ class SpellCheckProvider
   // checker, which is available on the browser process.
   void RequestTextChecking(
       const string16& text,
-      WebKit::WebTextCheckingCompletion* completion,
+      blink::WebTextCheckingCompletion* completion,
       const std::vector<SpellCheckMarker>& markers);
 
   // The number of ongoing IPC requests.
@@ -56,7 +56,7 @@ class SpellCheckProvider
 
   // RenderViewObserver implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
-  virtual void FocusedNodeChanged(const WebKit::WebNode& node) OVERRIDE;
+  virtual void FocusedNodeChanged(const blink::WebNode& node) OVERRIDE;
 
  private:
   friend class TestingSpellCheckProvider;
@@ -65,31 +65,31 @@ class SpellCheckProvider
   // Returns true (and cancels/finishes the completion) if it can, false
   // if the provider should forward the query on.
   bool SatisfyRequestFromCache(const string16& text,
-                               WebKit::WebTextCheckingCompletion* completion);
+                               blink::WebTextCheckingCompletion* completion);
 
-  // WebKit::WebSpellCheckClient implementation.
+  // blink::WebSpellCheckClient implementation.
   virtual void spellCheck(
-      const WebKit::WebString& text,
+      const blink::WebString& text,
       int& offset,
       int& length,
-      WebKit::WebVector<WebKit::WebString>* optional_suggestions) OVERRIDE;
+      blink::WebVector<blink::WebString>* optional_suggestions) OVERRIDE;
   virtual void checkTextOfParagraph(
-      const WebKit::WebString& text,
-      WebKit::WebTextCheckingTypeMask mask,
-      WebKit::WebVector<WebKit::WebTextCheckingResult>* results) OVERRIDE;
+      const blink::WebString& text,
+      blink::WebTextCheckingTypeMask mask,
+      blink::WebVector<blink::WebTextCheckingResult>* results) OVERRIDE;
 
   virtual void requestCheckingOfText(
-      const WebKit::WebString& text,
-      const WebKit::WebVector<uint32>& markers,
-      const WebKit::WebVector<unsigned>& marker_offsets,
-      WebKit::WebTextCheckingCompletion* completion) OVERRIDE;
+      const blink::WebString& text,
+      const blink::WebVector<uint32>& markers,
+      const blink::WebVector<unsigned>& marker_offsets,
+      blink::WebTextCheckingCompletion* completion) OVERRIDE;
 
-  virtual WebKit::WebString autoCorrectWord(
-      const WebKit::WebString& misspelled_word) OVERRIDE;
+  virtual blink::WebString autoCorrectWord(
+      const blink::WebString& misspelled_word) OVERRIDE;
   virtual void showSpellingUI(bool show) OVERRIDE;
   virtual bool isShowingSpellingUI() OVERRIDE;
   virtual void updateSpellingUIWithMisspelledWord(
-      const WebKit::WebString& word) OVERRIDE;
+      const blink::WebString& word) OVERRIDE;
 
 #if !defined(OS_MACOSX)
   void OnRespondSpellingService(
@@ -117,7 +117,7 @@ class SpellCheckProvider
   // The last text sent to the browser process to spellcheck it and its
   // spellchecking results.
   string16 last_request_;
-  WebKit::WebVector<WebKit::WebTextCheckingResult> last_results_;
+  blink::WebVector<blink::WebTextCheckingResult> last_results_;
 
   // True if the browser is showing the spelling panel for us.
   bool spelling_panel_visible_;
diff --git a/chrome/renderer/spellchecker/spellcheck_provider_hunspell_unittest.cc b/chrome/renderer/spellchecker/spellcheck_provider_hunspell_unittest.cc
index 11dcd9d..a08fb78 100644
--- a/chrome/renderer/spellchecker/spellcheck_provider_hunspell_unittest.cc
+++ b/chrome/renderer/spellchecker/spellcheck_provider_hunspell_unittest.cc
@@ -18,7 +18,7 @@ namespace {
 
 TEST_F(SpellCheckProviderTest, UsingHunspell) {
   FakeTextCheckingCompletion completion;
-  provider_.RequestTextChecking(WebKit::WebString("hello"),
+  provider_.RequestTextChecking(blink::WebString("hello"),
                                 &completion,
                                 std::vector<SpellCheckMarker>());
   EXPECT_EQ(completion.completion_count_, 1U);
@@ -35,20 +35,20 @@ TEST_F(SpellCheckProviderTest, MultiLineText) {
   // Verify that the SpellCheckProvider class does not spellcheck empty text.
   provider_.ResetResult();
   provider_.RequestTextChecking(
-      WebKit::WebString(), &completion, std::vector<SpellCheckMarker>());
+      blink::WebString(), &completion, std::vector<SpellCheckMarker>());
   EXPECT_TRUE(provider_.text_.empty());
 
   // Verify that the SpellCheckProvider class does not spellcheck text while we
   // are typing a word.
   provider_.ResetResult();
   provider_.RequestTextChecking(
-      WebKit::WebString("First"), &completion, std::vector<SpellCheckMarker>());
+      blink::WebString("First"), &completion, std::vector<SpellCheckMarker>());
   EXPECT_TRUE(provider_.text_.empty());
 
   // Verify that the SpellCheckProvider class spellcheck the first word when we
   // type a space key, i.e. when we finish typing a word.
   provider_.ResetResult();
-  provider_.RequestTextChecking(WebKit::WebString("First "),
+  provider_.RequestTextChecking(blink::WebString("First "),
                                 &completion,
                                 std::vector<SpellCheckMarker>());
   EXPECT_EQ(ASCIIToUTF16("First "), provider_.text_);
@@ -56,7 +56,7 @@ TEST_F(SpellCheckProviderTest, MultiLineText) {
   // Verify that the SpellCheckProvider class spellcheck the first line when we
   // type a return key, i.e. when we finish typing a line.
   provider_.ResetResult();
-  provider_.RequestTextChecking(WebKit::WebString("First Second\n"),
+  provider_.RequestTextChecking(blink::WebString("First Second\n"),
                                 &completion,
                                 std::vector<SpellCheckMarker>());
   EXPECT_EQ(ASCIIToUTF16("First Second\n"), provider_.text_);
@@ -64,7 +64,7 @@ TEST_F(SpellCheckProviderTest, MultiLineText) {
   // Verify that the SpellCheckProvider class spellcheck the lines when we
   // finish typing a word "Third" to the second line.
   provider_.ResetResult();
-  provider_.RequestTextChecking(WebKit::WebString("First Second\nThird "),
+  provider_.RequestTextChecking(blink::WebString("First Second\nThird "),
                                 &completion,
                                 std::vector<SpellCheckMarker>());
   EXPECT_EQ(ASCIIToUTF16("First Second\nThird "), provider_.text_);
@@ -72,7 +72,7 @@ TEST_F(SpellCheckProviderTest, MultiLineText) {
   // Verify that the SpellCheckProvider class does not send a spellcheck request
   // when a user inserts whitespace characters.
   provider_.ResetResult();
-  provider_.RequestTextChecking(WebKit::WebString("First Second\nThird   "),
+  provider_.RequestTextChecking(blink::WebString("First Second\nThird   "),
                                 &completion,
                                 std::vector<SpellCheckMarker>());
   EXPECT_TRUE(provider_.text_.empty());
@@ -81,7 +81,7 @@ TEST_F(SpellCheckProviderTest, MultiLineText) {
   // a period.
   provider_.ResetResult();
   provider_.RequestTextChecking(
-      WebKit::WebString("First Second\nThird   Fourth."),
+      blink::WebString("First Second\nThird   Fourth."),
       &completion,
       std::vector<SpellCheckMarker>());
   EXPECT_EQ(ASCIIToUTF16("First Second\nThird   Fourth."), provider_.text_);
@@ -91,7 +91,7 @@ TEST_F(SpellCheckProviderTest, MultiLineText) {
 // spelling service when not necessary.
 TEST_F(SpellCheckProviderTest, CancelUnnecessaryRequests) {
   FakeTextCheckingCompletion completion;
-  provider_.RequestTextChecking(WebKit::WebString("hello."),
+  provider_.RequestTextChecking(blink::WebString("hello."),
                                 &completion,
                                 std::vector<SpellCheckMarker>());
   EXPECT_EQ(completion.completion_count_, 1U);
@@ -100,7 +100,7 @@ TEST_F(SpellCheckProviderTest, CancelUnnecessaryRequests) {
 
   // Test that the SpellCheckProvider does not send a request with the same text
   // as above.
-  provider_.RequestTextChecking(WebKit::WebString("hello."),
+  provider_.RequestTextChecking(blink::WebString("hello."),
                                 &completion,
                                 std::vector<SpellCheckMarker>());
   EXPECT_EQ(completion.completion_count_, 2U);
@@ -109,7 +109,7 @@ TEST_F(SpellCheckProviderTest, CancelUnnecessaryRequests) {
 
   // Test that the SpellCheckProvider class cancels an incoming request that
   // does not include any words.
-  provider_.RequestTextChecking(WebKit::WebString(":-)"),
+  provider_.RequestTextChecking(blink::WebString(":-)"),
                                 &completion,
                                 std::vector<SpellCheckMarker>());
   EXPECT_EQ(completion.completion_count_, 3U);
@@ -119,7 +119,7 @@ TEST_F(SpellCheckProviderTest, CancelUnnecessaryRequests) {
   // Test that the SpellCheckProvider class sends a request when it receives a
   // Russian word.
   const wchar_t kRussianWord[] = L"\x0431\x0451\x0434\x0440\x0430";
-  provider_.RequestTextChecking(WebKit::WebString(WideToUTF16(kRussianWord)),
+  provider_.RequestTextChecking(blink::WebString(WideToUTF16(kRussianWord)),
                                 &completion,
                                 std::vector<SpellCheckMarker>());
   EXPECT_EQ(completion.completion_count_, 4U);
@@ -134,20 +134,20 @@ TEST_F(SpellCheckProviderTest, CompleteNecessaryRequests) {
 
   string16 text = ASCIIToUTF16("Icland is an icland ");
   provider_.RequestTextChecking(
-      WebKit::WebString(text), &completion, std::vector<SpellCheckMarker>());
+      blink::WebString(text), &completion, std::vector<SpellCheckMarker>());
   EXPECT_EQ(0U, completion.cancellation_count_) << "Should finish checking \""
                                                 << text << "\"";
 
   const int kSubstringLength = 18;
   string16 substring = text.substr(0, kSubstringLength);
-  provider_.RequestTextChecking(WebKit::WebString(substring),
+  provider_.RequestTextChecking(blink::WebString(substring),
                                 &completion,
                                 std::vector<SpellCheckMarker>());
   EXPECT_EQ(0U, completion.cancellation_count_) << "Should finish checking \""
                                                 << substring << "\"";
 
   provider_.RequestTextChecking(
-      WebKit::WebString(text), &completion, std::vector<SpellCheckMarker>());
+      blink::WebString(text), &completion, std::vector<SpellCheckMarker>());
   EXPECT_EQ(0U, completion.cancellation_count_) << "Should finish checking \""
                                                 << text << "\"";
 }
@@ -156,21 +156,21 @@ TEST_F(SpellCheckProviderTest, CompleteNecessaryRequests) {
 // a word.
 TEST_F(SpellCheckProviderTest, CancelMidWordRequests) {
   FakeTextCheckingCompletion completion;
-  provider_.RequestTextChecking(WebKit::WebString("hello "),
+  provider_.RequestTextChecking(blink::WebString("hello "),
                                 &completion,
                                 std::vector<SpellCheckMarker>());
   EXPECT_EQ(completion.completion_count_, 1U);
   EXPECT_EQ(completion.cancellation_count_, 0U);
   EXPECT_EQ(provider_.spelling_service_call_count_, 1U);
 
-  provider_.RequestTextChecking(WebKit::WebString("hello world"),
+  provider_.RequestTextChecking(blink::WebString("hello world"),
                                 &completion,
                                 std::vector<SpellCheckMarker>());
   EXPECT_EQ(completion.completion_count_, 2U);
   EXPECT_EQ(completion.cancellation_count_, 1U);
   EXPECT_EQ(provider_.spelling_service_call_count_, 1U);
 
-  provider_.RequestTextChecking(WebKit::WebString("hello world."),
+  provider_.RequestTextChecking(blink::WebString("hello world."),
                                 &completion,
                                 std::vector<SpellCheckMarker>());
   EXPECT_EQ(completion.completion_count_, 3U);
diff --git a/chrome/renderer/spellchecker/spellcheck_provider_mac_unittest.cc b/chrome/renderer/spellchecker/spellcheck_provider_mac_unittest.cc
index 852756d..1a04523 100644
--- a/chrome/renderer/spellchecker/spellcheck_provider_mac_unittest.cc
+++ b/chrome/renderer/spellchecker/spellcheck_provider_mac_unittest.cc
@@ -53,7 +53,7 @@ void FakeMessageArrival(SpellCheckProvider* provider,
 TEST_F(SpellCheckProviderMacTest, SingleRoundtripSuccess) {
   FakeTextCheckingCompletion completion;
 
-  provider_.RequestTextChecking(WebKit::WebString("hello "),
+  provider_.RequestTextChecking(blink::WebString("hello "),
                                 &completion,
                                 std::vector<SpellCheckMarker>());
   EXPECT_EQ(completion.completion_count_, 0U);
@@ -71,11 +71,11 @@ TEST_F(SpellCheckProviderMacTest, SingleRoundtripSuccess) {
 
 TEST_F(SpellCheckProviderMacTest, TwoRoundtripSuccess) {
   FakeTextCheckingCompletion completion1;
-  provider_.RequestTextChecking(WebKit::WebString("hello "),
+  provider_.RequestTextChecking(blink::WebString("hello "),
                                 &completion1,
                                 std::vector<SpellCheckMarker>());
   FakeTextCheckingCompletion completion2;
-  provider_.RequestTextChecking(WebKit::WebString("bye "),
+  provider_.RequestTextChecking(blink::WebString("bye "),
                                 &completion2,
                                 std::vector<SpellCheckMarker>());
 
diff --git a/chrome/renderer/spellchecker/spellcheck_provider_test.cc b/chrome/renderer/spellchecker/spellcheck_provider_test.cc
index 59fe3f6..427c3e1 100644
--- a/chrome/renderer/spellchecker/spellcheck_provider_test.cc
+++ b/chrome/renderer/spellchecker/spellcheck_provider_test.cc
@@ -21,7 +21,7 @@ FakeTextCheckingCompletion::FakeTextCheckingCompletion()
 FakeTextCheckingCompletion::~FakeTextCheckingCompletion() {}
 
 void FakeTextCheckingCompletion::didFinishCheckingText(
-    const WebKit::WebVector<WebKit::WebTextCheckingResult>& results) {
+    const blink::WebVector<blink::WebTextCheckingResult>& results) {
   ++completion_count_;
 }
 
@@ -67,7 +67,7 @@ void TestingSpellCheckProvider::OnCallSpellingService(int route_id,
   NOTREACHED();
 #else
   ++spelling_service_call_count_;
-  WebKit::WebTextCheckingCompletion* completion =
+  blink::WebTextCheckingCompletion* completion =
       text_check_completions_.Lookup(identifier);
   if (!completion) {
     ResetResult();
@@ -75,10 +75,10 @@ void TestingSpellCheckProvider::OnCallSpellingService(int route_id,
   }
   text_.assign(text);
   text_check_completions_.Remove(identifier);
-  std::vector<WebKit::WebTextCheckingResult> results;
-  results.push_back(WebKit::WebTextCheckingResult(
-      WebKit::WebTextDecorationTypeSpelling,
-      0, 5, WebKit::WebString("hello")));
+  std::vector<blink::WebTextCheckingResult> results;
+  results.push_back(blink::WebTextCheckingResult(
+      blink::WebTextDecorationTypeSpelling,
+      0, 5, blink::WebString("hello")));
   completion->didFinishCheckingText(results);
   last_request_ = text;
   last_results_ = results;
diff --git a/chrome/renderer/spellchecker/spellcheck_provider_test.h b/chrome/renderer/spellchecker/spellcheck_provider_test.h
index bda4fef..878c948 100644
--- a/chrome/renderer/spellchecker/spellcheck_provider_test.h
+++ b/chrome/renderer/spellchecker/spellcheck_provider_test.h
@@ -20,13 +20,13 @@ namespace IPC {
 }
 
 // A fake completion object for verification.
-class FakeTextCheckingCompletion : public WebKit::WebTextCheckingCompletion {
+class FakeTextCheckingCompletion : public blink::WebTextCheckingCompletion {
  public:
   FakeTextCheckingCompletion();
   ~FakeTextCheckingCompletion();
 
   virtual void didFinishCheckingText(
-      const WebKit::WebVector<WebKit::WebTextCheckingResult>& results) OVERRIDE;
+      const blink::WebVector<blink::WebTextCheckingResult>& results) OVERRIDE;
   virtual void didCancelCheckingText() OVERRIDE;
 
 
diff --git a/chrome/renderer/spellchecker/spellcheck_unittest.cc b/chrome/renderer/spellchecker/spellcheck_unittest.cc
index 8b9aeac..27fae68 100644
--- a/chrome/renderer/spellchecker/spellcheck_unittest.cc
+++ b/chrome/renderer/spellchecker/spellcheck_unittest.cc
@@ -89,14 +89,14 @@ class SpellCheckTest : public testing::Test {
   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);
     }
@@ -109,14 +109,14 @@ class SpellCheckTest : public testing::Test {
 };
 
 // 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;
@@ -127,7 +127,7 @@ class MockTextCheckingCompletion : public WebKit::WebTextCheckingCompletion {
   }
 
   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
@@ -1123,14 +1123,14 @@ TEST_F(SpellCheckTest, CreateTextCheckingResults) {
     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);
@@ -1143,14 +1143,14 @@ TEST_F(SpellCheckTest, CreateTextCheckingResults) {
     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);