Removed WebTextCheckingResult legacy API use.

chrome/renderer/spellchecker/spellcheck_provider.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_provider.h"
 
 #include "base/command_line.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/spellcheck_messages.h"
+#include "chrome/common/spellcheck_result.h"
 #include "chrome/renderer/chrome_content_renderer_client.h"
 #include "chrome/renderer/spellchecker/spellcheck.h"
 #include "content/public/renderer/render_view.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebTextCheckingCompletion.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebTextCheckingResult.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebTextCheckingType.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebVector.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 
 using WebKit::WebFrame;
 using WebKit::WebString;
 using WebKit::WebTextCheckingCompletion;
 using WebKit::WebTextCheckingResult;
+using WebKit::WebTextCheckingType;
 using WebKit::WebVector;
 
+COMPILE_ASSERT(int(WebKit::WebTextCheckingTypeSpelling) ==
+               int(SpellCheckResult::Spelling), mismatching_enums);
+COMPILE_ASSERT(int(WebKit::WebTextCheckingTypeGrammar) ==
+               int(SpellCheckResult::Grammar), mismatching_enums);
+COMPILE_ASSERT(int(WebKit::WebTextCheckingTypeLink) ==
+               int(SpellCheckResult::Link), mismatching_enums);
+COMPILE_ASSERT(int(WebKit::WebTextCheckingTypeQuote) ==
+               int(SpellCheckResult::Quote), mismatching_enums);
+COMPILE_ASSERT(int(WebKit::WebTextCheckingTypeDash) ==
+               int(SpellCheckResult::Dash), mismatching_enums);
+COMPILE_ASSERT(int(WebKit::WebTextCheckingTypeReplacement) ==
+               int(SpellCheckResult::Replacement), mismatching_enums);
+COMPILE_ASSERT(int(WebKit::WebTextCheckingTypeCorrection) ==
+               int(SpellCheckResult::Correction), mismatching_enums);
+COMPILE_ASSERT(int(WebKit::WebTextCheckingTypeShowCorrectionPanel) ==
+               int(SpellCheckResult::ShowCorrectionPanel), mismatching_enums);
+
+void ToWebResultList(

[Hironori Bono, 2012/02/16 04:22:45]

nit: need 'namespace {' above this function to prevent these functions from
becoming global ones.

+    const std::vector<SpellCheckResult>& results,
+    WebVector<WebTextCheckingResult>* web_results) {
+  WebVector<WebTextCheckingResult> list(results.size());
+  for (size_t i = 0; i < results.size(); ++i) {
+    list[i] = WebTextCheckingResult(
+        static_cast<WebTextCheckingType>(results[i].type()),
+        results[i].location(),
+        results[i].length(),
+        results[i].replacement());
+  }
+
+  list.swap(*web_results);
+}
+
+WebVector<WebTextCheckingResult> ToWebResultList(
+    const std::vector<SpellCheckResult>& results) {
+  WebVector<WebTextCheckingResult> web_results;
+  ToWebResultList(results, &web_results);
+  return web_results;
+}

[Hironori Bono, 2012/02/16 04:22:45]

nit: need '}  // namespace' here.

+
 SpellCheckProvider::SpellCheckProvider(
     content::RenderView* render_view,
     chrome::ChromeContentRendererClient* renderer_client)
     : content::RenderViewObserver(render_view),
 #if defined(OS_MACOSX)
       has_document_tag_(false),
 #endif
       document_tag_(0),
       spelling_panel_visible_(false),
       chrome_content_renderer_client_(renderer_client) {
@@ skipping 114 matching lines @@
 
   if (!(mask & WebKit::WebTextCheckingTypeSpelling))
     return;
 
   EnsureDocumentTag();
 
   // Will be NULL during unit tets.
   if (!chrome_content_renderer_client_)
     return;
 
-  std::vector<WebKit::WebTextCheckingResult> tmp_results;
+  std::vector<SpellCheckResult> tmp_results;
   chrome_content_renderer_client_->spellcheck()->SpellCheckParagraph(
       string16(text),
       document_tag_,
       &tmp_results);
-  *results = tmp_results;
+  ToWebResultList(tmp_results, results);
 #endif
 }
 
 void SpellCheckProvider::requestCheckingOfText(
     const WebString& text,
     WebTextCheckingCompletion* completion) {
   RequestTextChecking(text, document_tag_, completion);
 }
 
 WebString SpellCheckProvider::autoCorrectWord(const WebString& word) {
@@ skipping 31 matching lines @@
   if (!render_view()->GetWebView())
     return;
   render_view()->GetWebView()->focusedFrame()->executeCommand(
       WebString::fromUTF8("AdvanceToNextMisspelling"));
 }
 
 #if !defined(OS_MACOSX)
 void SpellCheckProvider::OnRespondSpellingService(
     int identifier,
     int tag,
-    const std::vector<WebTextCheckingResult>& results) {
+    const std::vector<SpellCheckResult>& results) {
   WebTextCheckingCompletion* completion =
       text_check_completions_.Lookup(identifier);
   if (!completion)
     return;
   text_check_completions_.Remove(identifier);
-  completion->didFinishCheckingText(results);
+  completion->didFinishCheckingText(ToWebResultList(results));
 }
 #endif
 
 #if defined(OS_MACOSX)
 void SpellCheckProvider::OnRespondTextCheck(
     int identifier,
     int tag,
-    const std::vector<WebTextCheckingResult>& results) {
+    const std::vector<SpellCheckResult>& results) {
   WebTextCheckingCompletion* completion =
       text_check_completions_.Lookup(identifier);
   if (!completion)
     return;
   text_check_completions_.Remove(identifier);
-  completion->didFinishCheckingText(results);
+  completion->didFinishCheckingText(ToWebResultList(results));
 }
 #endif
 
 void SpellCheckProvider::OnToggleSpellPanel(bool is_currently_visible) {
   if (!render_view()->GetWebView())
     return;
   // We need to tell the webView whether the spelling panel is visible or not so
   // that it won't need to make ipc calls later.
   spelling_panel_visible_ = is_currently_visible;
   render_view()->GetWebView()->focusedFrame()->executeCommand(
@@ skipping 13 matching lines @@
   // TODO(darin): There's actually no reason for this to be here.  We should
   // have the browser side manage the document tag.
 #if defined(OS_MACOSX)
   if (!has_document_tag_) {
     // Make the call to get the tag.
     Send(new SpellCheckHostMsg_GetDocumentTag(routing_id(), &document_tag_));
     has_document_tag_ = true;
   }
 #endif
 }