NoState Prefetch: nostate prefetch browser tests.

chrome/browser/prerender/prerender_test_utils.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 "chrome/browser/prerender/prerender_test_utils.h"
 
 #include "base/command_line.h"
+#include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/loader/chrome_resource_dispatcher_host_delegate.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/local_database_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/pref_names.h"
+#include "chrome/grit/generated_resources.h"
+#include "chrome/test/base/ui_test_utils.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/ppapi_test_utils.h"
 #include "net/url_request/url_request_filter.h"
 #include "ppapi/shared_impl/ppapi_switches.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 using content::RenderViewHost;
 
 namespace prerender {
 
 namespace test_utils {
 
 namespace {
 
@@ skipping 19 matching lines @@
       start_callback_.Run();
     net::URLRequestMockHTTPJob::Start();
   }
 
  private:
   ~MockHTTPJob() override {}
 
   base::Closure start_callback_;
 };
 
-// Protocol handler which counts the number of requests that start.
+// URLRequestInterceptor which counts the number of requests that start.
 class CountingInterceptor : public net::URLRequestInterceptor {
  public:
   CountingInterceptor(const base::FilePath& file,
                       const base::WeakPtr<RequestCounter>& counter)
       : file_(file), counter_(counter), weak_factory_(this) {}
   ~CountingInterceptor() override {}
 
   net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const override {
@@ skipping 141 matching lines @@
       new_render_view_host_(nullptr),
       was_hidden_(false),
       was_shown_(false),
       should_be_shown_(expected_final_status == FINAL_STATUS_USED),
       skip_final_checks_(false) {}
 
 TestPrerenderContents::~TestPrerenderContents() {
   if (skip_final_checks_)
     return;
 
-  EXPECT_EQ(expected_final_status_, final_status())
-      << " when testing URL " << prerender_url().path()
-      << " (Expected: " << NameFromFinalStatus(expected_final_status_)
-      << ", Actual: " << NameFromFinalStatus(final_status()) << ")";
+  if (expected_final_status_ != FINAL_STATUS_TESTING_IGNORE) {
+    EXPECT_EQ(expected_final_status_, final_status())
+        << " when testing URL " << prerender_url().path()
+        << " (Expected: " << NameFromFinalStatus(expected_final_status_)
+        << ", Actual: " << NameFromFinalStatus(final_status()) << ")";
+  }
 
   // Prerendering RenderViewHosts should be hidden before the first
   // navigation, so this should be happen for every PrerenderContents for
   // which a RenderViewHost is created, regardless of whether or not it's
   // used.
   if (new_render_view_host_)
     EXPECT_TRUE(was_hidden_);
 
   // A used PrerenderContents will only be destroyed when we swap out
   // WebContents, at the end of a navigation caused by a call to
   // NavigateToURLImpl().
   if (final_status() == FINAL_STATUS_USED)
     EXPECT_TRUE(new_render_view_host_);
 
   EXPECT_EQ(should_be_shown_, was_shown_);
 }
 
 void TestPrerenderContents::RenderProcessGone(base::TerminationStatus status) {
   // On quit, it's possible to end up here when render processes are closed
   // before the PrerenderManager is destroyed.  As a result, it's possible to
   // get either FINAL_STATUS_APP_TERMINATING or FINAL_STATUS_RENDERER_CRASHED
   // on quit.
   //
   // It's also possible for this to be called after we've been notified of
   // app termination, but before we've been deleted, which is why the second
   // check is needed.
-  if (expected_final_status_ == FINAL_STATUS_APP_TERMINATING &&
+  if (expected_final_status_ != FINAL_STATUS_TESTING_IGNORE &&
+      expected_final_status_ == FINAL_STATUS_APP_TERMINATING &&
       final_status() != expected_final_status_) {
     expected_final_status_ = FINAL_STATUS_RENDERER_CRASHED;
   }
 
   PrerenderContents::RenderProcessGone(status);
 }
 
 bool TestPrerenderContents::CheckURL(const GURL& url) {
   // Prevent FINAL_STATUS_UNSUPPORTED_SCHEME when navigating to about:crash in
   // the PrerenderRendererCrash test.
@@ skipping 31 matching lines @@
       // Once hidden, a prerendered RenderViewHost should only be shown after
       // being removed from the PrerenderContents for display.
       EXPECT_FALSE(GetRenderViewHost());
       was_shown_ = true;
     }
     return;
   }
   PrerenderContents::Observe(type, source, details);
 }
 
+DestructionWaiter::DestructionWaiter(TestPrerenderContents* prerender_contents,
+                                     FinalStatus expected_final_status)
+    : expected_final_status_(expected_final_status),
+      saw_correct_status_(false) {
+  if (prerender_contents->final_status() != FINAL_STATUS_MAX) {
+    // The contents was already destroyed by the time this was called.
+    MarkDestruction(prerender_contents->final_status());
+  } else {
+    marker_ = base::MakeUnique<DestructionMarker>(this);
+    prerender_contents->AddObserver(marker_.get());
+  }
+}
+
+DestructionWaiter::~DestructionWaiter() {}
+
+bool DestructionWaiter::WaitForDestroy() {
+  if (!saw_correct_status_) {
+    wait_loop_.Run();
+  }
+  return saw_correct_status_;
+}
+
+void DestructionWaiter::MarkDestruction(FinalStatus reason) {
+  saw_correct_status_ = (reason == expected_final_status_);
+  wait_loop_.Quit();
+}
+
+DestructionWaiter::DestructionMarker::DestructionMarker(
+    DestructionWaiter* waiter)
+    : waiter_(waiter) {}
+
+DestructionWaiter::DestructionMarker::~DestructionMarker() {}
+
+void DestructionWaiter::DestructionMarker::OnPrerenderStop(
+    PrerenderContents* contents) {
+  waiter_->MarkDestruction(contents->final_status());
+}
+
 TestPrerender::TestPrerender()
     : contents_(nullptr), number_of_loads_(0), expected_number_of_loads_(0) {}
 
 TestPrerender::~TestPrerender() {
   if (contents_)
     contents_->RemoveObserver(this);
 }
 
 void TestPrerender::WaitForLoads(int expected_number_of_loads) {
   DCHECK(!load_waiter_);
@@ skipping 102 matching lines @@
 }
 
 content::SessionStorageNamespace*
 PrerenderInProcessBrowserTest::GetSessionStorageNamespace() const {
   content::WebContents* web_contents = GetActiveWebContents();
   if (!web_contents)
     return nullptr;
   return web_contents->GetController().GetDefaultSessionStorageNamespace();
 }
 
+std::string PrerenderInProcessBrowserTest::MakeAbsolute(
+    const std::string& path) {
+  CHECK(!path.empty());
+  if (path.front() == '/') {
+    return path;
+  }
+  return "/" + path;
+}
+
 bool PrerenderInProcessBrowserTest::UrlIsInPrerenderManager(
     const std::string& html_file) const {
   return UrlIsInPrerenderManager(embedded_test_server()->GetURL(html_file));
 }
 
 bool PrerenderInProcessBrowserTest::UrlIsInPrerenderManager(
     const GURL& url) const {
   return GetPrerenderManager()->FindPrerenderData(
              url, GetSessionStorageNamespace()) != nullptr;
 }
@@ skipping 13 matching lines @@
   PrerenderManager::PrerenderData* prerender_data =
       GetPrerenderManager()->FindPrerenderData(url, nullptr);
   return static_cast<TestPrerenderContents*>(
       prerender_data ? prerender_data->contents() : nullptr);
 }
 
 std::unique_ptr<TestPrerender> PrerenderInProcessBrowserTest::PrerenderTestURL(
     const std::string& html_file,
     FinalStatus expected_final_status,
     int expected_number_of_loads) {
-  GURL url = embedded_test_server()->GetURL(html_file);
+  GURL url = src_server()->GetURL(MakeAbsolute(html_file));
   return PrerenderTestURL(url, expected_final_status, expected_number_of_loads);
 }
 
-ScopedVector<TestPrerender> PrerenderInProcessBrowserTest::PrerenderTestURL(
-    const std::string& html_file,
-    const std::vector<FinalStatus>& expected_final_status_queue,
-    int expected_number_of_loads) {
-  GURL url = embedded_test_server()->GetURL(html_file);
-  return PrerenderTestURLImpl(url, expected_final_status_queue,
-                              expected_number_of_loads);
-}
-
 std::unique_ptr<TestPrerender> PrerenderInProcessBrowserTest::PrerenderTestURL(
     const GURL& url,
     FinalStatus expected_final_status,
     int expected_number_of_loads) {
   std::vector<FinalStatus> expected_final_status_queue(1,
                                                        expected_final_status);
   std::vector<TestPrerender*> prerenders;
   PrerenderTestURLImpl(url, expected_final_status_queue,
                        expected_number_of_loads)
       .release(&prerenders);
   CHECK_EQ(1u, prerenders.size());
   return std::unique_ptr<TestPrerender>(prerenders[0]);
 }
 
+ScopedVector<TestPrerender> PrerenderInProcessBrowserTest::PrerenderTestURL(
+    const std::string& html_file,
+    const std::vector<FinalStatus>& expected_final_status_queue,
+    int expected_number_of_loads) {
+  GURL url = src_server()->GetURL(MakeAbsolute(html_file));
+  return PrerenderTestURLImpl(url, expected_final_status_queue,
+                              expected_number_of_loads);
+}
+
+net::EmbeddedTestServer* PrerenderInProcessBrowserTest::src_server() {
+  if (https_src_server_)
+    return https_src_server_.get();
+  return embedded_test_server();
+}
+
+test_utils::FakeSafeBrowsingDatabaseManager*
+PrerenderInProcessBrowserTest::GetFakeSafeBrowsingDatabaseManager() {
+  return static_cast<test_utils::FakeSafeBrowsingDatabaseManager*>(
+      safe_browsing_factory()
+          ->test_safe_browsing_service()
+          ->database_manager()
+          .get());
+}
+
 void PrerenderInProcessBrowserTest::SetUpInProcessBrowserTestFixture() {
   safe_browsing_factory_->SetTestDatabaseManager(
       new test_utils::FakeSafeBrowsingDatabaseManager());
   safe_browsing::SafeBrowsingService::RegisterFactory(
       safe_browsing_factory_.get());
 }
 
 void PrerenderInProcessBrowserTest::SetUpOnMainThread() {
   // Increase the memory allowed in a prerendered page above normal settings.
   // Debug build bots occasionally run against the default limit, and tests
@@ skipping 12 matching lines @@
   PrerenderManager* prerender_manager = GetPrerenderManager();
   ASSERT_TRUE(prerender_manager);
   prerender_manager->mutable_config().rate_limit_enabled = false;
   ASSERT_FALSE(prerender_contents_factory_);
   prerender_contents_factory_ = new TestPrerenderContentsFactory;
   prerender_manager->SetPrerenderContentsFactoryForTest(
       prerender_contents_factory_);
   ASSERT_TRUE(safe_browsing_factory_->test_safe_browsing_service());
 }
 
+void PrerenderInProcessBrowserTest::UseHttpsSrcServer() {
+  if (https_src_server_)
+    return;
+  https_src_server_.reset(
+      new net::EmbeddedTestServer(net::EmbeddedTestServer::TYPE_HTTPS));
+  https_src_server_->ServeFilesFromSourceDirectory("chrome/test/data");
+  CHECK(https_src_server_->Start());
+}
+
+base::string16 PrerenderInProcessBrowserTest::MatchTaskManagerTab(
+    const char* page_title) {
+  return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_TAB_PREFIX,
+                                    base::ASCIIToUTF16(page_title));
+}
+
+base::string16 PrerenderInProcessBrowserTest::MatchTaskManagerPrerender(
+    const char* page_title) {
+  return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_PRERENDER_PREFIX,
+                                    base::ASCIIToUTF16(page_title));
+}
+
+ScopedVector<TestPrerender>
+PrerenderInProcessBrowserTest::NavigateWithPrerenders(
+    const GURL& loader_url,
+    const std::vector<FinalStatus>& expected_final_status_queue,
+    int expected_number_of_loads) {
+  CHECK(!expected_final_status_queue.empty());
+  ScopedVector<TestPrerender> prerenders;
+  for (size_t i = 0; i < expected_final_status_queue.size(); i++) {
+    prerenders.push_back(
+        prerender_contents_factory()
+            ->ExpectPrerenderContents(expected_final_status_queue[i])
+            .release());
+  }
+
+  // Navigate to the loader URL and then wait for the first prerender to be
+  // created.
+  ui_test_utils::NavigateToURL(current_browser(), loader_url);
+  prerenders.get().at(0)->WaitForCreate();
+  prerenders.get().at(0)->WaitForLoads(expected_number_of_loads);
+
+  return prerenders;
+}
+
 void CreateCountingInterceptorOnIO(
     const GURL& url,
     const base::FilePath& file,
     const base::WeakPtr<RequestCounter>& counter) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-  std::unique_ptr<net::URLRequestInterceptor> request_interceptor(
-      new CountingInterceptor(file, counter));
   net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
-      url, std::move(request_interceptor));
+      url, base::MakeUnique<CountingInterceptor>(file, counter));
 }
 
 void CreateMockInterceptorOnIO(const GURL& url, const base::FilePath& file) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
       url, net::URLRequestMockHTTPJob::CreateInterceptorForSingleFile(
                file, content::BrowserThread::GetBlockingPool()));
 }
 
 }  // namespace test_utils
 
 }  // namespace prerender