Plumb network stack information about existence of cached copy

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/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/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_factory.h"
 
 using content::BrowserThread;
 using content::NavigationController;
 using content::URLRequestFailedJob;
 
 namespace {
 
 class ErrorPageTest : public InProcessBrowserTest {
@@ skipping 37 matching lines @@
 
   // Navigates forward in the history and waits for |num_navigations| to occur,
   // and the title to change to |expected_title|.
   void GoForwardAndWaitForTitle(const std::string& expected_title,
                                 int num_navigations) {
     NavigateHistoryAndWaitForTitle(expected_title,
                                    num_navigations,
                                    HISTORY_NAVIGATE_FORWARD);
   }
 
+  // Confirms that the javascript variable indicating whether or not we have
+  // a stale copy in the cache has been set to |expected|.
+  bool ProbeStaleCopyValue(bool expected) {
+    const char* js_cache_probe =
+        "(function () {\n"
+        "  if ('staleCopyInCache' in templateData) {\n"
+        "    domAutomationController.send(\n"
+        "      templateData.staleCopyInCache ? 'yes' : 'no');\n"
+        "  } else {\n"
+        "    domAutomationController.send('absent');\n"
+        "  }\n"
+        "})();";
+
+    std::string result;
+    bool ret =
+        content::ExecuteScriptAndExtractString(
+            browser()->tab_strip_model()->GetActiveWebContents(),
+            js_cache_probe,
+            &result);
+    EXPECT_TRUE(ret);
+    if (!ret)
+      return false;
+    EXPECT_EQ(expected ? "yes" : "no", result);
+    return ((expected ? "yes" : "no") == result);
+  }
+
  protected:
   virtual void SetUpOnMainThread() OVERRIDE {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&chrome_browser_net::SetUrlRequestMocksEnabled, true));
   }
 
   // Returns a GURL that results in a DNS error.
   GURL GetDnsErrorURL() const {
     return URLRequestFailedJob::GetMockHttpUrl(net::ERR_NAME_NOT_RESOLVED);
@@ skipping 19 matching lines @@
     } else {
       FAIL();
     }
     test_navigation_observer.Wait();
 
     EXPECT_EQ(title_watcher.WaitAndGetTitle(),
               base::ASCIIToUTF16(expected_title));
   }
 };
 
-
 class TestFailProvisionalLoadObserver : public content::WebContentsObserver {
  public:
   explicit TestFailProvisionalLoadObserver(content::WebContents* contents)
       : content::WebContentsObserver(contents) {}
   virtual ~TestFailProvisionalLoadObserver() {}
 
   // This method is invoked when the provisional load failed.
   virtual void DidFailProvisionalLoad(
       int64 frame_id,
       const base::string16& frame_unique_name,
       bool is_main_frame,
       const GURL& validated_url,
       int error_code,
       const base::string16& error_description,
       content::RenderViewHost* render_view_host) OVERRIDE {
     fail_url_ = validated_url;
   }
 
   const GURL& fail_url() const { return fail_url_; }
 
  private:
   GURL fail_url_;
 
   DISALLOW_COPY_AND_ASSIGN(TestFailProvisionalLoadObserver);
 };
 
+void InterceptNetworkTransactions(net::URLRequestContextGetter* getter,
+                                  net::Error error) {
+  DCHECK(content::BrowserThread::CurrentlyOn(BrowserThread::IO));
+  net::HttpCache* cache(
+      getter->GetURLRequestContext()->http_transaction_factory()->GetCache());
+  DCHECK(cache);
+  scoped_ptr<net::HttpTransactionFactory> factory(
+      new net::FailingHttpTransactionFactory(cache->GetSession(), error));
+  // Throw away old version; since this is a a browser test, we don't
+  // need to restore the old state.
+  cache->SetHttpNetworkTransactionFactoryForTesting(factory.Pass());
+}
+
 // See crbug.com/109669
 #if defined(USE_AURA) || defined(OS_WIN)
 #define MAYBE_DNSError_Basic DISABLED_DNSError_Basic
 #else
 #define MAYBE_DNSError_Basic DNSError_Basic
 #endif
 // Test that a DNS error occuring in the main frame redirects to an error page.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, MAYBE_DNSError_Basic) {
   // The first navigation should fail, and the second one should be the error
   // page.
@@ skipping 188 matching lines @@
 
 // Checks that the Link Doctor is not loaded when we receive an actual 404 page.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, Page404) {
   NavigateToURLAndWaitForTitle(
       content::URLRequestMockHTTPJob::GetMockUrl(
           base::FilePath(FILE_PATH_LITERAL("page404.html"))),
       "SUCCESS",
       1);
 }
 
