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

content/browser/service_worker/service_worker_storage_unittest.cc

 // Copyright 2013 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 "content/browser/service_worker/service_worker_storage.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 
@@ skipping 560 matching lines @@
   std::vector<scoped_refptr<ServiceWorkerRegistration>> found_registrations;
   EXPECT_EQ(
       SERVICE_WORKER_ERROR_ABORT,
       GetRegistrationsForOrigin(kScope.GetOrigin(), &found_registrations));
 
   std::vector<ServiceWorkerRegistrationInfo> all_registrations;
   EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT,
             GetAllRegistrationsInfos(&all_registrations));
 
   scoped_refptr<ServiceWorkerRegistration> live_registration =
-      new ServiceWorkerRegistration(kScope, kRegistrationId,
-                                    context()->AsWeakPtr());
+      new ServiceWorkerRegistration(kScope, false /* use_cache */,
+                                    kRegistrationId, context()->AsWeakPtr());
   scoped_refptr<ServiceWorkerVersion> live_version = new ServiceWorkerVersion(
       live_registration.get(), kScript, kVersionId, context()->AsWeakPtr());
   EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT,
             StoreRegistration(live_registration, live_version));
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT, UpdateToActiveState(live_registration));
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT,
             DeleteRegistration(kRegistrationId, kScope.GetOrigin()));
 
@@ skipping 62 matching lines @@
   EXPECT_FALSE(found_registration.get());
 
   std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
   resources.push_back(
       ServiceWorkerDatabase::ResourceRecord(1, kResource1, kResource1Size));
   resources.push_back(
       ServiceWorkerDatabase::ResourceRecord(2, kResource2, kResource2Size));
 
   // Store something.
   scoped_refptr<ServiceWorkerRegistration> live_registration =
-      new ServiceWorkerRegistration(kScope, kRegistrationId,
-                                    context()->AsWeakPtr());
+      new ServiceWorkerRegistration(kScope, false /* use_cache */,
+                                    kRegistrationId, context()->AsWeakPtr());
   scoped_refptr<ServiceWorkerVersion> live_version = new ServiceWorkerVersion(
       live_registration.get(), kResource1, kVersionId, context()->AsWeakPtr());
   live_version->set_fetch_handler_existence(
       ServiceWorkerVersion::FetchHandlerExistence::EXISTS);
   live_version->SetStatus(ServiceWorkerVersion::INSTALLED);
   live_version->script_cache_map()->SetResources(resources);
   live_version->set_foreign_fetch_scopes(
       std::vector<GURL>(1, kForeignFetchScope));
   live_version->set_foreign_fetch_origins(
       std::vector<url::Origin>(1, kForeignFetchOrigin));
@@ skipping 106 matching lines @@
   found_registration->SetActiveVersion(temp_version);
   temp_version = NULL;
   EXPECT_EQ(SERVICE_WORKER_OK, UpdateToActiveState(found_registration));
   found_registration->set_last_update_check(kToday);
   UpdateLastUpdateCheckTime(found_registration.get());
 
   found_registration = NULL;
 
   // Trying to update a unstored registration to active should fail.
   scoped_refptr<ServiceWorkerRegistration> unstored_registration =
-      new ServiceWorkerRegistration(kScope, kRegistrationId + 1,
+      new ServiceWorkerRegistration(kScope, false /* use_cache */,
+                                    kRegistrationId + 1,
                                     context()->AsWeakPtr());
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             UpdateToActiveState(unstored_registration));
   unstored_registration = NULL;
 
   // The Find methods should return a registration with an active version
   // and the expected update time.
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
   ASSERT_TRUE(found_registration.get());
@@ skipping 29 matching lines @@
   const GURL kScope("http://www.test.not/scope/");
   const GURL kScript("http://www.test.not/script.js");
   const GURL kDocumentUrl("http://www.test.not/scope/document.html");
   const int64_t kRegistrationId = 0;
   const int64_t kVersionId = 0;
 
   scoped_refptr<ServiceWorkerRegistration> found_registration;
 
   // Create an unstored registration.
   scoped_refptr<ServiceWorkerRegistration> live_registration =
