Add back the code to PrerenderManager::PendingSwap to handle RenderViewCreated being called for a...

chrome/browser/prerender/prerender_browsertest.cc

 // Copyright (c) 2012 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 <deque>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 687 matching lines @@
 // |file| afterwards.
 void CreateHangingFirstRequestProtocolHandlerOnIO(const GURL& url,
                                                   const base::FilePath& file) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   scoped_ptr<net::URLRequestJobFactory::ProtocolHandler> never_respond_handler(
       new HangingFirstRequestProtocolHandler(file));
   net::URLRequestFilter::GetInstance()->AddUrlProtocolHandler(
       url, never_respond_handler.Pass());
 }
 
+// Wrapper over URLRequestMockHTTPJob that exposes extra callbacks.
+class MockHTTPJob : public content::URLRequestMockHTTPJob {
+ public:
+  MockHTTPJob(net::URLRequest* request,
+              net::NetworkDelegate* delegate,
+              const base::FilePath& file)
+      : content::URLRequestMockHTTPJob(request, delegate, file) {
+  }
+
+  void set_start_callback(const base::Closure& start_callback) {
+    start_callback_ = start_callback;
+  }
+
+  virtual void Start() OVERRIDE {
+    if (!start_callback_.is_null())
+      start_callback_.Run();
+    content::URLRequestMockHTTPJob::Start();
+  }
+
+ private:
+  base::Closure start_callback_;
+};
+
+// Dummy counter class to live on the UI thread for counting requests.
+class RequestCounter : public base::SupportsWeakPtr<RequestCounter> {
+ public:
+  RequestCounter() : count_(0) {}
+  int count() const { return count_; }
+  void RequestStarted() { count_++; }
+ private:
+  int count_;
+};
+
+// Protocol handler which counts the number of requests that start.
+class CountingProtocolHandler
+    : public net::URLRequestJobFactory::ProtocolHandler {
+ public:
+  CountingProtocolHandler(const base::FilePath& file,
+                          const base::WeakPtr<RequestCounter>& counter)
+      : file_(file),
+        counter_(counter),
+        weak_factory_(this) {
+  }
+  virtual ~CountingProtocolHandler() {}
+
+  virtual net::URLRequestJob* MaybeCreateJob(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const OVERRIDE {
+    MockHTTPJob* job = new MockHTTPJob(request, network_delegate, file_);
+    job->set_start_callback(base::Bind(&CountingProtocolHandler::RequestStarted,
+                                       weak_factory_.GetWeakPtr()));
+    return job;
+  }
+
+  void RequestStarted() {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&RequestCounter::RequestStarted, counter_));
+  }
+
+ private:
+  base::FilePath file_;
+  base::WeakPtr<RequestCounter> counter_;
+  mutable base::WeakPtrFactory<CountingProtocolHandler> weak_factory_;
+};
+
+// Makes |url| respond to requests with the contents of |file|, counting the
+// number that start in |counter|.
+void CreateCountingProtocolHandlerOnIO(
+    const GURL& url,
+    const base::FilePath& file,
+    const base::WeakPtr<RequestCounter>& counter) {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  scoped_ptr<net::URLRequestJobFactory::ProtocolHandler> protocol_handler(
+      new CountingProtocolHandler(file, counter));
+  net::URLRequestFilter::GetInstance()->AddUrlProtocolHandler(
+      url, protocol_handler.Pass());
+}
+
 // Makes |url| respond to requests with the contents of |file|.
 void CreateMockProtocolHandlerOnIO(const GURL& url,
                                    const base::FilePath& file) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   net::URLRequestFilter::GetInstance()->AddUrlProtocolHandler(
       url, content::URLRequestMockHTTPJob::CreateProtocolHandlerForSingleFile(
           file));
 }
 
 // A ContentBrowserClient that cancels all prerenderers on OpenURL.
@@ skipping 62 matching lines @@
     NOTREACHED();
   }
   virtual void LaunchUrlWithoutSecurityCheck(const GURL& url) OVERRIDE {
     NOTREACHED();
   }
   virtual void FinishedProcessingCheck() OVERRIDE {
     NOTREACHED();
   }
 };
 
