Convert Spellcheck host MessageFilter IPC to mojo

chrome/browser/chrome_site_per_process_browsertest.cc

 // Copyright 2014 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 "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 20 matching lines @@
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/api/extensions_api_client.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "ui/display/display_switches.h"
 #include "url/gurl.h"
 
 #if BUILDFLAG(ENABLE_SPELLCHECK)
+#include "components/spellcheck/common/spellcheck.mojom.h"
 #include "components/spellcheck/common/spellcheck_messages.h"
+#include "services/service_manager/public/cpp/bind_source_info.h"
 #endif
 
 class ChromeSitePerProcessTest : public InProcessBrowserTest {
  public:
   ChromeSitePerProcessTest() {}
   ~ChromeSitePerProcessTest() override {}
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     content::IsolateAllSitesForTesting(command_line);
   }
@@ skipping 459 matching lines @@
       "window.domAutomationController.send(!!w);\n",
       &popup_handle_is_valid));
   popup_observer.Wait();
 
   // The popup shouldn't be blocked.
   EXPECT_TRUE(popup_handle_is_valid);
   ASSERT_EQ(2, browser()->tab_strip_model()->count());
 }
 
 #if BUILDFLAG(ENABLE_SPELLCHECK)
-// Class to sniff incoming IPCs for spell check messages.
-class TestSpellCheckMessageFilter : public content::BrowserMessageFilter {
+// Class to sniff incoming spellcheck IPC / Mojo SpellCheckHost messages.
+class TestSpellCheckMessageFilter : public content::BrowserMessageFilter,
+                                    spellcheck::mojom::SpellCheckHost {
  public:
   explicit TestSpellCheckMessageFilter(content::RenderProcessHost* process_host)
       : content::BrowserMessageFilter(SpellCheckMsgStart),
         process_host_(process_host),
         text_received_(false),
-        message_loop_runner_(base::MakeShared<content::MessageLoopRunner>()) {}
+        message_loop_runner_(base::MakeShared<content::MessageLoopRunner>()),
+        binding_(this) {}
 
-  bool OnMessageReceived(const IPC::Message& message) override {
-    IPC_BEGIN_MESSAGE_MAP(TestSpellCheckMessageFilter, message)
-#if !BUILDFLAG(USE_BROWSER_SPELLCHECKER)
-      IPC_MESSAGE_HANDLER(SpellCheckHostMsg_CallSpellingService, HandleMessage)
-#else
-      IPC_MESSAGE_HANDLER(SpellCheckHostMsg_RequestTextCheck, HandleMessage)
-#endif
-    IPC_END_MESSAGE_MAP()
-    return false;
-  }
+  content::RenderProcessHost* process() const { return process_host_; }
 
-  base::string16 last_text() const { return last_text_; }
+  const base::string16& text() const { return text_; }
 
   void Wait() {
     if (!text_received_)
       message_loop_runner_->Run();
   }
 
-  content::RenderProcessHost* process() const { return process_host_; }
+  bool OnMessageReceived(const IPC::Message& message) override {
+#if BUILDFLAG(USE_BROWSER_SPELLCHECKER)
+    IPC_BEGIN_MESSAGE_MAP(TestSpellCheckMessageFilter, message)
+      // TODO(crbug.com/714480): convert the RequestTextCheck IPC to mojo.
+      IPC_MESSAGE_HANDLER(SpellCheckHostMsg_RequestTextCheck, HandleMessage)
+    IPC_END_MESSAGE_MAP()
+#endif
+    return false;
+  }
+
+#if !BUILDFLAG(USE_BROWSER_SPELLCHECKER)
+  void ShellCheckHostRequest(const service_manager::BindSourceInfo& source_info,
+                             spellcheck::mojom::SpellCheckHostRequest request) {
+    EXPECT_FALSE(binding_.is_bound());
+    binding_.Bind(std::move(request));
+  }
+#endif
 
  private:
   ~TestSpellCheckMessageFilter() override {}
 
+#if BUILDFLAG(USE_BROWSER_SPELLCHECKER)
   void HandleMessage(int, int, const base::string16& text) {
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE,
-        base::BindOnce(&TestSpellCheckMessageFilter::HandleMessageOnUI, this,
-                       text));
+        base::BindOnce(&TestSpellCheckMessageFilter::HandleMessageOnUIThread,
+                       this, text));
+  }
+#endif
+
+  void HandleMessageOnUIThread(const base::string16& text) {
+    if (!text_received_) {
+      text_received_ = true;
+      text_ = text;
+      message_loop_runner_->Quit();
+    } else {
+      NOTREACHED();
+    }
   }
 