-      new ServiceWorkerRegistration(kScope, kRegistrationId,
-                                    context()->AsWeakPtr());
+      new ServiceWorkerRegistration(kScope, false /* use_cache */,
+                                    kRegistrationId, context()->AsWeakPtr());
   scoped_refptr<ServiceWorkerVersion> live_version = new ServiceWorkerVersion(
       live_registration.get(), kScript, kVersionId, context()->AsWeakPtr());
   live_version->SetStatus(ServiceWorkerVersion::INSTALLING);
   live_registration->SetWaitingVersion(live_version);
 
   // Should not be findable, including by GetAllRegistrationsInfos.
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForId(
                 kRegistrationId, kScope.GetOrigin(), &found_registration));
   EXPECT_FALSE(found_registration.get());
@@ skipping 106 matching lines @@
 TEST_F(ServiceWorkerStorageTest, StoreUserData) {
   const GURL kScope("http://www.test.not/scope/");
   const GURL kScript("http://www.test.not/script.js");
   const int64_t kRegistrationId = 0;
   const int64_t kVersionId = 0;
 
   LazyInitialize();
 
   // Store a registration.
   scoped_refptr<ServiceWorkerRegistration> live_registration =
-      new ServiceWorkerRegistration(kScope, kRegistrationId,
-                                    context()->AsWeakPtr());
+      new ServiceWorkerRegistration(kScope, false /* use_cache */,
+                                    kRegistrationId, context()->AsWeakPtr());
   scoped_refptr<ServiceWorkerVersion> live_version = new ServiceWorkerVersion(
       live_registration.get(), kScript, kVersionId, context()->AsWeakPtr());
   std::vector<ServiceWorkerDatabase::ResourceRecord> records;
   records.push_back(ServiceWorkerDatabase::ResourceRecord(
       1, live_version->script_url(), 100));
   live_version->script_cache_map()->SetResources(records);
   live_version->set_fetch_handler_existence(
       ServiceWorkerVersion::FetchHandlerExistence::EXISTS);
   live_version->SetStatus(ServiceWorkerVersion::INSTALLED);
   live_registration->SetWaitingVersion(live_version);
@@ skipping 157 matching lines @@
     version_id_ = storage()->NewVersionId();
     resource_id1_ = storage()->NewResourceId();
     resource_id2_ = storage()->NewResourceId();
     resource_id1_size_ = 239193;
     resource_id2_size_ = 59923;
 
     // Cons up a new registration+version with two script resources.
     RegistrationData data;
     data.registration_id = registration_id_;
     data.scope = scope_;
+    data.use_cache = false;
     data.script = script_;
     data.version_id = version_id_;
     data.is_active = false;
     std::vector<ResourceRecord> resources;
     resources.push_back(
         ResourceRecord(resource_id1_, script_, resource_id1_size_));
     resources.push_back(
         ResourceRecord(resource_id2_, import_, resource_id2_size_));
     registration_ = storage()->GetOrCreateRegistration(data, resources);
     registration_->waiting_version()->SetStatus(ServiceWorkerVersion::NEW);
@@ skipping 455 matching lines @@
 TEST_F(ServiceWorkerStorageTest, FindRegistration_LongestScopeMatch) {
   const GURL kDocumentUrl("http://www.example.com/scope/foo");
   scoped_refptr<ServiceWorkerRegistration> found_registration;
 
   // Registration for "/scope/".
   const GURL kScope1("http://www.example.com/scope/");
   const GURL kScript1("http://www.example.com/script1.js");
   const int64_t kRegistrationId1 = 1;
   const int64_t kVersionId1 = 1;
   scoped_refptr<ServiceWorkerRegistration> live_registration1 =
-      new ServiceWorkerRegistration(kScope1, kRegistrationId1,
-                                    context()->AsWeakPtr());
+      new ServiceWorkerRegistration(kScope1, false /* use_cache */,
+                                    kRegistrationId1, context()->AsWeakPtr());
   scoped_refptr<ServiceWorkerVersion> live_version1 = new ServiceWorkerVersion(
       live_registration1.get(), kScript1, kVersionId1, context()->AsWeakPtr());
   std::vector<ServiceWorkerDatabase::ResourceRecord> records1;
   records1.push_back(ServiceWorkerDatabase::ResourceRecord(
       1, live_version1->script_url(), 100));
   live_version1->script_cache_map()->SetResources(records1);
   live_version1->set_fetch_handler_existence(
       ServiceWorkerVersion::FetchHandlerExistence::EXISTS);
   live_version1->SetStatus(ServiceWorkerVersion::INSTALLED);
   live_registration1->SetWaitingVersion(live_version1);
 
   // Registration for "/scope/foo".
   const GURL kScope2("http://www.example.com/scope/foo");
   const GURL kScript2("http://www.example.com/script2.js");
   const int64_t kRegistrationId2 = 2;
   const int64_t kVersionId2 = 2;
   scoped_refptr<ServiceWorkerRegistration> live_registration2 =
-      new ServiceWorkerRegistration(kScope2, kRegistrationId2,
-                                    context()->AsWeakPtr());
+      new ServiceWorkerRegistration(kScope2, false /* use_cache */,
+                                    kRegistrationId2, context()->AsWeakPtr());
   scoped_refptr<ServiceWorkerVersion> live_version2 = new ServiceWorkerVersion(
       live_registration2.get(), kScript2, kVersionId2, context()->AsWeakPtr());
   std::vector<ServiceWorkerDatabase::ResourceRecord> records2;
   records2.push_back(ServiceWorkerDatabase::ResourceRecord(
       2, live_version2->script_url(), 100));
   live_version2->script_cache_map()->SetResources(records2);
   live_version2->set_fetch_handler_existence(
       ServiceWorkerVersion::FetchHandlerExistence::EXISTS);
   live_version2->SetStatus(ServiceWorkerVersion::INSTALLED);
   live_registration2->SetWaitingVersion(live_version2);
 
   // Registration for "/scope/foobar".
   const GURL kScope3("http://www.example.com/scope/foobar");
   const GURL kScript3("http://www.example.com/script3.js");
   const int64_t kRegistrationId3 = 3;
   const int64_t kVersionId3 = 3;
   scoped_refptr<ServiceWorkerRegistration> live_registration3 =
-      new ServiceWorkerRegistration(kScope3, kRegistrationId3,
-                                    context()->AsWeakPtr());
+      new ServiceWorkerRegistration(kScope3, false /* use_cache */,
+                                    kRegistrationId3, context()->AsWeakPtr());
   scoped_refptr<ServiceWorkerVersion> live_version3 = new ServiceWorkerVersion(
       live_registration3.get(), kScript3, kVersionId3, context()->AsWeakPtr());
   std::vector<ServiceWorkerDatabase::ResourceRecord> records3;
   records3.push_back(ServiceWorkerDatabase::ResourceRecord(
       3, live_version3->script_url(), 100));
   live_version3->script_cache_map()->SetResources(records3);
   live_version3->set_fetch_handler_existence(
       ServiceWorkerVersion::FetchHandlerExistence::EXISTS);
   live_version3->SetStatus(ServiceWorkerVersion::INSTALLED);
   live_registration3->SetWaitingVersion(live_version3);
@@ skipping 43 matching lines @@
 
 TEST_F(ServiceWorkerStorageDiskTest, OriginHasForeignFetchRegistrations) {
   LazyInitialize();
 
   // Registration 1 for http://www.example.com
   const GURL kScope1("http://www.example.com/scope/");
   const GURL kScript1("http://www.example.com/script1.js");
   const int64_t kRegistrationId1 = 1;
   const int64_t kVersionId1 = 1;
   scoped_refptr<ServiceWorkerRegistration> live_registration1 =
-      new ServiceWorkerRegistration(kScope1, kRegistrationId1,
-                                    context()->AsWeakPtr());
+      new ServiceWorkerRegistration(kScope1, false /* use_cache */,
+                                    kRegistrationId1, context()->AsWeakPtr());
   scoped_refptr<ServiceWorkerVersion> live_version1 = new ServiceWorkerVersion(
       live_registration1.get(), kScript1, kVersionId1, context()->AsWeakPtr());
   std::vector<ServiceWorkerDatabase::ResourceRecord> records1;
   records1.push_back(ServiceWorkerDatabase::ResourceRecord(
       1, live_version1->script_url(), 100));
   live_version1->script_cache_map()->SetResources(records1);
   live_version1->set_fetch_handler_existence(
       ServiceWorkerVersion::FetchHandlerExistence::EXISTS);
   live_version1->SetStatus(ServiceWorkerVersion::INSTALLED);
   live_version1->set_foreign_fetch_scopes(std::vector<GURL>(1, kScope1));
   live_registration1->SetWaitingVersion(live_version1);
 
   // Registration 2 for http://www.example.com
   const GURL kScope2("http://www.example.com/scope/foo");
   const GURL kScript2("http://www.example.com/script2.js");
   const int64_t kRegistrationId2 = 2;
   const int64_t kVersionId2 = 2;
   scoped_refptr<ServiceWorkerRegistration> live_registration2 =
-      new ServiceWorkerRegistration(kScope2, kRegistrationId2,
-                                    context()->AsWeakPtr());
+      new ServiceWorkerRegistration(kScope2, false /* use_cache */,
+                                    kRegistrationId2, context()->AsWeakPtr());
   scoped_refptr<ServiceWorkerVersion> live_version2 = new ServiceWorkerVersion(
       live_registration2.get(), kScript2, kVersionId2, context()->AsWeakPtr());
   std::vector<ServiceWorkerDatabase::ResourceRecord> records2;
   records2.push_back(ServiceWorkerDatabase::ResourceRecord(
       2, live_version2->script_url(), 100));
   live_version2->script_cache_map()->SetResources(records2);
   live_version2->set_fetch_handler_existence(
       ServiceWorkerVersion::FetchHandlerExistence::EXISTS);
   live_version2->SetStatus(ServiceWorkerVersion::INSTALLED);
   live_version2->set_foreign_fetch_scopes(std::vector<GURL>(1, kScope2));
   live_registration2->SetWaitingVersion(live_version2);
 
   // Registration for http://www.test.com
   const GURL kScope3("http://www.test.com/scope/foobar");
   const GURL kScript3("http://www.test.com/script3.js");
   const int64_t kRegistrationId3 = 3;
   const int64_t kVersionId3 = 3;
   scoped_refptr<ServiceWorkerRegistration> live_registration3 =
-      new ServiceWorkerRegistration(kScope3, kRegistrationId3,
-                                    context()->AsWeakPtr());
+      new ServiceWorkerRegistration(kScope3, false /* use_cache */,
+                                    kRegistrationId3, context()->AsWeakPtr());
   scoped_refptr<ServiceWorkerVersion> live_version3 = new ServiceWorkerVersion(
       live_registration3.get(), kScript3, kVersionId3, context()->AsWeakPtr());
   std::vector<ServiceWorkerDatabase::ResourceRecord> records3;
   records3.push_back(ServiceWorkerDatabase::ResourceRecord(
       3, live_version3->script_url(), 100));
   live_version3->script_cache_map()->SetResources(records3);
   live_version3->set_fetch_handler_existence(
       ServiceWorkerVersion::FetchHandlerExistence::EXISTS);
   live_version3->SetStatus(ServiceWorkerVersion::INSTALLED);
   live_registration3->SetWaitingVersion(live_version3);
@@ skipping 131 matching lines @@
   TestContentClient test_content_client_;
 };
 
 TEST_F(ServiceWorkerStorageOriginTrialsDiskTest, FromMainScript) {
   LazyInitialize();
   const GURL kScope("https://valid.example.com/scope");
   const GURL kScript("https://valid.example.com/script.js");
   const int64_t kRegistrationId = 1;
   const int64_t kVersionId = 1;
   scoped_refptr<ServiceWorkerRegistration> registration =
-      new ServiceWorkerRegistration(kScope, kRegistrationId,
-                                    context()->AsWeakPtr());
+      new ServiceWorkerRegistration(kScope, false /* use_cache */,
+                                    kRegistrationId, context()->AsWeakPtr());
   scoped_refptr<ServiceWorkerVersion> version = new ServiceWorkerVersion(
       registration.get(), kScript, kVersionId, context()->AsWeakPtr());
 
   net::HttpResponseInfo http_info;
   http_info.ssl_info.cert =
       net::ImportCertFromFile(net::GetTestCertsDirectory(), "ok_cert.pem");
   EXPECT_TRUE(http_info.ssl_info.is_valid());
   http_info.ssl_info.security_bits = 0x100;
   // SSL3 TLS_DHE_RSA_WITH_AES_256_CBC_SHA
   http_info.ssl_info.connection_status = 0x300039;
@@ skipping 106 matching lines @@
 
 // Tests loading a registration with a disabled navigation preload
 // state.
 TEST_F(ServiceWorkerStorageDiskTest, DisabledNavigationPreloadState) {
   LazyInitialize();
   const GURL kScope("https://valid.example.com/scope");
   const GURL kScript("https://valid.example.com/script.js");
   const int64_t kRegistrationId = 1;
   const int64_t kVersionId = 1;
   scoped_refptr<ServiceWorkerRegistration> registration =
-      new ServiceWorkerRegistration(kScope, kRegistrationId,
-                                    context()->AsWeakPtr());
+      new ServiceWorkerRegistration(kScope, false /* use_cache */,
+                                    kRegistrationId, context()->AsWeakPtr());
   scoped_refptr<ServiceWorkerVersion> version = new ServiceWorkerVersion(
       registration.get(), kScript, kVersionId, context()->AsWeakPtr());
 
   std::vector<ServiceWorkerDatabase::ResourceRecord> record;
   record.push_back(ServiceWorkerDatabase::ResourceRecord(1, kScript, 100));
   version->script_cache_map()->SetResources(record);
   version->set_fetch_handler_existence(
       ServiceWorkerVersion::FetchHandlerExistence::EXISTS);
   version->SetStatus(ServiceWorkerVersion::ACTIVATED);
   registration->SetActiveVersion(version);
@@ skipping 24 matching lines @@
 // Tests loading a registration with an enabled navigation preload state, as
 // well as a custom header value.
 TEST_F(ServiceWorkerStorageDiskTest, EnabledNavigationPreloadState) {
   LazyInitialize();
   const GURL kScope("https://valid.example.com/scope");
   const GURL kScript("https://valid.example.com/script.js");
   const std::string kHeaderValue("custom header value");
   const int64_t kRegistrationId = 1;
   const int64_t kVersionId = 1;
   scoped_refptr<ServiceWorkerRegistration> registration =
-      new ServiceWorkerRegistration(kScope, kRegistrationId,
-                                    context()->AsWeakPtr());
+      new ServiceWorkerRegistration(kScope, false /* use_cache */,
+                                    kRegistrationId, context()->AsWeakPtr());
   scoped_refptr<ServiceWorkerVersion> version = new ServiceWorkerVersion(
       registration.get(), kScript, kVersionId, context()->AsWeakPtr());
 
   std::vector<ServiceWorkerDatabase::ResourceRecord> record;
   record.push_back(ServiceWorkerDatabase::ResourceRecord(1, kScript, 100));
   version->script_cache_map()->SetResources(record);
   version->set_fetch_handler_existence(
       ServiceWorkerVersion::FetchHandlerExistence::EXISTS);
   version->SetStatus(ServiceWorkerVersion::ACTIVATED);
   registration->SetActiveVersion(version);
@@ skipping 16 matching lines @@
   EXPECT_TRUE(registration_state.enabled);
   EXPECT_EQ(kHeaderValue, registration_state.header);
   ASSERT_TRUE(found_registration->active_version());
   const NavigationPreloadState& state =
       found_registration->active_version()->navigation_preload_state();
   EXPECT_TRUE(state.enabled);
   EXPECT_EQ(kHeaderValue, state.header);
 }
 
 }  // namespace content