Revert "Remove spellcheck 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 "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/common/render_messages.h"
@@ skipping 27 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>& markers() const { return markers_; }
+  bool Visit(content::RenderView* render_view) override;
+
+ private:
+  std::vector<uint32> markers_;
+  DISALLOW_COPY_AND_ASSIGN(DocumentMarkersCollector);
+};
+
+bool DocumentMarkersCollector::Visit(content::RenderView* render_view) {
+  if (!render_view || !render_view->GetWebView())
+    return true;
+  WebVector<uint32> 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::vector<std::string>& words);
   ~DocumentMarkersRemover() override {}
   bool Visit(content::RenderView* render_view) override;
 
  private:
   WebVector<WebString> words_;
   DISALLOW_COPY_AND_ASSIGN(DocumentMarkersRemover);
 };
@@ skipping 59 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_EnableAutoSpellCorrect,
                         OnEnableAutoSpellCorrect)
     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(IPC::PlatformFileForTransit bdict_file,
                         const std::set<std::string>& custom_words,
                         const std::string& language,
                         bool auto_spell_correct) {
@@ skipping 18 matching lines @@
 void SpellCheck::OnEnableAutoSpellCorrect(bool enable) {
   auto_spell_correct_turned_on_ = enable;
 }
 
 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 Init()
 // is called.
 void SpellCheck::Init(base::File file,
                       const std::set<std::string>& custom_words,
                       const std::string& language) {
   spellcheck_.Init(file.Pass(), language);
   custom_dictionary_.Init(custom_words);
 }
 
 bool SpellCheck::SpellCheckWord(
@@ skipping 196 matching lines @@
       list.push_back(WebTextCheckingResult(
           static_cast<WebTextDecorationType>(decoration),
           word_location + line_offset,
           word_length,
           spellcheck_results[i].replacement,
           spellcheck_results[i].hash));
     }
   }
   textcheck_results->assign(list);
 }