Prerender: Disable prefetch if there's an appcache.

chrome/browser/prerender/prerender_nostate_prefetch_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/command_line.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_split.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_scheduler/post_task.h"
+#include "base/test/simple_test_tick_clock.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/history/history_test_utils.h"
 #include "chrome/browser/prerender/prerender_handle.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/prerender/prerender_test_utils.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/task_manager/task_manager_browsertest_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
@@ skipping 13 matching lines @@
 #include "ui/base/l10n/l10n_util.h"
 
 using prerender::test_utils::DestructionWaiter;
 using prerender::test_utils::RequestCounter;
 using prerender::test_utils::TestPrerender;
 
 namespace prerender {
 
 // These URLs used for test resources must be relative with the exception of
 // |kPrefetchLoaderPath|.
+const char kPrefetchAppcache[] = "prerender/prefetch_appcache.html";
+const char kPrefetchAppcacheManifest[] = "prerender/appcache.manifest";
 const char kPrefetchImagePage[] = "prerender/prefetch_image.html";
 const char kPrefetchJpeg[] = "prerender/image.jpeg";
 const char kPrefetchLoaderPath[] = "/prerender/prefetch_loader.html";
 const char kPrefetchLoopPage[] = "prerender/prefetch_loop.html";
 const char kPrefetchMetaCSP[] = "prerender/prefetch_meta_csp.html";
 const char kPrefetchPage[] = "prerender/prefetch_page.html";
 const char kPrefetchPage2[] = "prerender/prefetch_page2.html";
 const char kPrefetchPng[] = "prerender/image.png";
 const char kPrefetchResponseHeaderCSP[] =
     "prerender/prefetch_response_csp.html";
@@ skipping 29 matching lines @@
                           const std::string& path_str,
                           RequestCounter* counter) {
     base::FilePath url_file = ui_test_utils::GetTestFilePath(
         base::FilePath(), base::FilePath::FromUTF8Unsafe(path_str));
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
         base::Bind(&prerender::test_utils::CreateCountingInterceptorOnIO, url,
                    url_file, counter->AsWeakPtr()));
   }
 
+  base::SimpleTestTickClock* OverridePrerenderManagerTimeTicks() {
+    auto clock = base::MakeUnique<base::SimpleTestTickClock>();
+    auto clock_ptr = clock.get();
+    // The default zero time causes the prerender manager to do strange things.
+    clock->Advance(base::TimeDelta::FromSeconds(1));
+    GetPrerenderManager()->SetTickClockForTesting(std::move(clock));
+    return clock_ptr;
+  }
+
  protected:
   std::unique_ptr<TestPrerender> PrefetchFromURL(
       const GURL& target_url,
       FinalStatus expected_final_status) {
     GURL loader_url = ServeLoaderURL(
         kPrefetchLoaderPath, "REPLACE_WITH_PREFETCH_URL", target_url, "");
     std::vector<FinalStatus> expected_final_status_queue(1,
                                                          expected_final_status);
     std::vector<std::unique_ptr<TestPrerender>> prerenders =
         NavigateWithPrerenders(loader_url, expected_final_status_queue);
@@ skipping 75 matching lines @@
   histogram_tester().ExpectTotalCount(
       "Prerender.websame_PrefetchTTFCP.Warm.Cacheable.Visible", 1);
   histogram_tester().ExpectTotalCount(
       "Prerender.websame_NoStatePrefetchResponseTypes", 2);
 }
 
 // Checks the prefetch of an img tag.
 IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, PrefetchImage) {
   RequestCounter image_counter;
   CountRequestFor(kPrefetchJpeg, &image_counter);
-  base::StringPairs replacement_text;
-  replacement_text.push_back(
-      std::make_pair("REPLACE_WITH_IMAGE_URL", MakeAbsolute(kPrefetchJpeg)));
-  std::string main_page_path;
-  net::test_server::GetFilePathWithReplacements(
-      kPrefetchImagePage, replacement_text, &main_page_path);
-  // Note CountRequestFor cannot be used on the main page as the test server
-  // must handling the image url replacement.
-  PrefetchFromFile(main_page_path, FINAL_STATUS_NOSTATE_PREFETCH_FINISHED);
+  GURL main_page_url =
+      GetURLWithReplacement(kPrefetchImagePage, "REPLACE_WITH_IMAGE_URL",
+                            MakeAbsolute(kPrefetchJpeg));
+  PrefetchFromURL(main_page_url, FINAL_STATUS_NOSTATE_PREFETCH_FINISHED);
   image_counter.WaitForCount(1);
 }
 
 // Checks that a cross-domain prefetching works correctly.
 IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, PrefetchCrossDomain) {
   static const std::string secondary_domain = "www.foo.com";
   host_resolver()->AddRule(secondary_domain, "127.0.0.1");
   GURL cross_domain_url(base::StringPrintf(
       "http://%s:%d/%s", secondary_domain.c_str(),
       embedded_test_server()->host_port_pair().port(), kPrefetchPage));
@@ skipping 191 matching lines @@
 IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, SSLSubresourceError) {
   // First confirm that the image loads as expected.
 
   // A separate HTTPS server is started for the subresource; src_server() is
   // non-HTTPS.
   net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
   https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_MISMATCHED_NAME);
   https_server.ServeFilesFromSourceDirectory("chrome/test/data");
   ASSERT_TRUE(https_server.Start());
   GURL https_url = https_server.GetURL("/prerender/image.jpeg");
