Support auto-reload on errors.

chrome/browser/errorpage_browsertest.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 "base/bind.h"
+#include "base/command_line.h"
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/net/url_request_mock_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "content/test/net/url_request_failed_job.h"
 #include "content/test/net/url_request_mock_http_job.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/http/failing_http_transaction_factory.h"
 #include "net/http/http_cache.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_filter.h"
+#include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_job_factory.h"
+#include "net/url_request/url_request_test_job.h"
+#include "net/url_request/url_request_test_util.h"
 
 using content::BrowserThread;
 using content::NavigationController;
 using content::URLRequestFailedJob;
+using net::TestJobInterceptor;

[mmenke, 2014/03/04 17:26:25]

Not used.

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+using net::URLRequestJobFactory;
+using net::URLRequestTestJob;
 
 namespace {
 
+// A protocol handler that fails a configurable number of requests, then
+// succeeds all requests after that, keeping count of failures and successes.
+class FailFirstNRequestsProtocolHandler
+    : public URLRequestJobFactory::ProtocolHandler {
+ public:
+  FailFirstNRequestsProtocolHandler(const GURL& url, int requests_to_fail)
+      : url_(url), requests_(0), failures_(0),
+        requests_to_fail_(requests_to_fail) {}
+  virtual ~FailFirstNRequestsProtocolHandler() {}
+
+  void AddUrlHandler() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    scoped_ptr<URLRequestJobFactory::ProtocolHandler> scoped_handler(this);
+    net::URLRequestFilter::GetInstance()->AddUrlProtocolHandler(url_,
+        scoped_handler.Pass());

[mmenke, 2014/03/04 17:26:25]

nit:  url_, should appear on next line.

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+  }
+
+  virtual net::URLRequestJob* MaybeCreateJob(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) OVERRIDE const {
+    DCHECK_EQ(request->url(), url_);

[mmenke, 2014/03/04 17:26:25]

nit:  Think url_ should go first, since that's closer to the the "expected"
value than the "actual" value.

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+    requests_++;
+    if (failures_ < requests_to_fail_) {
+      failures_++;
+      return new URLRequestFailedJob(request,
+                                     network_delegate,
+                                     net::ERR_CONNECTION_RESET);

[mmenke, 2014/03/04 17:26:25]

May want to comment somewhere that this error won't bring up the LinkDoctor.

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+    } else {
+      return new URLRequestTestJob(request, network_delegate,
+                                   URLRequestTestJob::test_headers(),
+                                   URLRequestTestJob::test_data_1(),
+                                   true);
+    }
+  }
+
+  int requests() const { return requests_; }
+  int failures() const { return failures_; }
+
+ private:
+  const GURL url_;
+  // these are mutable because MaybeCreateJob is const but we want this state
+  // for testing.

[mmenke, 2014/03/04 17:26:25]

nit:  Capitalize "these"

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+  mutable int requests_;
+  mutable int failures_;
+  int requests_to_fail_;
+};
+
 class ErrorPageTest : public InProcessBrowserTest {
  public:
   enum HistoryNavigationDirection {
     HISTORY_NAVIGATE_BACK,
     HISTORY_NAVIGATE_FORWARD,
   };
 
   // Navigates the active tab to a mock url created for the file at |file_path|.
   void NavigateToFileURL(const base::FilePath::StringType& file_path) {
     ui_test_utils::NavigateToURL(
@@ skipping 381 matching lines @@
   // that there is no cached copy.
   BrowsingDataRemover* remover =
       BrowsingDataRemover::CreateForUnboundedRange(browser()->profile());
   remover->Remove(BrowsingDataRemover::REMOVE_CACHE,
                   BrowsingDataHelper::UNPROTECTED_WEB);
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
       browser(), test_url, 1);
   EXPECT_TRUE(ProbeStaleCopyValue(false));
 }
 
+class ErrorPageAutoReloadTest : public InProcessBrowserTest {
+ public:
+  virtual void SetUpCommandLine(CommandLine* command_line) {

[mmenke, 2014/03/04 17:26:25]

OVERRIDE

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+    command_line->AppendSwitch(switches::kEnableOfflineAutoReload);
+  }
+
+  void InstallProtocolHandler(const GURL& url, int requests_to_fail) {
+    protocol_handler_ = new FailFirstNRequestsProtocolHandler(url,
+        requests_to_fail);

[mmenke, 2014/03/04 17:26:25]

nit:  Move "url" to next line.

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+    // Tests don't need to wait for this task to complete before using the
+    // filter; any requests that might be affected by it will end up in the IO
+    // thread's message loop after this posted task anyway.
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&ErrorPageAutoReloadTest::AddFilters,
+            base::Unretained(this)));

[mmenke, 2014/03/04 17:26:25]

nit:  Align base with the &

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+  }
+
+  void NavigateToURLAndWaitForTitle(const GURL& url,
+                                    const std::string& expected_title,
+                                    int num_navigations) {
+    content::TitleWatcher title_watcher(
+        browser()->tab_strip_model()->GetActiveWebContents(),
+        base::ASCIIToUTF16(expected_title));
+
+    ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
+        browser(), url, num_navigations);
+
+    EXPECT_EQ(base::ASCIIToUTF16(expected_title),
+              title_watcher.WaitAndGetTitle());
+  }
+
+  FailFirstNRequestsProtocolHandler* protocol_handler() {
+    return protocol_handler_;
+  }
+
+ private:
+  void AddFilters() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    protocol_handler_->AddUrlHandler();
+  }
+
+  void RemoveFilters() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    net::URLRequestFilter::GetInstance()->ClearHandlers();
+  }

[mmenke, 2014/03/04 17:26:25]

This is no longer called anywhere, so should get rid of it.  (I rather like the
idea of cleaning up like this, but almost no other tests do it, and should
probably be consistent).

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+
+  FailFirstNRequestsProtocolHandler* protocol_handler_;
+};
+
+IN_PROC_BROWSER_TEST_F(ErrorPageAutoReloadTest, AutoReload) {
+  GURL test_url("http://error.page.auto.reload");
+  const int kRequestsToFail = 2;
+  InstallProtocolHandler(test_url, kRequestsToFail);
+  NavigateToURLAndWaitForTitle(test_url, "Test One", kRequestsToFail + 1);
+  // Note that the protocol handler updates these variables on the IO thread,
+  // but we read them on the main thread. The requests have to be created (on
+  // the IO thread) before NavigateToURLAndWaitForTitle returns or this becomes
+  // racey.

[mmenke, 2014/03/04 17:26:25]

nit:  Don't use "we" in comments, due to ambiguity.  Can just use "we read them"
-> "they are read" or somesuch.

[Elly Fong-Jones, 2014/03/06 21:48:37]

Done.

+  EXPECT_EQ(kRequestsToFail, protocol_handler()->failures());
+  EXPECT_EQ(kRequestsToFail + 1, protocol_handler()->requests());
+}
+
 // Returns Javascript code that executes plain text search for the page.
 // Pass into content::ExecuteScriptAndExtractBool as |script| parameter.
 std::string GetTextContentContainsStringScript(
     const std::string& value_to_search) {
   return base::StringPrintf(
       "var textContent = document.body.textContent;"
       "var hasError = textContent.indexOf('%s') >= 0;"
       "domAutomationController.send(hasError);",
       value_to_search.c_str());
 }
@@ skipping 165 matching lines @@
 
   bool result = false;
   EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
       browser()->tab_strip_model()->GetActiveWebContents(),
       GetTextContentContainsStringScript(kHostnameJSUnicode),
       &result));
   EXPECT_TRUE(result);
 }
 
 }  // namespace