Migrating tests to use EmbeddedTestServer (/chrome/browser misc)

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"
@@ skipping 23 matching lines @@
 #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/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 "third_party/WebKit/public/web/WebContextMenuData.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "components/signin/core/account_id/account_id.h"
 #include "components/user_manager/user_manager.h"
@@ skipping 179 matching lines @@
 
   // Verify that it's the correct tab.
   EXPECT_EQ(GURL("about:blank"), tab->GetURL());
 }
 
 // Verify that "Open Link in New Tab" doesn't send URL fragment as referrer.
 IN_PROC_BROWSER_TEST_F(ContextMenuBrowserTest, OpenInNewTabReferrer) {
   ui_test_utils::WindowedTabAddedNotificationObserver tab_observer(
       content::NotificationService::AllSources());
 
-  ASSERT_TRUE(test_server()->Start());
-  GURL echoheader(test_server()->GetURL("echoheader?Referer"));
+  ASSERT_TRUE(embedded_test_server()->Start());
+  GURL echoheader(embedded_test_server()->GetURL("/echoheader?Referer"));
 
   // Go to a |page| with a link to echoheader URL.
   GURL page("data:text/html,<a href='" + echoheader.spec() + "'>link</a>");
   ui_test_utils::NavigateToURL(browser(), page);
 
   // Set up referrer URL with fragment.
   const GURL kReferrerWithFragment("http://foo.com/test#fragment");
   const std::string kCorrectReferrer("http://foo.com/test");
 
   // Set up menu with link URL.
@@ skipping 29 matching lines @@
       "window.domAutomationController.send(window.document.referrer);",
       &page_referrer));
   ASSERT_EQ(kCorrectReferrer, page_referrer);
 }
 
 // Verify that "Open Link in Incognito Window " doesn't send referrer URL.
 IN_PROC_BROWSER_TEST_F(ContextMenuBrowserTest, OpenIncognitoNoneReferrer) {
   ui_test_utils::WindowedTabAddedNotificationObserver tab_observer(
       content::NotificationService::AllSources());
 
-  ASSERT_TRUE(test_server()->Start());
-  GURL echoheader(test_server()->GetURL("echoheader?Referer"));
+  ASSERT_TRUE(embedded_test_server()->Start());
+  GURL echoheader(embedded_test_server()->GetURL("/echoheader?Referer"));
 
   // Go to a |page| with a link to echoheader URL.
   GURL page("data:text/html,<a href='" + echoheader.spec() + "'>link</a>");
   ui_test_utils::NavigateToURL(browser(), page);
 
   // Set up referrer URL with fragment.
   const GURL kReferrerWithFragment("http://foo.com/test#fragment");
   const std::string kNoneReferrer("None");
   const std::string kEmptyReferrer("");
 
@@ skipping 289 matching lines @@
   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(test_server()->Start());
+    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(test_server()->GetURL(image_path));
+    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));
     content::WebContents* tab =
         browser()->tab_strip_model()->GetActiveWebContents();
     content::SimulateMouseClickAt(tab, 0, blink::WebMouseEvent::ButtonRight,
                                   gfx::Point(15, 15));
   }
 
   GURL GetImageSearchURL() {
-    static const char kImageSearchURL[] = "imagesearch";
-    return test_server()->GetURL(kImageSearchURL);
+    static const char kImageSearchURL[] = "/imagesearch";
+    return embedded_test_server()->GetURL(kImageSearchURL);
   }
 
  private:
   void SetupImageSearchEngine() {
     static const char kShortName[] = "test";
-    static const char kSearchURL[] = "search?q={searchTerms}";
+    static const char kSearchURL[] = "/search?q={searchTerms}";
     static const char kImageSearchPostParams[] =
         "thumb={google:imageThumbnail}";
 
     TemplateURLService* model =
         TemplateURLServiceFactory::GetForProfile(browser()->profile());
     ASSERT_TRUE(model);
     search_test_utils::WaitForTemplateURLServiceToLoad(model);
     ASSERT_TRUE(model->loaded());
 
     TemplateURLData data;
     data.SetShortName(base::ASCIIToUTF16(kShortName));
     data.SetKeyword(data.short_name());
-    data.SetURL(test_server()->GetURL(kSearchURL).spec());
+    data.SetURL(embedded_test_server()->GetURL(kSearchURL).spec());
     data.image_url = GetImageSearchURL().spec();
     data.image_url_post_params = kImageSearchPostParams;
 
     // The model takes ownership of |template_url|.
     TemplateURL* template_url = new TemplateURL(data);
     ASSERT_TRUE(model->Add(template_url));
     model->SetUserSelectedDefaultSearchProvider(template_url);
   }
 
   void TearDownInProcessBrowserTestFixture() override {
     menu_observer_.reset();
   }
 
   scoped_ptr<ContextMenuNotificationObserver> menu_observer_;
 };
 
 IN_PROC_BROWSER_TEST_F(SearchByImageBrowserTest, ImageSearchWithValidImage) {
-  static const char kValidImage[] = "files/image_search/valid.png";
+  static const char kValidImage[] = "/image_search/valid.png";
   SetupAndLoadImagePage(kValidImage);
 
   ui_test_utils::WindowedTabAddedNotificationObserver tab_observer(
       content::NotificationService::AllSources());
   AttemptImageSearch();
 
   // The browser should open a new tab for an image search.
   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[] = "files/image_search/corrupt.png";
+  static const char kCorruptImage[] = "/image_search/corrupt.png";
   SetupAndLoadImagePage(kCorruptImage);
 
   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());
@@ skipping 62 matching lines @@
   // 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) {
+    ASSERT_TRUE(embedded_test_server()->Start());
     // 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 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 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()),
+                   GURL(embedded_test_server()->GetURL(image_path).spec()),

[mmenke, 2015/11/17 21:54:12]

Erm...how did this test work before, without setting up the test server?

[svaldez, 2015/11/17 22:18:54]

I believe because this test doesn't actually check whether the image load
completes successfully.

                    base::Passed(&owned_interceptor)));
   }
 
   void AttemptLoadImage() {
     // 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_LOAD_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";
+  static const char kValidImage[] = "/load_image/image.png";
   SetupAndLoadImagePage(kValidImage);
   AddLoadImageInterceptor(kValidImage);
   AttemptLoadImage();
   interceptor_->WaitForRequests(1);
   EXPECT_EQ(1, interceptor_->num_requests());
 }
 
 }  // namespace