Remove spellchecker feedback.

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 <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
@@ skipping 44 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(UpdateSpellcheckEnabled);
 };
 
 bool UpdateSpellcheckEnabled::Visit(content::RenderView* render_view) {
   SpellCheckProvider* provider = SpellCheckProvider::Get(render_view);
   DCHECK(provider);
   provider->EnableSpellcheck(enabled_);
   return true;
 }
 
-class DocumentMarkersCollector : public content::RenderViewVisitor {
- public:
-  DocumentMarkersCollector() {}
-  ~DocumentMarkersCollector() override {}
-  const std::vector<uint32_t>& markers() const { return markers_; }
-  bool Visit(content::RenderView* render_view) override;
-
- private:
-  std::vector<uint32_t> markers_;
-  DISALLOW_COPY_AND_ASSIGN(DocumentMarkersCollector);
-};
-
-bool DocumentMarkersCollector::Visit(content::RenderView* render_view) {
-  if (!render_view || !render_view->GetWebView())
-    return true;
-  WebVector<uint32_t> markers;
-  render_view->GetWebView()->spellingMarkers(&markers);
-  for (size_t i = 0; i < markers.size(); ++i)
-    markers_.push_back(markers[i]);
-  // Visit all render views.
-  return true;
-}
-
 class DocumentMarkersRemover : public content::RenderViewVisitor {
  public:
   explicit DocumentMarkersRemover(const std::set<std::string>& words);
   ~DocumentMarkersRemover() override {}
   bool Visit(content::RenderView* render_view) override;
 
  private:
   WebVector<WebString> words_;
   DISALLOW_COPY_AND_ASSIGN(DocumentMarkersRemover);
 };
@@ skipping 106 matching lines @@
   }
 }
 
 bool SpellCheck::OnControlMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(SpellCheck, message)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_Init, OnInit)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_CustomDictionaryChanged,
                         OnCustomDictionaryChanged)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_EnableSpellCheck, OnEnableSpellCheck)
-    IPC_MESSAGE_HANDLER(SpellCheckMsg_RequestDocumentMarkers,
-                        OnRequestDocumentMarkers)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 void SpellCheck::OnInit(
     const std::vector<SpellCheckBDictLanguage>& bdict_languages,
     const std::set<std::string>& custom_words) {
   languages_.clear();
@@ skipping 18 matching lines @@
   DocumentMarkersRemover markersRemover(words_added);
   content::RenderView::ForEach(&markersRemover);
 }
 
 void SpellCheck::OnEnableSpellCheck(bool enable) {
   spellcheck_enabled_ = enable;
   UpdateSpellcheckEnabled updater(enable);
   content::RenderView::ForEach(&updater);
 }
 
-void SpellCheck::OnRequestDocumentMarkers() {
-  DocumentMarkersCollector collector;
-  content::RenderView::ForEach(&collector);
-  content::RenderThread::Get()->Send(
-      new SpellCheckHostMsg_RespondDocumentMarkers(collector.markers()));
-}
-
 // TODO(groby): Make sure we always have a spelling engine, even before
 // AddSpellcheckLanguage() is called.
 void SpellCheck::AddSpellcheckLanguage(base::File file,
                                        const std::string& language) {
   languages_.push_back(new SpellcheckLanguage());
   languages_.back()->Init(std::move(file), language);
 }
 
 bool SpellCheck::SpellCheckWord(
     const base::char16* text_begin,
@@ skipping 252 matching lines @@
                          misspelled_word.length(), kNoTag,
                          &unused_misspelling_start, &unused_misspelling_length,
                          nullptr)) {
         decoration = SpellCheckResult::GRAMMAR;
       }
     }
 
     results.push_back(WebTextCheckingResult(
         static_cast<WebTextDecorationType>(decoration),
         line_offset + spellcheck_result.location, spellcheck_result.length,
-        replacement, spellcheck_result.hash));
+        replacement));
   }
 
   textcheck_results->assign(results);
 }
 
 bool SpellCheck::IsSpellcheckEnabled() {
 #if defined(OS_ANDROID)
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           spellcheck::switches::kEnableAndroidSpellChecker)) {
     return false;
   }
 #endif
   return spellcheck_enabled_;
 }