-  void HandleMessageOnUI(const base::string16& text) {
-    last_text_ = text;
-    if (!text_received_) {
-      text_received_ = true;
-      message_loop_runner_->Quit();
-    }
+  // spellcheck::mojom::SpellCheckHost:
+  void RequestDictionary() override {}
+
+  void NotifyChecked(const base::string16& word, bool misspelled) override {}
+
+  void CallSpellingService(
+      const base::string16& text,
+      const CallSpellingServiceCallback& callback) override {
+#if !BUILDFLAG(USE_BROWSER_SPELLCHECKER)
+    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+    callback.Run(true, std::vector<SpellCheckResult>());
+    binding_.Close();
+    HandleMessageOnUIThread(text);
+#endif
   }
 
   content::RenderProcessHost* process_host_;
   bool text_received_;
-  base::string16 last_text_;
+  base::string16 text_;
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
+  mojo::Binding<spellcheck::mojom::SpellCheckHost> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSpellCheckMessageFilter);
 };
 
 class TestBrowserClientForSpellCheck : public ChromeContentBrowserClient {
  public:
   TestBrowserClientForSpellCheck() {}
   ~TestBrowserClientForSpellCheck() override {}
 
   // ContentBrowserClient overrides.
   void RenderProcessWillLaunch(
       content::RenderProcessHost* process_host) override {
     filters_.push_back(new TestSpellCheckMessageFilter(process_host));
     process_host->AddFilter(filters_.back().get());
     ChromeContentBrowserClient::RenderProcessWillLaunch(process_host);
   }
 
+#if !BUILDFLAG(USE_BROWSER_SPELLCHECKER)
+  void ExposeInterfacesToRenderer(
+      service_manager::BinderRegistry* registry,
+      content::AssociatedInterfaceRegistry* associated_registry,
+      content::RenderProcessHost* render_process_host) override {
+    // Expose the default interfaces.
+    ChromeContentBrowserClient::ExposeInterfacesToRenderer(
+        registry, associated_registry, render_process_host);
+
+    scoped_refptr<TestSpellCheckMessageFilter> filter =
+        GetSpellCheckMessageFilterForProcess(render_process_host);
+    CHECK(filter);
+
+    // Override the default SpellCheckHost interface.
+    auto ui_task_runner = content::BrowserThread::GetTaskRunnerForThread(
+        content::BrowserThread::UI);
+    registry->AddInterface(
+        base::Bind(&TestSpellCheckMessageFilter::ShellCheckHostRequest, filter),
+        ui_task_runner);
+  }
+#endif  // !BUILDFLAG(USE_BROWSER_SPELLCHECKER)
+
   // Retrieves the registered filter for the given RenderProcessHost. It will
   // return nullptr if the RenderProcessHost was initialized while a different
   // instance of ContentBrowserClient was in action.
   scoped_refptr<TestSpellCheckMessageFilter>
   GetSpellCheckMessageFilterForProcess(
       content::RenderProcessHost* process_host) const {
     for (auto filter : filters_) {
       if (filter->process() == process_host)
         return filter;
     }
@@ skipping 12 matching lines @@
   TestBrowserClientForSpellCheck browser_client;
   content::ContentBrowserClient* old_browser_client =
       content::SetBrowserClientForTesting(&browser_client);
 
   GURL main_url(embedded_test_server()->GetURL(
       "a.com", "/page_with_contenteditable_in_cross_site_subframe.html"));
   ui_test_utils::NavigateToURL(browser(), main_url);
 
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
-  content::RenderFrameHost* subframe =
+  content::RenderFrameHost* cross_site_subframe =
       ChildFrameAt(web_contents->GetMainFrame(), 0);
+
   scoped_refptr<TestSpellCheckMessageFilter> filter =
       browser_client.GetSpellCheckMessageFilterForProcess(
-          subframe->GetProcess());
+          cross_site_subframe->GetProcess());
   filter->Wait();
 
-  EXPECT_EQ(base::ASCIIToUTF16("zz."), filter->last_text());
+  EXPECT_EQ(base::ASCIIToUTF16("zz."), filter->text());
 
   content::SetBrowserClientForTesting(old_browser_client);
 }
 #endif  // BUILDFLAG(ENABLE_SPELLCHECK)