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 475 matching lines @@
     content::WebContents* tab = tab_observer.GetTab();
     content::WaitForLoadStop(tab);
 
     // Verify that it's the correct tab and profile.
     EXPECT_EQ(url, tab->GetURL());
     EXPECT_EQ(profile, Profile::FromBrowserContext(tab->GetBrowserContext()));
   }
 }
 #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) {
-    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());
-  }
-
-  ~ThumbnailResponseWatcher() override { filter_->Disown(); }
-
-  QuitReason Wait() WARN_UNUSED_RESULT {
-    message_loop_runner_->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();
-  }
-
-  void OnRequestThumbnailForContextNodeACK() {
-    quit_reason_ = THUMBNAIL_RECEIVED;
-    message_loop_runner_->Quit();
-  }
-
- private:
-  scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
-  scoped_refptr<MessageFilter> filter_;
-  content::NotificationRegistrar notification_registrar_;
-  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 42 matching lines @@
   tab_observer.Wait();
   content::WebContents* new_tab = tab_observer.GetTab();
   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();
+  // Open and close a context menu.
+  ContextMenuWaiter waiter(content::NotificationService::AllSources());
+  RightClickImage();
+  waiter.WaitForMenuOpenAndClose();
+
+  chrome::mojom::ThumbnailCapturerPtr thumbnail_capturer;
+  browser()
+      ->tab_strip_model()
+      ->GetActiveWebContents()
+      ->GetMainFrame()
+      ->GetRemoteInterfaces()
+      ->GetInterface(&thumbnail_capturer);
+
+  auto callback = [](bool* response_received, const base::Closure& quit,
+                     const std::vector<uint8_t>& thumbnail_data,
+                     const gfx::Size& original_size) {
+    *response_received = true;
+    quit.Run();
+  };
+
+  base::RunLoop run_loop;
+  bool response_received = false;
+  thumbnail_capturer->RequestThumbnailForContextNode(
+      0, gfx::Size(2048, 2048),
+      base::Bind(callback, &response_received, run_loop.QuitClosure()));
+  run_loop.Run();
 
   // The browser should receive a response from the renderer, because the
   // renderer should not crash.
-  EXPECT_EQ(ThumbnailResponseWatcher::THUMBNAIL_RECEIVED, watcher.Wait());
+  ASSERT_TRUE(response_received);
 }
 
 class LoadImageRequestInterceptor : public net::URLRequestInterceptor {
  public:
   LoadImageRequestInterceptor() : num_requests_(0),
                                   requests_to_wait_for_(-1),
                                   weak_factory_(this) {
   }
 
   ~LoadImageRequestInterceptor() override {}
@@ skipping 106 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