Revert of [NoStatePrefetch] Kill renderer after preload scanning

chrome/browser/prerender/prerender_test_utils.h

 // Copyright (c) 2016 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.
 
 #ifndef CHROME_BROWSER_PRERENDER_PRERENDER_TEST_UTILS_H_
 #define CHROME_BROWSER_PRERENDER_PRERENDER_TEST_UTILS_H_
 
 #include <deque>
 #include <functional>
 #include <memory>
@@ skipping 126 matching lines @@
   // Set to true when the prerendering RenderWidget is hidden.
   bool was_hidden_;
   // Set to true when the prerendering RenderWidget is shown, after having been
   // hidden.
   bool was_shown_;
   // Expected final value of was_shown_.  Defaults to true for
   // FINAL_STATUS_USED, and false otherwise.
   bool should_be_shown_;
   // If true, |expected_final_status_| and other shutdown checks are skipped.
   bool skip_final_checks_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestPrerenderContents);
 };
 
 // A handle to a TestPrerenderContents whose lifetime is under the caller's
 // control. A PrerenderContents may be destroyed at any point. This allows
-// tracking the FinalStatus.
+// tracking the final status, etc.
 class TestPrerender : public PrerenderContents::Observer,
                       public base::SupportsWeakPtr<TestPrerender> {
  public:
   TestPrerender();
   ~TestPrerender() override;
 
   TestPrerenderContents* contents() const { return contents_; }
   int number_of_loads() const { return number_of_loads_; }
-  FinalStatus GetFinalStatus() const;
 
   void WaitForCreate();
   void WaitForStart();
   void WaitForStop();
 
   // Waits for |number_of_loads()| to be at least |expected_number_of_loads| OR
   // for the prerender to stop running (just to avoid a timeout if the prerender
   // dies). Note: this does not assert equality on the number of loads; the
   // caller must do it instead.
   void WaitForLoads(int expected_number_of_loads);
 
   void OnPrerenderCreated(TestPrerenderContents* contents);
 
   // PrerenderContents::Observer implementation:
   void OnPrerenderStart(PrerenderContents* contents) override;
 
   void OnPrerenderStopLoading(PrerenderContents* contents) override;
 
   void OnPrerenderStop(PrerenderContents* contents) override;
 
  private:
   TestPrerenderContents* contents_;
-  FinalStatus final_status_;
   int number_of_loads_;
 
   int expected_number_of_loads_;
   std::unique_ptr<base::RunLoop> load_waiter_;
 
   bool started_;
   bool stopped_;
 
   base::RunLoop create_loop_;
   base::RunLoop start_loop_;
@@ skipping 24 matching lines @@
    public:
     // Does not own the waiter which must outlive the TestPrerenderContents.
     explicit DestructionMarker(DestructionWaiter* waiter);
 
     ~DestructionMarker() override;
 
     void OnPrerenderStop(PrerenderContents* contents) override;
 
    private:
     DestructionWaiter* waiter_;
-
-    DISALLOW_COPY_AND_ASSIGN(DestructionMarker);
   };
 
   // To be called by a DestructionMarker.
   void MarkDestruction(FinalStatus reason);
 
   base::RunLoop wait_loop_;
   FinalStatus expected_final_status_;
   bool saw_correct_status_;
   std::unique_ptr<DestructionMarker> marker_;
