Mojoify the RequestThumbnailForContextNode IPC message and reply

chrome/browser/renderer_context_menu/render_view_context_menu_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 "chrome/browser/renderer_context_menu/render_view_context_menu.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
+#include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile_attributes_entry.h"
 #include "chrome/browser/profiles/profile_attributes_storage.h"
 #include "chrome/browser/profiles/profile_window.h"
 #include "chrome/browser/renderer_context_menu/render_view_context_menu_browsertest_util.h"
 #include "chrome/browser/renderer_context_menu/render_view_context_menu_test_util.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/render_messages.h"
+#include "chrome/common/thumbnail_capturer.mojom.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/search_test_utils.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_switches.h"
 #include "components/search_engines/template_url_data.h"
 #include "components/search_engines/template_url_service.h"
 #include "content/public/browser/browser_message_filter.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "net/base/load_flags.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_interceptor.h"
+#include "services/service_manager/public/cpp/interface_provider.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebContextMenuData.h"
 #include "ui/base/models/menu_model.h"
 
 using content::WebContents;
 
 namespace {
 
 class ContextMenuBrowserTest : public InProcessBrowserTest {
  public:
@@ skipping 483 matching lines @@
 #endif  // !defined(OS_CHROMEOS)
 
 class ThumbnailResponseWatcher : public content::NotificationObserver {
  public:
   enum QuitReason {
     STILL_RUNNING = 0,
     THUMBNAIL_RECEIVED,
     RENDER_PROCESS_GONE,
   };
 
-  class MessageFilter : public content::BrowserMessageFilter {
-   public:
-    explicit MessageFilter(ThumbnailResponseWatcher* owner)
-        : content::BrowserMessageFilter(ChromeMsgStart), owner_(owner) {}
-
-    bool OnMessageReceived(const IPC::Message& message) override {
-      if (message.type() ==
-          ChromeViewHostMsg_RequestThumbnailForContextNode_ACK::ID) {
-        content::BrowserThread::PostTask(
-            content::BrowserThread::UI, FROM_HERE,
-            base::Bind(&MessageFilter::OnRequestThumbnailForContextNodeACK,
-                       this));
-      }
-      return false;
-    }
-
-    void OnRequestThumbnailForContextNodeACK() {
-      if (owner_)
-        owner_->OnRequestThumbnailForContextNodeACK();
-    }
-
-    void Disown() { owner_ = nullptr; }
-
-   private:
-    ~MessageFilter() override {}
-
-    ThumbnailResponseWatcher* owner_;
-
-    DISALLOW_COPY_AND_ASSIGN(MessageFilter);
-  };
-
-  explicit ThumbnailResponseWatcher(
-      content::RenderProcessHost* render_process_host)
-      : message_loop_runner_(new content::MessageLoopRunner),
-        filter_(new MessageFilter(this)),
-        quit_reason_(STILL_RUNNING) {
+  explicit ThumbnailResponseWatcher(content::WebContents* tab)
+      : tab_(tab), quit_reason_(STILL_RUNNING) {
+    content::RenderProcessHost* render_process_host =
+        tab->GetRenderProcessHost();
     notification_registrar_.Add(
         this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
         content::Source<content::RenderProcessHost>(render_process_host));
     notification_registrar_.Add(
         this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
         content::Source<content::RenderProcessHost>(render_process_host));
-    render_process_host->AddFilter(filter_.get());
+    notification_registrar_.Add(
+        this, chrome::NOTIFICATION_RENDER_VIEW_CONTEXT_MENU_SHOWN,
+        content::NotificationService::AllSources());
   }
 
-  ~ThumbnailResponseWatcher() override { filter_->Disown(); }
-
   QuitReason Wait() WARN_UNUSED_RESULT {
-    message_loop_runner_->Run();
+    run_loop_.Run();
     DCHECK_NE(STILL_RUNNING, quit_reason_);
     return quit_reason_;
   }
 
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override {
-    DCHECK(type == content::NOTIFICATION_RENDERER_PROCESS_CLOSED ||
-           type == content::NOTIFICATION_RENDERER_PROCESS_TERMINATED);
-    quit_reason_ = RENDER_PROCESS_GONE;
-    message_loop_runner_->Quit();
+    if (type == content::NOTIFICATION_RENDERER_PROCESS_CLOSED ||
+        type == content::NOTIFICATION_RENDERER_PROCESS_TERMINATED) {
+      quit_reason_ = RENDER_PROCESS_GONE;
+      run_loop_.Quit();
+    } else {
+      DCHECK_EQ(type, chrome::NOTIFICATION_RENDER_VIEW_CONTEXT_MENU_SHOWN);
+      RequestThumbnail();
+    }
   }
 
-  void OnRequestThumbnailForContextNodeACK() {
+  void RequestThumbnail() {
+    tab_->GetMainFrame()->GetRemoteInterfaces()->GetInterface(
+        &thumbnail_capturer_);
+    thumbnail_capturer_->RequestThumbnailForContextNode(
+        0, gfx::Size(2048, 2048),
+        base::Bind(&ThumbnailResponseWatcher::OnRequestThumbnailResponse,
+                   base::Unretained(this)));
+  }
+
+  void OnRequestThumbnailResponse(const std::string& thumbnail_data,
+                                  const gfx::Size& original_size) {
     quit_reason_ = THUMBNAIL_RECEIVED;
-    message_loop_runner_->Quit();
+    run_loop_.Quit();
   }
 
  private:
-  scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
-  scoped_refptr<MessageFilter> filter_;
+  base::RunLoop run_loop_;
   content::NotificationRegistrar notification_registrar_;
+  content::WebContents* tab_;
+  chrome::mojom::ThumbnailCapturerPtr thumbnail_capturer_;
   QuitReason quit_reason_;
 
   DISALLOW_COPY_AND_ASSIGN(ThumbnailResponseWatcher);
 };
 
 // Maintains image search test state. In particular, note that |menu_observer_|
 // must live until the right-click completes asynchronously.
 class SearchByImageBrowserTest : public InProcessBrowserTest {
  protected:
   void SetupAndLoadImagePage(const std::string& image_path) {
     // The test server must start first, so that we know the port that the test
     // server is using.
     ASSERT_TRUE(embedded_test_server()->Start());
     SetupImageSearchEngine();
 
     // Go to a page with an image in it. The test server doesn't serve the image
     // with the right MIME type, so use a data URL to make a page containing it.
     GURL image_url(embedded_test_server()->GetURL(image_path));
     GURL page("data:text/html,<img src='" + image_url.spec() + "'>");
     ui_test_utils::NavigateToURL(browser(), page);
   }
 
   void AttemptImageSearch() {
-    // Right-click where the image should be.
     // |menu_observer_| will cause the search-by-image menu item to be clicked.
     menu_observer_.reset(new ContextMenuNotificationObserver(
         IDC_CONTENT_CONTEXT_SEARCHWEBFORIMAGE));
+    RightClickImage();
+  }
+
+  // Right-click where the image should be.
+  void RightClickImage() {
     content::WebContents* tab =
         browser()->tab_strip_model()->GetActiveWebContents();
     content::SimulateMouseClickAt(tab, 0, blink::WebMouseEvent::Button::Right,
                                   gfx::Point(15, 15));
   }
 
   GURL GetImageSearchURL() {
     static const char kImageSearchURL[] = "/imagesearch";
     return embedded_test_server()->GetURL(kImageSearchURL);
   }
@@ skipping 44 matching lines @@
   content::WaitForLoadStop(new_tab);
   EXPECT_EQ(GetImageSearchURL(), new_tab->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(SearchByImageBrowserTest, ImageSearchWithCorruptImage) {
   static const char kCorruptImage[] = "/image_search/corrupt.png";
   SetupAndLoadImagePage(kCorruptImage);
 
   content::WebContents* tab =
       browser()->tab_strip_model()->GetActiveWebContents();
-  ThumbnailResponseWatcher watcher(tab->GetRenderProcessHost());
-  AttemptImageSearch();
+  // Create the watcher first because it observes the context menu creation.
+  ThumbnailResponseWatcher watcher(tab);
+  RightClickImage();
 
   // The browser should receive a response from the renderer, because the
   // renderer should not crash.
   EXPECT_EQ(ThumbnailResponseWatcher::THUMBNAIL_RECEIVED, watcher.Wait());
 }
 
 class LoadImageRequestInterceptor : public net::URLRequestInterceptor {
  public:
   LoadImageRequestInterceptor() : num_requests_(0),
                                   requests_to_wait_for_(-1),
@@ skipping 110 matching lines @@
 IN_PROC_BROWSER_TEST_F(LoadImageBrowserTest, LoadImage) {
   static const char kValidImage[] = "/load_image/image.png";
   SetupAndLoadImagePage(kValidImage);
   AddLoadImageInterceptor(kValidImage);
   AttemptLoadImage();
   interceptor_->WaitForRequests(1);
   EXPECT_EQ(1, interceptor_->num_requests());
 }
 
 }  // namespace