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 223 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 74 matching lines @@
 TestPrerenderContentsFactory::ExpectedContents::ExpectedContents(
     const ExpectedContents& other) = default;
 
 TestPrerenderContentsFactory::ExpectedContents::ExpectedContents(
     FinalStatus final_status,
     const base::WeakPtr<TestPrerender>& handle)
     : final_status(final_status), handle(handle) {}
 
 TestPrerenderContentsFactory::ExpectedContents::~ExpectedContents() {}
 
+TestPrerenderManager::TestPrerenderManager(Profile* profile)
+    : PrerenderManager(profile), time_(base::Time::Now()) {}
+
+base::Time TestPrerenderManager::GetCurrentTime() const {
+  if (delta_.is_zero()) {
+    return base::Time::Now();
+  }
+  return time_ + delta_;
+}
+
+base::TimeTicks TestPrerenderManager::GetCurrentTimeTicks() const {
+  if (delta_.is_zero()) {
+    return base::TimeTicks::Now();
+  }
+  return time_ticks_ + delta_;
+}
+
+void TestPrerenderManager::AdvanceTime(base::TimeDelta delta) {
+  if (delta_.is_zero()) {
+    time_ = base::Time::Now();
+    time_ticks_ = base::TimeTicks::Now();
+    delta_ = delta;
+  } else {
+    delta_ += delta;
+  }
+}
+
 PrerenderInProcessBrowserTest::PrerenderInProcessBrowserTest()
     : external_protocol_handler_delegate_(
           base::MakeUnique<NeverRunsExternalProtocolHandlerDelegate>()),
       safe_browsing_factory_(
           base::MakeUnique<safe_browsing::TestSafeBrowsingServiceFactory>()),
       prerender_contents_factory_(nullptr),
       explicitly_set_browser_(nullptr),
-      autostart_test_server_(true) {}
+      autostart_test_server_(true) {
+  PrerenderManagerFactory::set_testing_create_function(
+      [](content::BrowserContext* context) {
+        return static_cast<std::unique_ptr<KeyedService>>(

[droger, 2016/09/23 09:54:39]

Is the static cast really needed?

Can you instead:

return std::move(base::MakeUnique<TestPrerenderManager>(
    Profile::FromBrowserContext(context)));

(according to
http://stackoverflow.com/questions/33971318/the-correct-way-of-returning-stdu...)

+            base::MakeUnique<TestPrerenderManager>(
+                Profile::FromBrowserContext(context)));
+      });
+}
 
 PrerenderInProcessBrowserTest::~PrerenderInProcessBrowserTest() {}
 
 void PrerenderInProcessBrowserTest::SetUpCommandLine(
     base::CommandLine* command_line) {
   command_line->AppendSwitch(switches::kEnablePepperTesting);
   command_line->AppendSwitchASCII(switches::kOverridePluginPowerSaverForTesting,
                                   "ignore-list");
   ASSERT_TRUE(ppapi::RegisterPowerSaverTestPlugin(command_line));
 }
 
 void PrerenderInProcessBrowserTest::TearDownInProcessBrowserTestFixture() {
   safe_browsing::SafeBrowsingService::RegisterFactory(nullptr);
 }
 
 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);
+}
+
 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(
+    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