Rename WebKit namespace to blink (part 4)

chrome/renderer/spellchecker/spellcheck.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 "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/spellcheck_common.h"
 #include "chrome/common/spellcheck_messages.h"
 #include "chrome/common/spellcheck_result.h"
 #include "chrome/renderer/spellchecker/spellcheck_language.h"
 #include "chrome/renderer/spellchecker/spellcheck_provider.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/render_view_visitor.h"
 #include "third_party/WebKit/public/web/WebTextCheckingCompletion.h"
 #include "third_party/WebKit/public/web/WebTextCheckingResult.h"
 #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 {
 
 class UpdateSpellcheckEnabled : public content::RenderViewVisitor {
  public:
   explicit UpdateSpellcheckEnabled(bool enabled) : enabled_(enabled) {}
   virtual bool Visit(content::RenderView* render_view) OVERRIDE;
 
  private:
   bool enabled_;  // New spellcheck-enabled state.
@@ skipping 28 matching lines @@
     markers_.push_back(markers[i]);
   // Visit all render views.
   return true;
 }
 
 }  // namespace
 
 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);
 };
 
 
 // Initializes SpellCheck object.
 // spellcheck_enabled_ currently MUST be set to true, due to peculiarities of
 // the initialization sequence.
 // Since it defaults to true, newly created SpellCheckProviders will enable
 // spellchecking. After the first word is typed, the provider requests a check,
@@ skipping 121 matching lines @@
                        &misspelling_length,
                        NULL)) {
       results->assign(textcheck_results);
       return true;
     }
 
     if (!custom_dictionary_.SpellCheckWord(
             text, misspelling_start + offset, misspelling_length)) {
       string16 replacement;
       textcheck_results.push_back(WebTextCheckingResult(
-          WebKit::WebTextDecorationTypeSpelling,
+          blink::WebTextDecorationTypeSpelling,
           misspelling_start + offset,
           misspelling_length,
           replacement));
     }
     offset += misspelling_start + misspelling_length;
   }
   results->assign(textcheck_results);
   return false;
 #else
   // This function is only invoked for spell checker functionality that runs
@@ skipping 51 matching lines @@
 
     // Restore the swapped characters.
     std::swap(misspelled_word[i], misspelled_word[i + 1]);
   }
   return autocorrect_word;
 }
 
 #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();
 
   pending_request_param_.reset(new SpellcheckRequest(
       text, completion));
   // We will check this text after we finish loading the hunspell dictionary.
   if (InitializeIfNeeded())
     return;
 
@@ skipping 17 matching lines @@
 }
 #endif
 
 #if !defined(OS_MACOSX)  // Mac uses its native engine instead.
 void SpellCheck::PerformSpellCheck(SpellcheckRequest* param) {
   DCHECK(param);
 
   if (!spellcheck_.IsEnabled()) {
     param->completion()->didCancelCheckingText();
   } else {
-    WebVector<WebKit::WebTextCheckingResult> results;
+    WebVector<blink::WebTextCheckingResult> results;
     SpellCheckParagraph(param->text(), &results);
     param->completion()->didFinishCheckingText(results);
   }
 }
 #endif
 
 void SpellCheck::CreateTextCheckingResults(
     ResultFilter filter,
     int line_offset,
     const string16& line_text,
@@ skipping 22 matching lines @@
       list.push_back(WebTextCheckingResult(
           static_cast<WebTextDecorationType>(decoration),
           word_location + line_offset,
           word_length,
           spellcheck_results[i].replacement,
           spellcheck_results[i].hash));
     }
   }
   textcheck_results->assign(list);
 }