"Load image" context menu item to reload a LoFi image.

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 <string>
 
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/renderer_context_menu/render_view_context_menu.h"
 #include "chrome/browser/renderer_context_menu/render_view_context_menu_browsertest_util.h"
@@ skipping 10 matching lines @@
 #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_process_host.h"
 #include "content/public/browser/render_view_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/url_request/url_request.h"
+#include "net/url_request/url_request_filter.h"
+#include "net/url_request/url_request_interceptor.h"
 #include "third_party/WebKit/public/web/WebContextMenuData.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 
 using content::WebContents;
 
 namespace {
 
 class ContextMenuBrowserTest : public InProcessBrowserTest {
  public:
   ContextMenuBrowserTest() {}
 
-  TestRenderViewContextMenu* CreateContextMenu(
+  content::ContextMenuParams CreateContextMenuParams(
       const GURL& unfiltered_url,
       const GURL& url,
       blink::WebContextMenuData::MediaType media_type) {
     content::ContextMenuParams params;
     params.media_type = media_type;
     params.unfiltered_link_url = unfiltered_url;
     params.link_url = url;
     params.src_url = url;
     WebContents* web_contents =
         browser()->tab_strip_model()->GetActiveWebContents();
     params.page_url = web_contents->GetController().GetActiveEntry()->GetURL();
 #if defined(OS_MACOSX)
     params.writing_direction_default = 0;
     params.writing_direction_left_to_right = 0;
     params.writing_direction_right_to_left = 0;
 #endif  // OS_MACOSX
+    return params;
+  }
+
+  TestRenderViewContextMenu* CreateContextMenu(
+      content::ContextMenuParams params) {
     TestRenderViewContextMenu* menu = new TestRenderViewContextMenu(
         browser()->tab_strip_model()->GetActiveWebContents()->GetMainFrame(),
         params);
     menu->Init();
     return menu;
   }
 
   TestRenderViewContextMenu* CreateContextMenuMediaTypeNone(
       const GURL& unfiltered_url,
       const GURL& url) {
-    return CreateContextMenu(unfiltered_url, url,
-                             blink::WebContextMenuData::MediaTypeNone);
+    return CreateContextMenu(CreateContextMenuParams(
+        unfiltered_url, url, blink::WebContextMenuData::MediaTypeNone));
   }
 };
 
 IN_PROC_BROWSER_TEST_F(ContextMenuBrowserTest,
                        OpenEntryPresentForNormalURLs) {
   scoped_ptr<TestRenderViewContextMenu> menu(CreateContextMenuMediaTypeNone(
       GURL("http://www.google.com/"), GURL("http://www.google.com/")));
 
   ASSERT_TRUE(menu->IsItemPresent(IDC_CONTENT_CONTEXT_OPENLINKNEWTAB));
   ASSERT_TRUE(menu->IsItemPresent(IDC_CONTENT_CONTEXT_OPENLINKNEWWINDOW));
@@ skipping 214 matching lines @@
   TestRenderViewContextMenu menu(tab->GetMainFrame(), context_menu_params);
   menu.Init();
 
   // The item shouldn't be enabled in the menu.
   EXPECT_FALSE(menu.IsCommandIdEnabled(IDC_CONTENT_CONTEXT_VIEWPAGEINFO));
 
   // Ensure that viewing page info doesn't crash even if you can get to it.
   menu.ExecuteCommand(IDC_CONTENT_CONTEXT_VIEWPAGEINFO, 0);
 }
 
+IN_PROC_BROWSER_TEST_F(ContextMenuBrowserTest, DataSaverLoadImage) {
+  content::ContextMenuParams params = CreateContextMenuParams(
+      GURL(), GURL("http://url.com/image.png"),
+      blink::WebContextMenuData::MediaTypeImage);
+  params.image_was_fetched_lo_fi = true;
+
+  scoped_ptr<TestRenderViewContextMenu> menu(CreateContextMenu(params));
+
+  ASSERT_TRUE(menu->IsItemPresent(IDC_CONTENT_CONTEXT_RELOAD_ORIGINAL_IMAGE));
+}
+
 IN_PROC_BROWSER_TEST_F(ContextMenuBrowserTest, DataSaverOpenOrigImageInNewTab) {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   command_line->AppendSwitch(
       data_reduction_proxy::switches::kEnableDataReductionProxy);
 
   scoped_ptr<TestRenderViewContextMenu> menu(
-      CreateContextMenu(GURL(), GURL("http://url.com/image.png"),
-                        blink::WebContextMenuData::MediaTypeImage));
+      CreateContextMenu(CreateContextMenuParams(
+          GURL(), GURL("http://url.com/image.png"),
+          blink::WebContextMenuData::MediaTypeImage)));
 
   ASSERT_FALSE(menu->IsItemPresent(IDC_CONTENT_CONTEXT_OPENIMAGENEWTAB));
   ASSERT_TRUE(menu->IsItemPresent(
       IDC_CONTENT_CONTEXT_OPEN_ORIGINAL_IMAGE_NEW_TAB));
 }
 
 IN_PROC_BROWSER_TEST_F(ContextMenuBrowserTest,
                        DataSaverHttpsOpenImageInNewTab) {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   command_line->AppendSwitch(
       data_reduction_proxy::switches::kEnableDataReductionProxy);
 
   scoped_ptr<TestRenderViewContextMenu> menu(
-      CreateContextMenu(GURL(), GURL("https://url.com/image.png"),
-                        blink::WebContextMenuData::MediaTypeImage));
+      CreateContextMenu(CreateContextMenuParams(
+          GURL(), GURL("https://url.com/image.png"),
+          blink::WebContextMenuData::MediaTypeImage)));
 
   ASSERT_FALSE(
       menu->IsItemPresent(IDC_CONTENT_CONTEXT_OPEN_ORIGINAL_IMAGE_NEW_TAB));
   ASSERT_TRUE(menu->IsItemPresent(IDC_CONTENT_CONTEXT_OPENIMAGENEWTAB));
 }
 
 IN_PROC_BROWSER_TEST_F(ContextMenuBrowserTest, OpenImageInNewTab) {
   scoped_ptr<TestRenderViewContextMenu> menu(
-      CreateContextMenu(GURL(), GURL("http://url.com/image.png"),
-                        blink::WebContextMenuData::MediaTypeImage));
+      CreateContextMenu(CreateContextMenuParams(
+          GURL(), GURL("http://url.com/image.png"),
+          blink::WebContextMenuData::MediaTypeImage)));
   ASSERT_FALSE(
       menu->IsItemPresent(IDC_CONTENT_CONTEXT_OPEN_ORIGINAL_IMAGE_NEW_TAB));
   ASSERT_TRUE(menu->IsItemPresent(IDC_CONTENT_CONTEXT_OPENIMAGENEWTAB));
 }
 
 class ThumbnailResponseWatcher : public content::NotificationObserver {
  public:
   enum QuitReason {
     STILL_RUNNING = 0,
     THUMBNAIL_RECEIVED,
@@ skipping 164 matching lines @@
   content::WebContents* tab =
       browser()->tab_strip_model()->GetActiveWebContents();
   ThumbnailResponseWatcher watcher(tab->GetRenderProcessHost());
   AttemptImageSearch();
 
   // 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),
+                                  weak_factory_(this) {
+  }
+
+  ~LoadImageRequestInterceptor() override {}
+
+  // net::URLRequestInterceptor implementation
+  net::URLRequestJob* MaybeInterceptRequest(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const override {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+    EXPECT_TRUE(request->load_flags() & net::LOAD_BYPASS_CACHE);
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        base::Bind(&LoadImageRequestInterceptor::RequestCreated,
+                   weak_factory_.GetWeakPtr()));
+    return nullptr;
+  }
+
+  void WaitForRequests(int requests_to_wait_for) {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+    DCHECK_EQ(-1, requests_to_wait_for_);
+    DCHECK(!run_loop_);
+
+    if (num_requests_ >= requests_to_wait_for)
+      return;
+
+    requests_to_wait_for_ = requests_to_wait_for;
+    run_loop_.reset(new base::RunLoop());
+    run_loop_->Run();
+    run_loop_.reset();
+    requests_to_wait_for_ = -1;
+    EXPECT_EQ(num_requests_, requests_to_wait_for);
+  }
+
+  // It is up to the caller to wait until all relevant requests has been
+  // created, either through calling WaitForRequests or some other manner,
+  // before calling this method.
+  int num_requests() const {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+    return num_requests_;
+  }
+
+ private:
+  void RequestCreated() {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+    num_requests_++;
+    if (num_requests_ == requests_to_wait_for_)
+      run_loop_->Quit();
+  }
+
+  // These are only used on the UI thread.
+  int num_requests_;
+  int requests_to_wait_for_;
+  scoped_ptr<base::RunLoop> run_loop_;
+
+  // This prevents any risk of flake if any test doesn't wait for a request
+  // it sent.  Mutable so it can be accessed from a const function.
+  mutable base::WeakPtrFactory<LoadImageRequestInterceptor> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(LoadImageRequestInterceptor);
+};
+
+class LoadImageBrowserTest : public InProcessBrowserTest {
+ protected:
+  void SetupAndLoadImagePage(const std::string& image_path) {
+    // 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(test_server()->GetURL(image_path));
+    GURL page("data:text/html,<img src='" + image_url.spec() + "'>");
+    ui_test_utils::NavigateToURL(browser(), page);
+  }
+
+  void AddLoadImageInterceptor(const std::string& image_path) {
+    interceptor_ = new LoadImageRequestInterceptor();
+    scoped_ptr<net::URLRequestInterceptor> owned_interceptor(interceptor_);
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&LoadImageBrowserTest::AddInterceptorForURL,
+                   base::Unretained(this),
+                   GURL(test_server()->GetURL(image_path).spec()),
+                   base::Passed(&owned_interceptor)));
+  }
+
+  void AttemptImageLoad() {
+    // Right-click where the image should be.
+    // |menu_observer_| will cause the load-image menu item to be clicked.
+    menu_observer_.reset(new ContextMenuNotificationObserver(
+        IDC_CONTENT_CONTEXT_RELOAD_ORIGINAL_IMAGE));
+    content::WebContents* tab =
+        browser()->tab_strip_model()->GetActiveWebContents();
+    content::SimulateMouseClickAt(tab, 0, blink::WebMouseEvent::ButtonRight,
+                                  gfx::Point(15, 15));
+  }
+
+  void AddInterceptorForURL(
+      const GURL& url, scoped_ptr<net::URLRequestInterceptor> handler) {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+    net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
+        url, handler.Pass());
+  }
+
+  LoadImageRequestInterceptor* interceptor_;
+
+ private:
+  scoped_ptr<ContextMenuNotificationObserver> menu_observer_;
+};
+
+IN_PROC_BROWSER_TEST_F(LoadImageBrowserTest, LoadImage) {
+  static const char kValidImage[] = "files/load_image/image.png";
+  SetupAndLoadImagePage(kValidImage);
+  AddLoadImageInterceptor(kValidImage);
+  AttemptImageLoad();
+  interceptor_->WaitForRequests(1);
+  EXPECT_EQ(1, interceptor_->num_requests());
+}
+
 }  // namespace