NoState Prefetch: nostate prefetch browser tests.

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 <functional>
+
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
+#include "base/test/histogram_tester.h"
 #include "chrome/browser/external_protocol/external_protocol_handler.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/safe_browsing/test_safe_browsing_service.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "components/safe_browsing_db/test_database_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/test/url_request/url_request_mock_http_job.h"
 #include "net/url_request/url_request_interceptor.h"
 #include "url/gurl.h"
 
@@ skipping 65 matching lines @@
 
   void OnCheckBrowseURLDone(const GURL& gurl, Client* client);
 
   std::unordered_map<std::string, safe_browsing::SBThreatType> bad_urls_;
   DISALLOW_COPY_AND_ASSIGN(FakeSafeBrowsingDatabaseManager);
 };
 
 // PrerenderContents that stops the UI message loop on DidStopLoading().
 class TestPrerenderContents : public PrerenderContents {
  public:
+  class DestroyObserver {
+   public:
+    virtual ~DestroyObserver();
+    virtual void OnDestroy(FinalStatus reason) = 0;
+  };
+
   TestPrerenderContents(PrerenderManager* prerender_manager,
                         Profile* profile,
                         const GURL& url,
                         const content::Referrer& referrer,
                         Origin origin,
                         FinalStatus expected_final_status);
 
   ~TestPrerenderContents() override;
 
   void RenderProcessGone(base::TerminationStatus status) override;
   bool CheckURL(const GURL& url) override;
 
   // For tests that open the prerender in a new background tab, the RenderView
   // will not have been made visible when the PrerenderContents is destroyed
   // even though it is used.
   void set_should_be_shown(bool value) { should_be_shown_ = value; }
 
   // For tests which do not know whether the prerender will be used.
   void set_skip_final_checks(bool value) { skip_final_checks_ = value; }
 
   FinalStatus expected_final_status() const { return expected_final_status_; }
 
+  // Will own the observer.
+  void AddDestroyObserver(std::unique_ptr<DestroyObserver> observer);
+
+  void Destroy(FinalStatus reason) override;
+
  private:
   void OnRenderViewHostCreated(
       content::RenderViewHost* new_render_view_host) override;
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override;
 
   FinalStatus expected_final_status_;
 
   // The RenderViewHost created for the prerender, if any.
   content::RenderViewHost* new_render_view_host_;
   // 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_;
+  std::vector<std::unique_ptr<DestroyObserver>> destroy_observers_;

[droger, 2016/09/20 10:57:20]

Use ObserverList instead (base/observer_list.h)

[mattcary, 2016/09/21 08:45:10]

thanks, but moot now.

 };
 
 // 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 final status, etc.
 class TestPrerender : public PrerenderContents::Observer,
                       public base::SupportsWeakPtr<TestPrerender> {
  public:
   TestPrerender();
   ~TestPrerender() override;
@@ skipping 27 matching lines @@
   int expected_number_of_loads_;
   std::unique_ptr<base::RunLoop> load_waiter_;
 
   base::RunLoop create_loop_;
   base::RunLoop start_loop_;
   base::RunLoop stop_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPrerender);
 };
 
