Revert of [NoStatePrefetch] Kill renderer after preload scanning

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 <memory>
 #include <set>
 #include <string>
-#include <utility>
 #include <vector>
 
 #include "base/command_line.h"
-#include "base/strings/string_split.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/test/embedded_test_server/request_handler_util.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 {
 
@@ skipping 297 matching lines @@
 
 DestructionWaiter::DestructionMarker::~DestructionMarker() {}
 
 void DestructionWaiter::DestructionMarker::OnPrerenderStop(
     PrerenderContents* contents) {
   waiter_->MarkDestruction(contents->final_status());
 }
 
 TestPrerender::TestPrerender()
     : contents_(nullptr),
-      final_status_(FINAL_STATUS_MAX),
       number_of_loads_(0),
       expected_number_of_loads_(0),
       started_(false),
       stopped_(false) {}
 
 TestPrerender::~TestPrerender() {
   if (contents_)
     contents_->RemoveObserver(this);
 }
 
-FinalStatus TestPrerender::GetFinalStatus() const {
-  if (contents_)
-    return contents_->final_status();
-  return final_status_;
-}
-
 void TestPrerender::WaitForCreate() {
   if (contents_)
     return;
   create_loop_.Run();
 }
 
 void TestPrerender::WaitForStart() {
   if (started_)
     return;
   start_loop_.Run();
@@ skipping 32 matching lines @@
 
 void TestPrerender::OnPrerenderStopLoading(PrerenderContents* contents) {
   number_of_loads_++;
   if (load_waiter_ && number_of_loads_ >= expected_number_of_loads_)
     load_waiter_->Quit();
 }
 
 void TestPrerender::OnPrerenderStop(PrerenderContents* contents) {
   DCHECK(contents_);
   contents_ = nullptr;
-  final_status_ = contents->final_status();
   stopped_ = true;
   stop_loop_.Quit();
   // If there is a WaitForLoads call and it has yet to see the expected number
   // of loads, stop the loop so the test fails instead of timing out.
   if (load_waiter_)
     load_waiter_->Quit();
 }
 
 TestPrerenderContentsFactory::TestPrerenderContentsFactory() {}
 
@@ skipping 100 matching lines @@
 }
 
 TestPrerenderContents* PrerenderInProcessBrowserTest::GetPrerenderContentsFor(
     const GURL& url) const {
   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 = src_server()->GetURL(MakeAbsolute(html_file));
+  return PrerenderTestURL(url, expected_final_status, 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);
+  auto prerenders = PrerenderTestURLImpl(url, expected_final_status_queue,
+                                         expected_number_of_loads);
+  CHECK_EQ(1u, prerenders.size());
+  return std::move(prerenders[0]);
+}
+
+std::vector<std::unique_ptr<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()
@@ skipping 51 matching lines @@
 
 base::string16 PrerenderInProcessBrowserTest::MatchTaskManagerPrerender(
     const char* page_title) {
   return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_PRERENDER_PREFIX,
                                     base::ASCIIToUTF16(page_title));
 }
 
 std::vector<std::unique_ptr<TestPrerender>>
 PrerenderInProcessBrowserTest::NavigateWithPrerenders(
     const GURL& loader_url,
-    const std::vector<FinalStatus>& expected_final_status_queue) {
+    const std::vector<FinalStatus>& expected_final_status_queue,
+    int expected_number_of_loads) {
   CHECK(!expected_final_status_queue.empty());
   std::vector<std::unique_ptr<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]));
   }
 
   // Navigate to the loader URL and then wait for the first prerender to be
   // created.
   ui_test_utils::NavigateToURL(current_browser(), loader_url);
-  prerenders[0]->WaitForCreate();
+  prerenders.at(0)->WaitForCreate();
+  prerenders.at(0)->WaitForLoads(expected_number_of_loads);
 
   return prerenders;
 }
 
-GURL PrerenderInProcessBrowserTest::ServeLoaderURL(
-    const std::string& loader_path,
-    const std::string& replacement_variable,
-    const GURL& url_to_prerender,
-    const std::string& loader_query) {
-  base::StringPairs replacement_text;
-  replacement_text.push_back(
-      make_pair(replacement_variable, url_to_prerender.spec()));
-  std::string replacement_path;
-  net::test_server::GetFilePathWithReplacements(loader_path, replacement_text,
-                                                &replacement_path);
-  return src_server()->GetURL(replacement_path + loader_query);
-}
-
 void CreateCountingInterceptorOnIO(
     const GURL& url,
     const base::FilePath& file,
     const base::WeakPtr<RequestCounter>& counter) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
       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