Prerender: Disable prefetch if there's an appcache.

chrome/browser/prerender/prerender_nostate_prefetch_browsertest.cc

Index: chrome/browser/prerender/prerender_nostate_prefetch_browsertest.cc
diff --git a/chrome/browser/prerender/prerender_nostate_prefetch_browsertest.cc b/chrome/browser/prerender/prerender_nostate_prefetch_browsertest.cc
index 522c0a49777e85c4681f992bb05de5ce7dbb9f24..1ac70c55831f9cc7bae05a400a3b5858833060f4 100644
--- a/chrome/browser/prerender/prerender_nostate_prefetch_browsertest.cc
+++ b/chrome/browser/prerender/prerender_nostate_prefetch_browsertest.cc
@@ -5,8 +5,10 @@
 #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"
@@ -40,6 +42,8 @@ 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";
@@ -89,6 +93,15 @@ class NoStatePrefetchBrowserTest
                    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,
@@ -184,15 +197,10 @@ IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, PrefetchHistograms) {
 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);
 }
 
@@ -404,17 +412,13 @@ IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, SSLSubresourceError) {
   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.
@@ -602,4 +606,57 @@ IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, ServiceWorkerIntercept) {
   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