Remove spellchecker feedback.

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 "base/metrics/histogram.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/renderer/spellchecker/spellcheck.h"
 #include "chrome/renderer/spellchecker/spellcheck_language.h"
-#include "components/spellcheck/common/spellcheck_marker.h"
 #include "components/spellcheck/common/spellcheck_messages.h"
 #include "components/spellcheck/common/spellcheck_result.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"
 #include "third_party/WebKit/public/web/WebLocalFrame.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 blink::WebElement;
 using blink::WebLocalFrame;
 using blink::WebString;
 using blink::WebTextCheckingCompletion;
 using blink::WebTextCheckingResult;
 using blink::WebTextDecorationType;
 using blink::WebVector;
 
 static_assert(int(blink::WebTextDecorationTypeSpelling) ==
               int(SpellCheckResult::SPELLING), "mismatching enums");
 static_assert(int(blink::WebTextDecorationTypeGrammar) ==
               int(SpellCheckResult::GRAMMAR), "mismatching enums");
-static_assert(int(blink::WebTextDecorationTypeInvisibleSpellcheck) ==
-              int(SpellCheckResult::INVISIBLE), "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);
     EnableSpellcheck(spellcheck_->IsSpellcheckEnabled());
   }
 }
 
 SpellCheckProvider::~SpellCheckProvider() {
 }
 
 void SpellCheckProvider::RequestTextChecking(
     const base::string16& text,
-    WebTextCheckingCompletion* completion,
-    const std::vector<SpellCheckMarker>& markers) {
+    WebTextCheckingCompletion* completion) {
   // Ignore invalid requests.
   if (text.empty() || !HasWordCharacters(text, 0)) {
     completion->didCancelCheckingText();
     return;
   }
 
   // Try to satisfy check from cache.
   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(blink::WebVector<blink::WebTextCheckingResult>());
 
 #if defined(USE_BROWSER_SPELLCHECKER)
   // 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
   // available.
   Send(new SpellCheckHostMsg_RequestTextCheck(
       routing_id(),
       text_check_completions_.Add(completion),
-      text,
-      markers));
+      text));
 #else
   Send(new SpellCheckHostMsg_CallSpellingService(
       routing_id(),
       text_check_completions_.Add(completion),
-      base::string16(text),
-      markers));
+      base::string16(text)));
 #endif  // !USE_BROWSER_SPELLCHECKER
 }
 
 bool SpellCheckProvider::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(SpellCheckProvider, message)
 #if !defined(USE_BROWSER_SPELLCHECKER)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_RespondSpellingService,
                         OnRespondSpellingService)
 #endif
@@ skipping 54 matching lines @@
 
   // TODO(groby): As far as I can tell, this method is never invoked.
   // UMA results seem to support that. Investigate, clean up if true.
   NOTREACHED();
   spellcheck_->SpellCheckParagraph(text, results);
   UMA_HISTOGRAM_COUNTS("SpellCheck.api.paragraph", text.length());
 }
 
 void SpellCheckProvider::requestCheckingOfText(
     const WebString& text,
-    const WebVector<uint32_t>& markers,
-    const WebVector<unsigned>& marker_offsets,
     WebTextCheckingCompletion* completion) {
-  std::vector<SpellCheckMarker> spellcheck_markers;
-  for (size_t i = 0; i < markers.size(); ++i) {
-    spellcheck_markers.push_back(
-        SpellCheckMarker(markers[i], marker_offsets[i]));
-  }
-  RequestTextChecking(text, completion, spellcheck_markers);
+  RequestTextChecking(text, completion);
   UMA_HISTOGRAM_COUNTS("SpellCheck.api.async", text.length());
 }
 
 void SpellCheckProvider::showSpellingUI(bool show) {
 #if defined(USE_BROWSER_SPELLCHECKER)
   UMA_HISTOGRAM_BOOLEAN("SpellCheck.api.showUI", show);
   Send(new SpellCheckHostMsg_ShowSpellingPanel(routing_id(), show));
 #endif
 }
 
@@ skipping 166 matching lines @@
       return true;
     }
   }
 
   return false;
 }
 
 void SpellCheckProvider::OnDestruct() {
   delete this;
 }