+// Checks that when an error occurs, the stale cache status of the page
+// is correctly transferred.
+IN_PROC_BROWSER_TEST_F(ErrorPageTest, StaleCacheStatus) {
+  ASSERT_TRUE(test_server()->Start());
+  // Load cache with entry with "nocache" set, to create stale
+  // cache.
+  GURL test_url(test_server()->GetURL("files/nocache.html"));
+  NavigateToURLAndWaitForTitle(test_url, "Nocache Test Page", 1);
+
+  // Reload same URL after forcing an error from the the network layer;
+  // confirm that the error page is told the cached copy exists.
+  scoped_refptr<net::URLRequestContextGetter> url_request_context_getter =
+      browser()->profile()->GetRequestContext();
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&InterceptNetworkTransactions, url_request_context_getter,
+                 // Note that we can't use an error that'll invoke the link
+                 // doctor.  In normal network error conditions that would
+                 // work (because the link doctor fetch would also fail,
+                 // putting us back in the main offline path), but
+                 // SetUrlRequestMocksEnabled() has also specfied a link
+                 // doctor mock, which will be accessible because it
+                 // won't go through the network cache.
+                 net::ERR_FAILED));
+
+  ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
+      // With no link doctor load, there's only one navigation.
+      browser(), test_url, 1);
+  EXPECT_TRUE(ProbeStaleCopyValue(true));
+
+  // Clear the cache and reload the same URL; confirm the error page is told
+  // 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));
+}
+
 // 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 15 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AddressUnreachableProtocolHandler);
 };
 
 // A test fixture that returns ERR_ADDRESS_UNREACHABLE for all Link Doctor
 // requests.  ERR_NAME_NOT_RESOLVED is more typical, but need to use a different
 // error for the Link Doctor and the original page to validate the right page
 // is being displayed.
-class ErrorPageLinkDoctorFailTest : public InProcessBrowserTest {
+class ErrorPageLinkDoctorFailTest : public ErrorPageTest {
  public:
   // InProcessBrowserTest:
   virtual void SetUpOnMainThread() OVERRIDE {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&ErrorPageLinkDoctorFailTest::AddFilters));
   }
 
   virtual void CleanUpOnMainThread() OVERRIDE {
     BrowserThread::PostTask(
@@ skipping 35 matching lines @@
   // Verify that the expected error page is being displayed.  Do this by making
   // sure the original error code (ERR_NAME_NOT_RESOLVED) is displayed.
   bool result = false;
   EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
       browser()->tab_strip_model()->GetActiveWebContents(),
       GetTextContentContainsStringScript("ERR_NAME_NOT_RESOLVED"),
       &result));
   EXPECT_TRUE(result);
 }
 
+// Checks that when an error occurs and a link doctor load fails, the stale
+// cache status of the page is correctly transferred.  Most logic copied
+// from StaleCacheStatus above.
+IN_PROC_BROWSER_TEST_F(ErrorPageLinkDoctorFailTest,
+                       StaleCacheStatusFailedLinkDoctor) {
+  ASSERT_TRUE(test_server()->Start());
+  // Load cache with entry with "nocache" set, to create stale
+  // cache.
+  GURL test_url(test_server()->GetURL("files/nocache.html"));
+  NavigateToURLAndWaitForTitle(test_url, "Nocache Test Page", 1);
+
+  // Reload same URL after forcing an error from the the network layer;
+  // confirm that the error page is told the cached copy exists.
+  scoped_refptr<net::URLRequestContextGetter> url_request_context_getter =
+      browser()->profile()->GetRequestContext();
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&InterceptNetworkTransactions, url_request_context_getter,
+                 net::ERR_CONNECTION_FAILED));
+
+  ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
+      browser(), test_url, 2);
+  ProbeStaleCopyValue(true);
+
+  // Clear the cache and reload the same URL; confirm the error page is told
+  // 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, 2);
+  ProbeStaleCopyValue(false);
+}
+
 // A test fixture that simulates failing requests for an IDN domain name.
 class ErrorPageForIDNTest : public InProcessBrowserTest {
  public:
   // Target hostname in different forms.
   static const char kHostname[];
   static const char kHostnameJSUnicode[];
 
   // InProcessBrowserTest:
   virtual void SetUpOnMainThread() OVERRIDE {
     // Clear AcceptLanguages to force punycode decoding.
@@ skipping 39 matching lines @@
 
   bool result = false;
   EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
       browser()->tab_strip_model()->GetActiveWebContents(),
       GetTextContentContainsStringScript(kHostnameJSUnicode),
       &result));
   EXPECT_TRUE(result);
 }
 
 }  // namespace