Implement updateViaCache flag and no-cache by default for main service worker scripts

content/browser/service_worker/service_worker_browsertest.cc

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <utility>
@@ skipping 1390 matching lines @@
   content_browser_client.set_data_saver_enabled(true);
   ContentBrowserClient* old_client =
       SetBrowserClientForTesting(&content_browser_client);
   shell()->web_contents()->GetRenderViewHost()->OnWebkitPreferencesChanged();
   scoped_refptr<WorkerActivatedObserver> observer =
       new WorkerActivatedObserver(wrapper());
   observer->Init();
   public_context()->RegisterServiceWorker(
       embedded_test_server()->GetURL(kPageUrl),
       embedded_test_server()->GetURL(kWorkerUrl),
+      blink::WebServiceWorkerUpdateViaCache::kImports,
       base::Bind(&ExpectResultAndRun, true, base::Bind(&base::DoNothing)));
   observer->Wait();
 
   const base::string16 title1 = base::ASCIIToUTF16("save-data=on");
   TitleWatcher title_watcher1(shell()->web_contents(), title1);
   NavigateToURL(shell(), embedded_test_server()->GetURL(kPageUrl));
   EXPECT_EQ(title1, title_watcher1.WaitAndGetTitle());
 
   SetBrowserClientForTesting(old_client);
   shell()->Close();