-
-  DISALLOW_COPY_AND_ASSIGN(DestructionWaiter);
 };
 
 // PrerenderContentsFactory that uses TestPrerenderContents.
 class TestPrerenderContentsFactory : public PrerenderContents::Factory {
  public:
   TestPrerenderContentsFactory();
 
   ~TestPrerenderContentsFactory() override;
 
   std::unique_ptr<TestPrerender> ExpectPrerenderContents(
@@ skipping 12 matching lines @@
     ExpectedContents(const ExpectedContents& other);
     ExpectedContents(FinalStatus final_status,
                      const base::WeakPtr<TestPrerender>& handle);
     ~ExpectedContents();
 
     FinalStatus final_status;
     base::WeakPtr<TestPrerender> handle;
   };
 
   std::deque<ExpectedContents> expected_contents_queue_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestPrerenderContentsFactory);
 };
 
 class PrerenderInProcessBrowserTest : virtual public InProcessBrowserTest {
  public:
   PrerenderInProcessBrowserTest();
 
   ~PrerenderInProcessBrowserTest() override;
 
   void SetUpCommandLine(base::CommandLine* command_line) override;
   void SetUpInProcessBrowserTestFixture() override;
@@ skipping 10 matching lines @@
   bool UrlIsInPrerenderManager(const GURL& url) const;
 
   // Convenience function to get the currently active WebContents in
   // current_browser().
   content::WebContents* GetActiveWebContents() const;
 
   PrerenderManager* GetPrerenderManager() const;
 
   TestPrerenderContents* GetPrerenderContentsFor(const GURL& url) const;
 
+  std::unique_ptr<TestPrerender> PrerenderTestURL(
+      const std::string& html_file,
+      FinalStatus expected_final_status,
+      int expected_number_of_loads);
+
+  std::unique_ptr<TestPrerender> PrerenderTestURL(
+      const GURL& url,
+      FinalStatus expected_final_status,
+      int expected_number_of_loads);
+
+  std::vector<std::unique_ptr<TestPrerender>> PrerenderTestURL(
+      const std::string& html_file,
+      const std::vector<FinalStatus>& expected_final_status_queue,
+      int expected_number_of_loads);
+
   // Set up an HTTPS server.
   void UseHttpsSrcServer();
 
   // Returns the currently active server. See |UseHttpsSrcServer|.
   net::EmbeddedTestServer* src_server();
 
   safe_browsing::TestSafeBrowsingServiceFactory* safe_browsing_factory() const {
     return safe_browsing_factory_.get();
   }
 
@@ skipping 14 matching lines @@
 
   const base::HistogramTester& histogram_tester() { return histogram_tester_; }
 
   // Returns a string for pattern-matching TaskManager tab entries.
   base::string16 MatchTaskManagerTab(const char* page_title);
 
   // Returns a string for pattern-matching TaskManager prerender entries.
   base::string16 MatchTaskManagerPrerender(const char* page_title);
 
  protected:
-  // For each FinalStatus in |expected_final_status_queue| creates a prerender
-  // that is going to verify the correctness of its FinalStatus upon
-  // destruction. Waits for creation of the first PrerenderContents.
+  // To be called from PrerenderTestUrlImpl. Sets up the appropraite prerenders,
+  // checking for the expected final status, navigates to the loader url, and
+  // waits for the load.
   std::vector<std::unique_ptr<TestPrerender>> NavigateWithPrerenders(
       const GURL& loader_url,
-      const std::vector<FinalStatus>& expected_final_status_queue);
-
-  // Creates the URL that instructs the test server to substitute the text
-  // |replacement_variable| in the contents of the file pointed to by
-  // |loader_path| with |url_to_prerender|. Also appends the |loader_query| to
-  // the URL.
-  GURL ServeLoaderURL(const std::string& loader_path,
-                      const std::string& replacement_variable,
-                      const GURL& url_to_prerender,
-                      const std::string& loader_query);
+      const std::vector<FinalStatus>& expected_final_status_queue,
+      int expected_number_of_loads);
 
  private:
+  // Implement load of a url for a prerender test. prerender_url should be
+  // loaded, and we should expect to see one prerenderer created, and exit, for
+  // each entry in expected_final_status_queue, and seeing
+  // expected_number_of_loads. Specific tests can provide additional
+  // verification. Note this should be called by one of the convenience wrappers
+  // defined above.
+  virtual std::vector<std::unique_ptr<TestPrerender>> PrerenderTestURLImpl(
+      const GURL& prerender_url,
+      const std::vector<FinalStatus>& expected_final_status_queue,
+      int expected_number_of_loads) = 0;
+
   std::unique_ptr<ExternalProtocolHandler::Delegate>
       external_protocol_handler_delegate_;
   std::unique_ptr<safe_browsing::TestSafeBrowsingServiceFactory>
       safe_browsing_factory_;
   TestPrerenderContentsFactory* prerender_contents_factory_;
   Browser* explicitly_set_browser_;
   bool autostart_test_server_;
   base::HistogramTester histogram_tester_;
   std::unique_ptr<net::EmbeddedTestServer> https_src_server_;
-
-  DISALLOW_COPY_AND_ASSIGN(PrerenderInProcessBrowserTest);
 };
 
 // Makes |url| respond to requests with the contents of |file|, counting the
 // number that start in |counter|.
 void CreateCountingInterceptorOnIO(
     const GURL& url,
     const base::FilePath& file,
     const base::WeakPtr<RequestCounter>& counter);
 
 // Makes |url| respond to requests with the contents of |file|.
 void CreateMockInterceptorOnIO(const GURL& url, const base::FilePath& file);
 
 }  // namespace test_utils
 
 }  // namespace prerender
 
 #endif  // CHROME_BROWSER_PRERENDER_PRERENDER_TEST_UTILS_H_