Add PrerenderUnload browser test

chrome/browser/prerender/prerender_browsertest.cc

 // Copyright (c) 2011 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 <deque>
 
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
+#include "base/utf_string_conversions.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/in_process_browser_test.h"
 #include "chrome/test/ui_test_utils.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
+#include "content/browser/tab_contents/title_updated_details.h"
 #include "content/common/notification_service.h"
 #include "grit/generated_resources.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ui/base/l10n/l10n_util.h"
 
 // Prerender tests work as follows:
 //
 // A page with a prefetch link to the test page is loaded.  Once prerendered,
 // its Javascript function DidPrerenderPass() is called, which returns true if
@@ skipping 196 matching lines @@
                                      profile, url,
                                      referrer, number_of_loads_,
                                      expected_final_status);
   }
 
  private:
   int number_of_loads_;
   std::deque<FinalStatus> expected_final_status_queue_;
 };
 
+// Watches title changes on a tab, blocking until an expected change occurs.
+class TitleWatcher : public NotificationObserver {

[Paweł Hajdan Jr., 2011/06/09 09:23:15]

Could you move this to chrome/test/ui_test_utils? I'd suggest changing the name
to TabContentsTitleWatcher or TabTitleWatcher.

Please remember to move the implementation to the .cc file.

[cbentzel, 2011/06/09 15:29:21]

This seems like a pretty specific class, and doesn't warrant inclusion in
ui_test_utils. If you really want me to to move it there, I will.

[Paweł Hajdan Jr., 2011/06/09 19:24:12]

Yes please, for now it's not used by more tests but I'd prefer to have it in
ui_test_utils instead of duplicated for multiple tests. Many tests wait for
title to be updated, just in different, frequently non-optimal way.

+ public:
+  TitleWatcher(TabContents* tab_contents, const string16& expected_title)
+      : expected_tab_(tab_contents),
+        expected_title_(expected_title),
+        title_observed_(false),
+        quit_loop_on_observation_(false) {
+    EXPECT_TRUE(tab_contents != NULL);
+    notification_registrar_.Add(this,
+                                NotificationType::TAB_CONTENTS_TITLE_UPDATED,
+                                Source<TabContents>(tab_contents));
+  }
+
+  ~TitleWatcher() {
+  }
+
+  virtual void Observe(NotificationType type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details) OVERRIDE {
+    if (type != NotificationType::TAB_CONTENTS_TITLE_UPDATED)
+      return;
+
+    TabContents* source_contents = Source<TabContents>(source).ptr();
+    ASSERT_EQ(expected_tab_, source_contents);
+    if (source_contents->GetTitle() != expected_title_)
+      return;
+
+    title_observed_ = true;
+    if (quit_loop_on_observation_)
+      MessageLoopForUI::current()->Quit();
+  }
+
+  bool WaitForTitleChange() {

[Paweł Hajdan Jr., 2011/06/09 09:23:15]

nit: Add WARN_UNUSED_RESULT from base/compiler_specific.

[cbentzel, 2011/06/09 15:29:21]

Done.

+    if (title_observed_)
+      return true;
+    quit_loop_on_observation_ = true;
+    ui_test_utils::RunMessageLoop();
+    return title_observed_;
+  }
+
+ private:
+  TabContents* expected_tab_;
+  string16 expected_title_;
+  NotificationRegistrar notification_registrar_;
+  bool title_observed_;
+  bool quit_loop_on_observation_;

[Paweł Hajdan Jr., 2011/06/09 09:23:15]

nit: DISALLOW_COPY_AND_ASSIGN.

[cbentzel, 2011/06/09 15:29:21]

Done.

+};
+
 }  // namespace
 
 // A SafeBrowingService implementation that returns a fixed result for a given
 // URL.
 class FakeSafeBrowsingService :  public SafeBrowsingService {
  public:
   FakeSafeBrowsingService() :
       result_(SAFE) {}
 
   virtual ~FakeSafeBrowsingService() {}
@@ skipping 55 matching lines @@
  private:
   FakeSafeBrowsingService* most_recent_service_;
 };
 
 class PrerenderBrowserTest : public InProcessBrowserTest {
  public:
   PrerenderBrowserTest()
       : safe_browsing_factory_(new TestSafeBrowsingServiceFactory()),
         prerender_contents_factory_(NULL),
         use_https_src_server_(false),
-        call_javascript_(true) {
+        call_javascript_(true),
+        loader_path_("files/prerender/prerender_loader.html") {
     EnableDOMAutomation();
   }
 
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
     SafeBrowsingService::RegisterFactory(safe_browsing_factory_.get());
   }
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     command_line->AppendSwitchASCII(switches::kPrerender,
                                     switches::kPrerenderSwitchValueEnabled);
@@ skipping 129 matching lines @@
   PrerenderManager* prerender_manager() const {
     Profile* profile = browser()->GetSelectedTabContents()->profile();
     PrerenderManager* prerender_manager = profile->GetPrerenderManager();
     return prerender_manager;
   }
 
   FakeSafeBrowsingService* GetSafeBrowsingService() {
     return safe_browsing_factory_->most_recent_service();
   }
 
+  void set_loader_path(const std::string& path) {

[dominich, 2011/06/09 14:26:56]

Did you consider adding another PrerenderTestURL variant that takes this as a
parameter instead for consistency?

[cbentzel, 2011/06/09 15:29:21]

I did consider it, but it seemed like the combinatoric space was getting too
high at that point. 

+    loader_path_ = path;
+  }
+
  private:
   void PrerenderTestURLImpl(
       const GURL& url,
       const std::deque<FinalStatus>& expected_final_status_queue,
       int total_navigations) {
     dest_url_ = url;
 
     std::vector<net::TestServer::StringPair> replacement_text;
     replacement_text.push_back(
         make_pair("REPLACE_WITH_PRERENDER_URL", dest_url_.spec()));
     std::string replacement_path;
     ASSERT_TRUE(net::TestServer::GetFilePathWithReplacements(
-        "files/prerender/prerender_loader.html",
+        loader_path_,
         replacement_text,
         &replacement_path));
 
     net::TestServer* src_server = test_server();
     scoped_ptr<net::TestServer> https_src_server;
     if (use_https_src_server_) {
       https_src_server.reset(
           new net::TestServer(net::TestServer::TYPE_HTTPS,
                               FilePath(FILE_PATH_LITERAL("chrome/test/data"))));
       ASSERT_TRUE(https_src_server->Start());
@@ skipping 73 matching lines @@
           &display_test_result));
       EXPECT_TRUE(display_test_result);
     }
   }
 
   scoped_ptr<TestSafeBrowsingServiceFactory> safe_browsing_factory_;
   WaitForLoadPrerenderContentsFactory* prerender_contents_factory_;
   GURL dest_url_;
   bool use_https_src_server_;
   bool call_javascript_;
+  std::string loader_path_;
 };
 
 // Checks that a page is correctly prerendered in the case of a
 // <link rel=prerender> tag and then loaded into a tab in response to a
 // navigation.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPage) {
   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
@@ skipping 749 matching lines @@
 }
 
 // Checks that a local storage write will not cause prerender to fail.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderLocalStorageWrite) {
   PrerenderTestURL("files/prerender/prerender_localstorage_write.html",
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 }
 
+// Checks that when a prerendered page is swapped in to a referring page, the
+// unload handlers on the referring page are executed.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderUnload) {
+  set_loader_path("files/prerender/prerender_loader_with_unload.html");
+  PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
+  TabContents* tab_contents = browser()->GetSelectedTabContents();

[dominich, 2011/06/09 14:26:56]

nit: no need for this to be a local variable.

[cbentzel, 2011/06/09 15:29:21]

Done.

+  TitleWatcher title_watcher(tab_contents, ASCIIToUTF16("Unloaded"));
+  NavigateToDestURL();
+  EXPECT_TRUE(title_watcher.WaitForTitleChange());
+}
+
 }  // namespace prerender