@@ skipping 22 matching lines @@
   content_browser_client.set_data_saver_enabled(true);
   ContentBrowserClient* old_client =
       SetBrowserClientForTesting(&content_browser_client);
   shell()->web_contents()->GetRenderViewHost()->OnWebkitPreferencesChanged();
   scoped_refptr<WorkerActivatedObserver> observer =
       new WorkerActivatedObserver(wrapper());
   observer->Init();
   public_context()->RegisterServiceWorker(
       embedded_test_server()->GetURL(kPageUrl),
       embedded_test_server()->GetURL(kWorkerUrl),
+      blink::WebServiceWorkerUpdateViaCache::kImports,
       base::Bind(&ExpectResultAndRun, true, base::Bind(&base::DoNothing)));
   observer->Wait();
 
   const base::string16 title = base::ASCIIToUTF16("PASS");
   TitleWatcher title_watcher(shell()->web_contents(), title);
   NavigateToURL(shell(),
                 embedded_test_server()->GetURL(base::StringPrintf(
                     "%s?%s", kPageUrl,
                     cross_origin_server.GetURL("/cross_origin_request.html")
                         .spec()
@@ skipping 23 matching lines @@
       new WorkerActivatedObserver(wrapper());
   observer->Init();
 
   embedded_test_server()->RegisterRequestHandler(
       base::Bind(&VerifySaveDataHeaderInRequest));
   StartServerAndNavigateToSetup();
 
   public_context()->RegisterServiceWorker(
       embedded_test_server()->GetURL(kPageUrl),
       embedded_test_server()->GetURL(kWorkerUrl),
+      blink::WebServiceWorkerUpdateViaCache::kImports,
       base::Bind(&ExpectResultAndRun, true, base::Bind(&base::DoNothing)));
   observer->Wait();
 
   NavigateToURLBlockUntilNavigationsComplete(
       shell(), embedded_test_server()->GetURL(kPageUrl), 1);
 
   SetBrowserClientForTesting(old_client);
   shell()->Close();
 
   base::RunLoop run_loop;
   public_context()->UnregisterServiceWorker(
       embedded_test_server()->GetURL(kPageUrl),
       base::Bind(&ExpectResultAndRun, true, run_loop.QuitClosure()));
   run_loop.Run();
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerBrowserTest, Reload) {
   StartServerAndNavigateToSetup();
   const char kPageUrl[] = "/service_worker/reload.html";
   const char kWorkerUrl[] = "/service_worker/fetch_event_reload.js";
   scoped_refptr<WorkerActivatedObserver> observer =
       new WorkerActivatedObserver(wrapper());
   observer->Init();
   public_context()->RegisterServiceWorker(
       embedded_test_server()->GetURL(kPageUrl),
       embedded_test_server()->GetURL(kWorkerUrl),
+      blink::WebServiceWorkerUpdateViaCache::kImports,
       base::Bind(&ExpectResultAndRun, true, base::Bind(&base::DoNothing)));
   observer->Wait();
 
   const base::string16 title1 = base::ASCIIToUTF16("reload=false");
   TitleWatcher title_watcher1(shell()->web_contents(), title1);
   NavigateToURL(shell(), embedded_test_server()->GetURL(kPageUrl));
   EXPECT_EQ(title1, title_watcher1.WaitAndGetTitle());
 
   const base::string16 title2 = base::ASCIIToUTF16("reload=true");
   TitleWatcher title_watcher2(shell()->web_contents(), title2);
@@ skipping 53 matching lines @@
     callback.Run(HeaderInterceptorResult::KILL);
   }
 
   void SetupForNavigationPreloadTest(const GURL& scope,
                                      const GURL& worker_url) {
     scoped_refptr<WorkerActivatedObserver> observer =
         new WorkerActivatedObserver(wrapper());
     observer->Init();
 
     public_context()->RegisterServiceWorker(
-        scope, worker_url,
+        scope, worker_url, blink::WebServiceWorkerUpdateViaCache::kImports,
         base::Bind(&ExpectResultAndRun, true, base::Bind(&base::DoNothing)));
     observer->Wait();
   }
 
   std::string LoadNavigationPreloadTestPage(const GURL& page_url,
                                             const GURL& worker_url,
                                             const char* expected_result) {
     RegisterMonitorRequestHandler();
     StartServerAndNavigateToSetup();
     SetupForNavigationPreloadTest(page_url, worker_url);
@@ skipping 684 matching lines @@
   const char kPageUrl[] = "/service_worker/fetch_event_blob.html";
   const char kWorkerUrl[] = "/service_worker/fetch_event_blob.js";
   net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
   https_server.ServeFilesFromSourceDirectory("content/test/data");
   ASSERT_TRUE(https_server.Start());
 
   scoped_refptr<WorkerActivatedObserver> observer =
       new WorkerActivatedObserver(wrapper());
   observer->Init();
   public_context()->RegisterServiceWorker(
-      https_server.GetURL(kPageUrl),
-      https_server.GetURL(kWorkerUrl),
+      https_server.GetURL(kPageUrl), https_server.GetURL(kWorkerUrl),
+      blink::WebServiceWorkerUpdateViaCache::kImports,
       base::Bind(&ExpectResultAndRun, true, base::Bind(&base::DoNothing)));
   observer->Wait();
 
   const base::string16 title = base::ASCIIToUTF16("Title");
   TitleWatcher title_watcher(shell()->web_contents(), title);
   NavigateToURL(shell(), https_server.GetURL(kPageUrl));
   EXPECT_EQ(title, title_watcher.WaitAndGetTitle());
   NavigationEntry* entry =
       shell()->web_contents()->GetController().GetVisibleEntry();
   EXPECT_TRUE(entry->GetSSL().initialized);
@@ skipping 16 matching lines @@
                        ResponseFromHTTPServiceWorkerIsNotMarkedAsSecure) {
   StartServerAndNavigateToSetup();
   const char kPageUrl[] = "/service_worker/fetch_event_blob.html";
   const char kWorkerUrl[] = "/service_worker/fetch_event_blob.js";
   scoped_refptr<WorkerActivatedObserver> observer =
       new WorkerActivatedObserver(wrapper());
   observer->Init();
   public_context()->RegisterServiceWorker(
       embedded_test_server()->GetURL(kPageUrl),
       embedded_test_server()->GetURL(kWorkerUrl),
+      blink::WebServiceWorkerUpdateViaCache::kImports,
       base::Bind(&ExpectResultAndRun, true, base::Bind(&base::DoNothing)));
   observer->Wait();
 
   const base::string16 title = base::ASCIIToUTF16("Title");
   TitleWatcher title_watcher(shell()->web_contents(), title);
   NavigateToURL(shell(), embedded_test_server()->GetURL(kPageUrl));
   EXPECT_EQ(title, title_watcher.WaitAndGetTitle());
   NavigationEntry* entry =
       shell()->web_contents()->GetController().GetVisibleEntry();
   EXPECT_TRUE(entry->GetSSL().initialized);
@@ skipping 93 matching lines @@
         base::Bind(&ExpectResultAndRun, false, run_loop.QuitClosure()));
     run_loop.Run();
   }
 
   // If we use a worker URL that doesn't exist, registration fails.
   {
     base::RunLoop run_loop;
     public_context()->RegisterServiceWorker(
         embedded_test_server()->GetURL(kScope),
         embedded_test_server()->GetURL("/does/not/exist"),
+        blink::WebServiceWorkerUpdateViaCache::kImports,
         base::Bind(&ExpectResultAndRun, false, run_loop.QuitClosure()));
     run_loop.Run();
   }
   EXPECT_EQ(0, CountRenderProcessHosts());
 
   // Register returns when the promise would be resolved.
   {
     base::RunLoop run_loop;
     public_context()->RegisterServiceWorker(
         embedded_test_server()->GetURL(kScope),
         embedded_test_server()->GetURL(kWorkerUrl),
+        blink::WebServiceWorkerUpdateViaCache::kImports,
         base::Bind(&ExpectResultAndRun, true, run_loop.QuitClosure()));
     run_loop.Run();
   }
   EXPECT_EQ(1, CountRenderProcessHosts());
 
   // Registering again should succeed, although the algo still
   // might not be complete.
   {
     base::RunLoop run_loop;
     public_context()->RegisterServiceWorker(
         embedded_test_server()->GetURL(kScope),
         embedded_test_server()->GetURL(kWorkerUrl),
+        blink::WebServiceWorkerUpdateViaCache::kImports,
         base::Bind(&ExpectResultAndRun, true, run_loop.QuitClosure()));
     run_loop.Run();
   }
 
   // The registration algo might not be far enough along to have
   // stored the registration data, so it may not be findable
   // at this point.
 
   // Unregistering something should return true.
   {
@@ skipping 287 matching lines @@
   static const std::string kScriptUrl;
   static const int kV8CacheTimeStampDataSize;
 
   void RegisterAndActivateServiceWorker() {
     scoped_refptr<WorkerActivatedObserver> observer =
         new WorkerActivatedObserver(wrapper());
     observer->Init();
     public_context()->RegisterServiceWorker(
         embedded_test_server()->GetURL(kPageUrl),
         embedded_test_server()->GetURL(kWorkerUrl),
+        blink::WebServiceWorkerUpdateViaCache::kImports,
         base::Bind(&ExpectResultAndRun, true, base::Bind(&base::DoNothing)));
     observer->Wait();
   }
 
   void NavigateToTestPage() {
     const base::string16 title =
         base::ASCIIToUTF16("Title was changed by the script.");
     TitleWatcher title_watcher(shell()->web_contents(), title);
     NavigateToURL(shell(), embedded_test_server()->GetURL(kPageUrl));
     EXPECT_EQ(title, title_watcher.WaitAndGetTitle());
@@ skipping 118 matching lines @@
     ServiceWorkerBrowserTest::SetUpOnMainThread();
   }
 
   void RegisterServiceWorkerOnCrossOriginServer(const std::string& scope,
                                                 const std::string& script) {
     scoped_refptr<WorkerActivatedObserver> observer =
         new WorkerActivatedObserver(wrapper());
     observer->Init();
     public_context()->RegisterServiceWorker(
         cross_origin_server_.GetURL(scope), cross_origin_server_.GetURL(script),
+        blink::WebServiceWorkerUpdateViaCache::kImports,
         base::Bind(&ExpectResultAndRun, true, base::Bind(&base::DoNothing)));
     observer->Wait();
   }
 
   void RunTestWithCrossOriginURL(const std::string& test_page,
                                  const std::string& cross_origin_url) {
     const base::string16 title = base::ASCIIToUTF16("PASS");
     TitleWatcher title_watcher(shell()->web_contents(), title);
     NavigateToURL(shell(),
                   embedded_test_server()->GetURL(
@@ skipping 36 matching lines @@
 IN_PROC_BROWSER_TEST_F(ServiceWorkerDisableWebSecurityTest, UpdateNoCrash) {
   StartServerAndNavigateToSetup();
   const char kPageUrl[] = "/service_worker/disable_web_security_update.html";
   const char kScopeUrl[] = "/service_worker/scope/";
   const char kWorkerUrl[] = "/service_worker/fetch_event_blob.js";
   RegisterServiceWorkerOnCrossOriginServer(kScopeUrl, kWorkerUrl);
   RunTestWithCrossOriginURL(kPageUrl, kScopeUrl);
 }
 
 }  // namespace content