+// Blocks until a TestPrerenderContents has been destroyed with the given final
+// status. Should be created with a TestPrerenderContents, and then
+// WaitForDestroy should be called and its return value checked.
+class DestructionWaiter {
+ public:
+  // Does not own the prerender_contents, which must outlive any call to
+  // WaitForDestroy().
+  DestructionWaiter(TestPrerenderContents* prerender_contents,
+                    FinalStatus expected_final_status);
+
+  // Returns true if the TestPrerenderContents was destroyed with the correct
+  // final status, or false otherwise. Note this also may hang if the contents
+  // is never destroyed (which will presumably cause the test to time out).
+  bool WaitForDestroy();
+
+ private:
+  class DestructionMarker : public TestPrerenderContents::DestroyObserver {
+   public:
+    // Does not on the waiter which must outlive the TestPrerenderContents.

[droger, 2016/09/20 10:57:20]

I don't understand the comment, maybe there is a word missing.

[mattcary, 2016/09/21 08:45:10]

Done. Only a letter missing, but an important one ;)

+    explicit DestructionMarker(DestructionWaiter* waiter);
+    void OnDestroy(FinalStatus reason) override;
+
+   private:
+    DestructionWaiter* waiter_;
+  };
+
+  // To be called by a DestructionMarker.
+  void MarkDestruction(FinalStatus reason);
+
+  base::RunLoop wait_loop_;
+  FinalStatus expected_final_status_;
+  bool saw_correct_status_;
+};
+
 // PrerenderManager that uses TestPrerenderContents.
 class TestPrerenderContentsFactory : public PrerenderContents::Factory {
  public:
   TestPrerenderContentsFactory();
 
   ~TestPrerenderContentsFactory() override;
 
   std::unique_ptr<TestPrerender> ExpectPrerenderContents(
       FinalStatus final_status);
 
@@ skipping 24 matching lines @@
   PrerenderInProcessBrowserTest();
 
   ~PrerenderInProcessBrowserTest() override;
 
   void SetUpCommandLine(base::CommandLine* command_line) override;
   void SetUpInProcessBrowserTestFixture() override;
   void TearDownInProcessBrowserTestFixture() override;
   void SetUpOnMainThread() override;
   content::SessionStorageNamespace* GetSessionStorageNamespace() const;
 
+  // Many of the file and server manipulation commands are fussy about paths
+  // being relative or absolute. This makes path absolute if it is not
+  // already. The path must not be empty.
+  std::string MakeAbsolute(const std::string& path);
+
   bool UrlIsInPrerenderManager(const std::string& html_file) const;
   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);
+
   ScopedVector<TestPrerender> PrerenderTestURL(
       const std::string& html_file,
       const std::vector<FinalStatus>& expected_final_status_queue,
       int expected_number_of_loads);
 
-  std::unique_ptr<TestPrerender> PrerenderTestURL(
-      const GURL& url,
-      FinalStatus expected_final_status,
-      int expected_number_of_loads);
+  // Set up an HTTPS server. The lambda passed in is run after the server is
+  // created but before Start() is called.
+  void UseHttpsSrcServer(std::function<void(net::EmbeddedTestServer*)> startup);
+  void UseHttpsSrcServer() {
+    UseHttpsSrcServer([](net::EmbeddedTestServer*) {});
+  }
+
+  // Returns the currently active server (see UseHttpsSrcServer).
+  net::EmbeddedTestServer* src_server() {
+    if (https_src_server_)
+      return https_src_server_.get();
+    return embedded_test_server();
+  }
 
   safe_browsing::TestSafeBrowsingServiceFactory* safe_browsing_factory() const {
     return safe_browsing_factory_.get();
   }
 
+  test_utils::FakeSafeBrowsingDatabaseManager*
+  GetFakeSafeBrowsingDatabaseManager() {
+    return static_cast<test_utils::FakeSafeBrowsingDatabaseManager*>(
+        safe_browsing_factory()
+            ->test_safe_browsing_service()
+            ->database_manager()
+            .get());
+  }
+
   TestPrerenderContentsFactory* prerender_contents_factory() const {
     return prerender_contents_factory_;
   }
 
   void set_autostart_test_server(bool value) { autostart_test_server_ = value; }
 
   void set_browser(Browser* browser) { explicitly_set_browser_ = browser; }
 
   Browser* current_browser() const {
     return explicitly_set_browser_ ? explicitly_set_browser_ : browser();
   }
 
+  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:
+  // 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.
+  ScopedVector<TestPrerender> NavigateWithPrerenders(

[droger, 2016/09/20 10:57:20]

same: std::vector<std::unique_ptr<>>

[mattcary, 2016/09/21 08:45:10]

This will be fixed when I tear out the scoped vector from the old test.

+      GURL loader_url,

[droger, 2016/09/20 10:57:20]

const GURL&

[mattcary, 2016/09/21 08:45:10]

Done.

+      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 ScopedVector<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_;
 };
 
 // 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_