[Spellcheck] Removing cruft.

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"
@@ skipping 23 matching lines @@
                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);
 
-namespace {
-
-// Converts a vector of SpellCheckResult objects (used by Chrome) to a vector of
-// WebTextCheckingResult objects (used by WebKit).
-void CreateTextCheckingResults(
-    int offset,
-    const std::vector<SpellCheckResult>& spellcheck_results,
-    WebKit::WebVector<WebKit::WebTextCheckingResult>* textcheck_results) {
-  size_t result_size = spellcheck_results.size();
-  WebKit::WebVector<WebKit::WebTextCheckingResult> list(result_size);
-  for (size_t i = 0; i < result_size; ++i) {
-    list[i] = WebTextCheckingResult(
-        static_cast<WebTextCheckingType>(spellcheck_results[i].type),
-        spellcheck_results[i].location + offset,
-        spellcheck_results[i].length,
-        spellcheck_results[i].replacement);
-  }
-  textcheck_results->swap(list);
-}
-
-}  // namespace
-
 SpellCheckProvider::SpellCheckProvider(
     content::RenderView* render_view,
     SpellCheck* spellcheck)
     : content::RenderViewObserver(render_view),
       content::RenderViewObserverTracker<SpellCheckProvider>(render_view),
       spelling_panel_visible_(false),
       spellcheck_(spellcheck) {
+  DCHECK(spellcheck_);
   if (render_view)  // NULL in unit tests.
     render_view->GetWebView()->setSpellCheckClient(this);
 }
 
 SpellCheckProvider::~SpellCheckProvider() {
 #if defined(OS_MACOSX)
-  Send(new SpellCheckHostMsg_DocumentClosed(
-      routing_id(), routing_id()));
+  Send(new SpellCheckHostMsg_DocumentClosed(routing_id(), routing_id()));
 #endif
 }
 
 void SpellCheckProvider::RequestTextChecking(
     const WebString& text,
     WebTextCheckingCompletion* completion) {
 #if defined(OS_MACOSX)
   // Text check (unified request for grammar and spell check) is only
   // available for browser process, so we ask the system spellchecker
   // over IPC or return an empty result if the checker is not
@@ skipping 13 matching lines @@
   // Try to satisfy check from cache.
   // TODO(groby): Should that be applied to OSX results, too?
   if (SatisfyRequestFromCache(text, completion))
     return;
 
   // 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>());
 
-
   Send(new SpellCheckHostMsg_CallSpellingService(
       routing_id(),
       text_check_completions_.Add(completion),
       0,
       string16(text)));
 #endif  // !OS_MACOSX
 }
 
 bool SpellCheckProvider::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