-  base::StringPairs replacement_text;
-  replacement_text.push_back(
-      std::make_pair("REPLACE_WITH_IMAGE_URL", https_url.spec()));
-  std::string main_page_path;
-  net::test_server::GetFilePathWithReplacements(
-      kPrefetchImagePage, replacement_text, &main_page_path);
+  GURL main_page_url = GetURLWithReplacement(
+      kPrefetchImagePage, "REPLACE_WITH_IMAGE_URL", https_url.spec());
   RequestCounter script_counter;
   CountRequestFor(kPrefetchScript, &script_counter);
 
   std::unique_ptr<TestPrerender> prerender =
-      PrefetchFromFile(main_page_path, FINAL_STATUS_NOSTATE_PREFETCH_FINISHED);
+      PrefetchFromURL(main_page_url, FINAL_STATUS_NOSTATE_PREFETCH_FINISHED);
   // Checks that the presumed failure of the image load didn't affect the script
   // fetch. This assumes waiting for the script load is enough to see any error
   // from the image load.
   script_counter.WaitForCount(1);
 }
 
 IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, Loop) {
   RequestCounter script_counter;
   CountRequestFor(kPrefetchScript, &script_counter);
   RequestCounter main_counter;
@@ skipping 167 matching lines @@
 
   // The SW intercepts kPrefetchPage and replaces it with a body that contains
   // an <img> tage for kPrefetchPng. This verifies that the SW ran correctly by
   // observing the fetch of the image.
   RequestCounter image_counter;
   CountRequestFor(kPrefetchPng, &image_counter);
   PrefetchFromFile(kPrefetchPage, FINAL_STATUS_NOSTATE_PREFETCH_FINISHED);
   image_counter.WaitForCount(1);
 }
 
+// Checks that prefetching does not happen if an appcache is mentioned in the
+// html tag.
+IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, AppCacheHtml) {
+  RequestCounter image_counter;
+  CountRequestFor(kPrefetchPng, &image_counter);
+  // While the prefetch stops when it sees the AppCache manifest, from the point
+  // of view of the prerender manager the prefetch stops normally.
+  PrefetchFromFile(kPrefetchAppcache, FINAL_STATUS_NOSTATE_PREFETCH_FINISHED);
+  // The prefetch should have been canceled before the image in
+  // kPrefetchAppcache is loaded.
+  image_counter.WaitForCount(0);
+}
+
+// If an AppCache manifest exists but is not mentioned explicitly, prefetch will
+// continue. The page should be fetched from the appcache.

[droger, 2017/01/18 13:59:49]

I'm a bit confused, mostly because I am not familiar with AppCache.

What I see here is that the AppCache here is used even though the renderer skips
the AppCache initialization. So it seems the initialization is not necessary
here.

However, in the case from previous test, the AppCache would not be used because
of the missing initialization.

What is not quite clear to me, is in which cases AppCache works without being
initialized, and if we can really rely on this kind of behavior. There may be
other events that make the initialization necessary (such as maybe restarting
Chrome for exemple).


Maybe it's ok if the implementation is a bit hacky though, since AppCache is
deprecated. So if there is no easy way to get clear answers or no alternative, I
guess this could be good enough.

[mattcary, 2017/01/18 14:06:03]

Discussed somewhat offline.

AFAIU the reason for the AppCacheHtml is because the manifest present in the
file isn't processed by the AppCache (because the render side part of that isn't
initialized yet). 

In AppCacheRegistered, the AppCache is already initialized by the page that
loaded the manifest in the first place.

Offline you raised a good point about whether this still works if the manifest
is loaded and everything cached, then chrome is quit and restarted, and the
prefetch is the first thing that happens. I'm digging into that now.

+IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, AppCacheRegistered) {
+  base::TimeTicks current_time = GetPrerenderManager()->GetCurrentTimeTicks();
+  auto* clock = OverridePrerenderManagerTimeTicks();
+  // Some navigations have already occurred in test setup. In order to track
+  // duplicate prefetches correctly the test clock needs to be beyond those
+  // navigations.
+  clock->SetNowTicks(current_time);
+  clock->Advance(base::TimeDelta::FromSeconds(600));
+
+  // Fill manifest with kPrefetchPage so that it is cached without explicitly
+  // listing a manifest.
+  GURL prefetch_page_url = src_server()->GetURL(MakeAbsolute(kPrefetchPage));
+  GURL manifest_url = GetURLWithReplacement(
+      kPrefetchAppcacheManifest, "REPLACE_WITH_URL", prefetch_page_url.spec());
+
+  GURL appcache_page_url = GetURLWithReplacement(
+      kPrefetchAppcache, "REPLACE_WITH_MANIFEST", manifest_url.spec());
+
+  // Load the page into the appcache.
+  ui_test_utils::NavigateToURL(current_browser(), appcache_page_url);
+  // Load the prefetch page so it can be cached.
+  ui_test_utils::NavigateToURL(current_browser(), prefetch_page_url);
+
+  // If a page is prefetch shortly after being loading, the prefetch is
+  // canceled. Advancing the clock prevents the cancelation.
+  clock->Advance(base::TimeDelta::FromSeconds(6000));
+
+  RequestCounter page_counter;
+  CountRequestFor(kPrefetchPage, &page_counter);
+  RequestCounter script_counter;
+  CountRequestFor(kPrefetchScript, &script_counter);
+  PrefetchFromURL(prefetch_page_url, FINAL_STATUS_NOSTATE_PREFETCH_FINISHED);
+  // The script is fetched from the network, but the prefetch page is
+  // intercepted by the AppCache and the RequestCounter will never see it.
+  script_counter.WaitForCount(1);
+  page_counter.WaitForCount(0);
+}
+
 }  // namespace prerender