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/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.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 122 matching lines @@
   expected_threats.push_back(safe_browsing::SB_THREAT_TYPE_URL_PHISHING);
   // TODO(nparker): Replace SafeBrowsingCheck w/ a call to
   // client->OnCheckBrowseUrlResult()
   safe_browsing::LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck sb_check(
       std::vector<GURL>(1, gurl), std::vector<safe_browsing::SBFullHash>(),
       client, safe_browsing::MALWARE, expected_threats);
   sb_check.url_results[0] = bad_urls_[gurl.spec()];
   sb_check.OnSafeBrowsingResult();
 }
 
+TestPrerenderContents::DestroyObserver::~DestroyObserver() {}
+
 TestPrerenderContents::TestPrerenderContents(
     PrerenderManager* prerender_manager,
     Profile* profile,
     const GURL& url,
     const content::Referrer& referrer,
     Origin origin,
     FinalStatus expected_final_status)
     : PrerenderContents(prerender_manager, profile, url, referrer, origin),
       expected_final_status_(expected_final_status),
       new_render_view_host_(nullptr),
@@ skipping 45 matching lines @@
 }
 
 bool TestPrerenderContents::CheckURL(const GURL& url) {
   // Prevent FINAL_STATUS_UNSUPPORTED_SCHEME when navigating to about:crash in
   // the PrerenderRendererCrash test.
   if (url.spec() != content::kChromeUICrashURL)
     return PrerenderContents::CheckURL(url);
   return true;
 }
 
+void TestPrerenderContents::AddDestroyObserver(
+    std::unique_ptr<DestroyObserver> observer) {
+  if (final_status() != FINAL_STATUS_MAX) {
+    // This contents has already been destroyed, so update the observer
+    // immediately.
+    observer->OnDestroy(final_status());
+  }
+  destroy_observers_.push_back(std::move(observer));
+}
+
+void TestPrerenderContents::Destroy(FinalStatus reason) {
+  for (const auto& observer : destroy_observers_) {
+    observer->OnDestroy(reason);
+  }
+  PrerenderContents::Destroy(reason);
+}
+
 void TestPrerenderContents::OnRenderViewHostCreated(
     RenderViewHost* new_render_view_host) {
   // Used to make sure the RenderViewHost is hidden and, if used,
   // subsequently shown.
   notification_registrar().Add(
       this, content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
       content::Source<content::RenderWidgetHost>(
           new_render_view_host->GetWidget()));
 
   new_render_view_host_ = new_render_view_host;
@@ skipping 16 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) {
+  prerender_contents->AddDestroyObserver(
+      base::MakeUnique<DestructionMarker>(this));
+}
+
+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) {}
+
+void DestructionWaiter::DestructionMarker::OnDestroy(FinalStatus reason) {
+  waiter_->MarkDestruction(reason);
+}
+
 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 105 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 12 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);
+}
+
 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(
+    std::function<void(net::EmbeddedTestServer*)> startup) {
+  if (https_src_server_)
+    return;
+  https_src_server_.reset(
+      new net::EmbeddedTestServer(net::EmbeddedTestServer::TYPE_HTTPS));
+  https_src_server_->ServeFilesFromSourceDirectory("chrome/test/data");
+  startup(https_src_server_.get());
+  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(
+    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