@@ skipping 31 matching lines @@
   Send(new SpellCheckHostMsg_ToggleSpellCheck(routing_id(), enabled, checked));
 #endif  // OS_MACOSX
 }
 
 void SpellCheckProvider::spellCheck(
     const WebString& text,
     int& offset,
     int& length,
     WebVector<WebString>* optional_suggestions) {
   string16 word(text);
-  // Will be NULL during unit tests.
-  if (spellcheck_) {
-    std::vector<string16> suggestions;
-    spellcheck_->SpellCheckWord(
-        word.c_str(), word.size(), routing_id(),
-        &offset, &length, optional_suggestions ? & suggestions : NULL);
-    if (optional_suggestions)
-      *optional_suggestions = suggestions;
-    if (!optional_suggestions) {
-      // If optional_suggestions is not requested, the API is called
-      // for marking.  So we use this for counting markable words.
-      Send(new SpellCheckHostMsg_NotifyChecked(routing_id(), word, 0 < length));
-    }
+  std::vector<string16> suggestions;
+  spellcheck_->SpellCheckWord(
+      word.c_str(), word.size(), routing_id(),
+      &offset, &length, optional_suggestions ? & suggestions : NULL);
+  if (optional_suggestions)
+    *optional_suggestions = suggestions;
+  if (!optional_suggestions) {
+    // If optional_suggestions is not requested, the API is called
+    // for marking.  So we use this for counting markable words.
+    Send(new SpellCheckHostMsg_NotifyChecked(routing_id(), word, 0 < length));
   }
 }
 
 void SpellCheckProvider::checkTextOfParagraph(
     const WebKit::WebString& text,
     WebKit::WebTextCheckingTypeMask mask,
     WebKit::WebVector<WebKit::WebTextCheckingResult>* results) {
 #if !defined(OS_MACOSX)
   // Since Mac has its own spell checker, this method will not be used on Mac.
 
   if (!results)
     return;
 
   if (!(mask & WebKit::WebTextCheckingTypeSpelling))
     return;
 
-  // Will be NULL during unit tets.
-  if (!spellcheck_)
-    return;
-
   spellcheck_->SpellCheckParagraph(string16(text), results);
 #endif
 }
 
 void SpellCheckProvider::requestCheckingOfText(
     const WebString& text,
     WebTextCheckingCompletion* completion) {
   RequestTextChecking(text, completion);
 }
 
 WebString SpellCheckProvider::autoCorrectWord(const WebString& word) {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-  if (command_line.HasSwitch(switches::kEnableSpellingAutoCorrect)) {
-    // Will be NULL during unit tests.
-    if (spellcheck_) {
-      return spellcheck_->GetAutoCorrectionWord(word, routing_id());
-    }
-  }
+  if (command_line.HasSwitch(switches::kEnableSpellingAutoCorrect))
+    return spellcheck_->GetAutoCorrectionWord(word, routing_id());
   return string16();
 }
 
 void SpellCheckProvider::showSpellingUI(bool show) {
 #if defined(OS_MACOSX)
   Send(new SpellCheckHostMsg_ShowSpellingPanel(routing_id(), show));
 #endif
 }
 
 bool SpellCheckProvider::isShowingSpellingUI() {
@@ skipping 16 matching lines @@
     const string16& line,
     const std::vector<SpellCheckResult>& results) {
   WebTextCheckingCompletion* completion =
       text_check_completions_.Lookup(identifier);
   if (!completion)
     return;
   text_check_completions_.Remove(identifier);
 
   // If |succeeded| is false, we use local spellcheck as a fallback.
   if (!succeeded) {
-    // |spellcheck_| may be NULL in unit tests.
-    if (spellcheck_) {
-      spellcheck_->RequestTextChecking(line, offset, completion);
-      return;
-    }
+    spellcheck_->RequestTextChecking(line, offset, completion);
+    return;
   }
 
   // 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;
-  if (spellcheck_) {
-    spellcheck_->CreateTextCheckingResults(
-        offset, line, results, &textcheck_results);
-  } else {
-    CreateTextCheckingResults(offset, results, &textcheck_results);
-  }
+  spellcheck_->CreateTextCheckingResults(SpellCheck::USE_NATIVE_CHECKER,
+                                         offset,
+                                         line,
+                                         results,
+                                         &textcheck_results);
   completion->didFinishCheckingText(textcheck_results);
 
   // Cache the request and the converted results.
   last_request_ = line;
   last_results_.swap(textcheck_results);
 }
 
 bool SpellCheckProvider::HasWordCharacters(
     const WebKit::WebString& text,
     int index) const {
@@ skipping 14 matching lines @@
 void SpellCheckProvider::OnAdvanceToNextMisspelling() {
   if (!render_view()->GetWebView())
     return;
   render_view()->GetWebView()->focusedFrame()->executeCommand(
       WebString::fromUTF8("AdvanceToNextMisspelling"));
 }
 
 void SpellCheckProvider::OnRespondTextCheck(
     int identifier,
     const std::vector<SpellCheckResult>& results) {
+  DCHECK(spellcheck_);
   WebTextCheckingCompletion* completion =
       text_check_completions_.Lookup(identifier);
   if (!completion)
     return;
   text_check_completions_.Remove(identifier);
   WebKit::WebVector<WebKit::WebTextCheckingResult> textcheck_results;
-  CreateTextCheckingResults(0, results, &textcheck_results);
+  spellcheck_->CreateTextCheckingResults(SpellCheck::DO_NOT_MODIFY,
+                                         0,
+                                         string16(),
+                                         results,
+                                         &textcheck_results);
   completion->didFinishCheckingText(textcheck_results);
 }
 
 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 54 matching lines @@
         results[i].replacement = last_results_[i].replacement;
       }
       completion->didFinishCheckingText(results);
       return true;
     }
   }
 
   return false;
 }
 #endif