Split SpellCheckPanel off SpellCheckProvider

components/spellcheck/renderer/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 "components/spellcheck/renderer/spellcheck_provider.h"
 
-#include "base/command_line.h"
 #include "base/metrics/histogram_macros.h"
 #include "components/spellcheck/common/spellcheck_messages.h"
 #include "components/spellcheck/common/spellcheck_result.h"
 #include "components/spellcheck/renderer/spellcheck.h"
 #include "components/spellcheck/renderer/spellcheck_language.h"
 #include "components/spellcheck/spellcheck_build_features.h"
 #include "content/public/renderer/render_view.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
@@ skipping 14 matching lines @@
 static_assert(int(blink::WebTextDecorationTypeSpelling) ==
               int(SpellCheckResult::SPELLING), "mismatching enums");
 static_assert(int(blink::WebTextDecorationTypeGrammar) ==
               int(SpellCheckResult::GRAMMAR), "mismatching enums");
 
 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);
     render_view->GetWebView()->setTextCheckClient(this);
     EnableSpellcheck(spellcheck_->IsSpellcheckEnabled());
   }
 }
 
 SpellCheckProvider::~SpellCheckProvider() {
 }
 
 void SpellCheckProvider::RequestTextChecking(
     const base::string16& text,
@@ skipping 28 matching lines @@
 }
 
 bool SpellCheckProvider::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(SpellCheckProvider, message)
 #if !BUILDFLAG(USE_BROWSER_SPELLCHECKER)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_RespondSpellingService,
                         OnRespondSpellingService)
 #endif
 #if BUILDFLAG(USE_BROWSER_SPELLCHECKER)
-    IPC_MESSAGE_HANDLER(SpellCheckMsg_AdvanceToNextMisspelling,
-                        OnAdvanceToNextMisspelling)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_RespondTextCheck, OnRespondTextCheck)
-    IPC_MESSAGE_HANDLER(SpellCheckMsg_ToggleSpellPanel, OnToggleSpellPanel)
 #endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void SpellCheckProvider::FocusedNodeChanged(const blink::WebNode& unused) {
 #if BUILDFLAG(USE_BROWSER_SPELLCHECKER)
   WebLocalFrame* frame = render_view()->GetWebView()->focusedFrame();
   WebElement element = frame->document().isNull() ? WebElement() :
@@ skipping 39 matching lines @@
 }
 
 void SpellCheckProvider::cancelAllPendingRequests() {
   for (WebTextCheckCompletions::iterator iter(&text_check_completions_);
        !iter.IsAtEnd(); iter.Advance()) {
     iter.GetCurrentValue()->didCancelCheckingText();
   }
   text_check_completions_.Clear();
 }
 
-void SpellCheckProvider::showSpellingUI(bool show) {
-#if BUILDFLAG(USE_BROWSER_SPELLCHECKER)
-  UMA_HISTOGRAM_BOOLEAN("SpellCheck.api.showUI", show);
-  Send(new SpellCheckHostMsg_ShowSpellingPanel(routing_id(), show));
-#endif
-}
-
-bool SpellCheckProvider::isShowingSpellingUI() {
-  return spelling_panel_visible_;
-}
-
-void SpellCheckProvider::updateSpellingUIWithMisspelledWord(
-    const WebString& word) {
-#if BUILDFLAG(USE_BROWSER_SPELLCHECKER)
-  Send(new SpellCheckHostMsg_UpdateSpellingPanelWithMisspelledWord(
-      routing_id(), word.utf16()));
-#endif
-}
-
 #if !BUILDFLAG(USE_BROWSER_SPELLCHECKER)
 void SpellCheckProvider::OnRespondSpellingService(
     int identifier,
     bool succeeded,
     const base::string16& line,
     const std::vector<SpellCheckResult>& results) {
   WebTextCheckingCompletion* completion =
       text_check_completions_.Lookup(identifier);
   if (!completion)
     return;
@@ skipping 30 matching lines @@
     uint32_t code = 0;
     U16_NEXT(data, index, length, code);
     UErrorCode error = U_ZERO_ERROR;
     if (uscript_getScript(code, &error) != USCRIPT_COMMON)
       return true;
   }
   return false;
 }
 
 #if BUILDFLAG(USE_BROWSER_SPELLCHECKER)
-void SpellCheckProvider::OnAdvanceToNextMisspelling() {
-  if (!render_view()->GetWebView())
-    return;
-  render_view()->GetWebView()->focusedFrame()->executeCommand(
-      WebString::fromUTF8("AdvanceToNextMisspelling"));
-}
-
 void SpellCheckProvider::OnRespondTextCheck(
     int identifier,
     const base::string16& line,
     const std::vector<SpellCheckResult>& results) {
   // TODO(groby): Unify with SpellCheckProvider::OnRespondSpellingService
   DCHECK(spellcheck_);
   WebTextCheckingCompletion* completion =
       text_check_completions_.Lookup(identifier);
   if (!completion)
     return;
   text_check_completions_.Remove(identifier);
   blink::WebVector<blink::WebTextCheckingResult> textcheck_results;
   spellcheck_->CreateTextCheckingResults(SpellCheck::DO_NOT_MODIFY,
                                          0,
                                          line,
                                          results,
                                          &textcheck_results);
   completion->didFinishCheckingText(textcheck_results);
 
   // Cache the request and the converted results.
   last_request_ = line;
   last_results_.swap(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(
-      WebString::fromUTF8("ToggleSpellPanel"));
-}
 #endif
 
 void SpellCheckProvider::EnableSpellcheck(bool enable) {
   if (!render_view()->GetWebView())
     return;
 
   WebLocalFrame* frame = render_view()->GetWebView()->focusedFrame();
   // TODO(yabinh): The null check should be unnecessary.
   // See crbug.com/625068
   if (!frame)
@@ skipping 42 matching lines @@
     completion->didFinishCheckingText(results);
     return true;
   }
 
   return false;
 }
 
 void SpellCheckProvider::OnDestruct() {
   delete this;
 }