+base::FilePath GetTestPath(const std::string& file_name) {
+  return ui_test_utils::GetTestFilePath(
+      base::FilePath(FILE_PATH_LITERAL("prerender")),
+      base::FilePath().AppendASCII(file_name));
+}
+
 }  // namespace
 
 // Many of these tests are flaky. See http://crbug.com/249179
 class PrerenderBrowserTest : virtual public InProcessBrowserTest {
  public:
   PrerenderBrowserTest()
       : autostart_test_server_(true),
         prerender_contents_factory_(NULL),
 #if defined(FULL_SAFE_BROWSING)
         safe_browsing_factory_(new TestSafeBrowsingServiceFactory()),
@@ skipping 849 matching lines @@
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 }
 
 // Checks that the prerendering of a page is canceled correctly if we try to
 // swap it in before it commits.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNoCommitNoSwap) {
   // Navigate to a page that triggers a prerender for a URL that never commits.
   const GURL kNoCommitUrl("http://never-respond.example.com");
-  base::FilePath file(FILE_PATH_LITERAL(
-      "chrome/test/data/prerender/prerender_page.html"));
+  base::FilePath file(GetTestPath("prerender_page.html"));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&CreateHangingFirstRequestProtocolHandlerOnIO,
                  kNoCommitUrl, file));
   DisableJavascriptCalls();
   PrerenderTestURL(kNoCommitUrl,
                    FINAL_STATUS_NAVIGATION_UNCOMMITTED,
                    0);
 
   // Navigate to the URL, but assume the contents won't be swapped in.
   NavigateToDestURLWithDisposition(CURRENT_TAB, false);
 }
 
 // Checks that client redirects don't add alias URLs until after they commit.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNoCommitNoSwap2) {
   // Navigate to a page that then navigates to a URL that never commits.
   const GURL kNoCommitUrl("http://never-respond.example.com");
-  base::FilePath file(FILE_PATH_LITERAL(
-      "chrome/test/data/prerender/prerender_page.html"));
+  base::FilePath file(GetTestPath("prerender_page.html"));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&CreateHangingFirstRequestProtocolHandlerOnIO,
                  kNoCommitUrl, file));
   DisableJavascriptCalls();
   PrerenderTestURL(CreateClientRedirect(kNoCommitUrl.spec()),
                    FINAL_STATUS_APP_TERMINATING, 1);
 
   // Navigating to the second URL should not swap.
   NavigateToURLWithDisposition(kNoCommitUrl, CURRENT_TAB, false);
@@ skipping 1650 matching lines @@
 // a client redirect.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderCrossProcessClientRedirect) {
   // Cross-process navigation logic for renderer-initiated navigations
   // is partially controlled by the renderer, namely
   // ChromeContentRendererClient. This test instead relies on the Web
   // Store triggering such navigations.
   std::string webstore_url = extension_urls::GetWebstoreLaunchURL();
 
   // Mock out requests to the Web Store.
-  base::FilePath file(FILE_PATH_LITERAL(
-      "chrome/test/data/prerender/prerender_page.html"));
+  base::FilePath file(GetTestPath("prerender_page.html"));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&CreateMockProtocolHandlerOnIO,
                  GURL(webstore_url), file));
 
   PrerenderTestURL(CreateClientRedirect(webstore_url),
                    FINAL_STATUS_OPEN_URL, 1);
 }
 
 // Checks that canceling a MatchComplete dummy doesn't result in two
@@ skipping 95 matching lines @@
 // prerendered page tries to make a second navigation entry.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNewNavigationEntry) {
   PrerenderTestURL("files/prerender/prerender_new_entry.html",
                    FINAL_STATUS_NEW_NAVIGATION_ENTRY,
                    1);
 }
 
 // Attempt a swap-in in a new tab, verifying that session storage namespace
 // merging works.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageNewTab) {
-  PrerenderTestURL("files/prerender/prerender_session_storage.html",
-                   FINAL_STATUS_USED, 1);
+  // Mock out some URLs and count the number of requests to one of them. Both
+  // prerender_session_storage.html and init_session_storage.html need to be
+  // mocked so they are same-origin.
+  const GURL kInitURL("http://prerender.test/init_session_storage.html");
+  base::FilePath init_file = GetTestPath("init_session_storage.html");
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&CreateMockProtocolHandlerOnIO, kInitURL, init_file));
+
+  const GURL kTestURL("http://prerender.test/prerender_session_storage.html");
+  base::FilePath test_file = GetTestPath("prerender_session_storage.html");
+  RequestCounter counter;
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&CreateCountingProtocolHandlerOnIO,
+                 kTestURL, test_file, counter.AsWeakPtr()));
+
+  PrerenderTestURL(kTestURL, FINAL_STATUS_USED, 1);
 
   // Open a new tab to navigate in.
   ui_test_utils::NavigateToURLWithDisposition(
-      current_browser(),
-      test_server()->GetURL("files/prerender/init_session_storage.html"),
-      NEW_FOREGROUND_TAB,
+      current_browser(), kInitURL, NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // Now navigate in the new tab. Set expect_swap_to_succeed to false because
   // the swap does not occur synchronously.
   //
   // TODO(davidben): When all swaps become asynchronous, remove the OpenURL
   // return value assertion and let this go through the usual successful-swap
   // codepath.
   NavigateToDestURLWithDisposition(CURRENT_TAB, false);
 
   // Verify DidDisplayPass manually since the previous call skipped it.
   EXPECT_TRUE(DidDisplayPass(
       current_browser()->tab_strip_model()->GetActiveWebContents()));
+
+  // Only one request to the test URL started.
+  EXPECT_EQ(1, counter.count());
+}
+
+// Attempt a swap-in in a new tab, verifying that session storage namespace
+// merging works. Unlike the above test, the swap is for a navigation that would
+// normally be cross-process.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageNewTabCrossProcess) {
+  base::FilePath test_data_dir;
+  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir));
+
+  // Mock out some URLs and count the number of requests to one of them. Both
+  // prerender_session_storage.html and init_session_storage.html need to be
+  // mocked so they are same-origin.
+  const GURL kInitURL("http://prerender.test/init_session_storage.html");
+  base::FilePath init_file = GetTestPath("init_session_storage.html");
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&CreateMockProtocolHandlerOnIO, kInitURL, init_file));
+
+  const GURL kTestURL("http://prerender.test/prerender_session_storage.html");
+  base::FilePath test_file = GetTestPath("prerender_session_storage.html");
+  RequestCounter counter;
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&CreateCountingProtocolHandlerOnIO,
+                 kTestURL, test_file, counter.AsWeakPtr()));
+
+  PrerenderTestURL(kTestURL, FINAL_STATUS_USED, 1);
+
+  // Open a new tab to navigate in.
+  ui_test_utils::NavigateToURLWithDisposition(
+      current_browser(), kInitURL, NEW_FOREGROUND_TAB,
+      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
+
+  // Navigate to about:blank so the next navigation is cross-process.
+  ui_test_utils::NavigateToURL(current_browser(),
+                               GURL(content::kAboutBlankURL));
+
+  // Now navigate in the new tab. Set expect_swap_to_succeed to false because
+  // the swap does not occur synchronously.
+  //
+  // TODO(davidben): When all swaps become asynchronous, remove the OpenURL
+  // return value assertion and let this go through the usual successful-swap
+  // codepath.
+  NavigateToDestURLWithDisposition(CURRENT_TAB, false);
+
+  // Verify DidDisplayPass manually since the previous call skipped it.
+  EXPECT_TRUE(DidDisplayPass(
+      current_browser()->tab_strip_model()->GetActiveWebContents()));
+
+  // Only one request to the test URL started.
+  EXPECT_EQ(1, counter.count());
 }
 
 // Verify that session storage conflicts don't merge.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSessionStorageConflict) {
   PrerenderTestURL("files/prerender/prerender_session_storage_conflict.html",
                    FINAL_STATUS_APP_TERMINATING, 1);
 
   // Open a new tab to navigate in.
   ui_test_utils::NavigateToURLWithDisposition(
       current_browser(),
@@ skipping 23 matching lines @@
   const NavigationController& controller = web_contents->GetController();
   // First entry is about:blank, second is prerender_page.html.
   EXPECT_TRUE(controller.GetPendingEntry() == NULL);
   EXPECT_EQ(2, controller.GetEntryCount());
   EXPECT_EQ(GURL(content::kAboutBlankURL),
             controller.GetEntryAtIndex(0)->GetURL());
   EXPECT_EQ(dest_url(), controller.GetEntryAtIndex(1)->GetURL());
 }
 
 }  // namespace prerender