Eliminate network fallback from ServiceWorkerContextRequestHandler.

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 516 matching lines @@
         BrowserThread::IO, FROM_HERE,
         base::Bind(&self::StopOnIOThread, base::Unretained(this),
                    stop_run_loop.QuitClosure(), &status));
     stop_run_loop.Run();
     ASSERT_EQ(SERVICE_WORKER_OK, status);
   }
 
   void ActivateTestHelper(
       const std::string& worker_url,
       ServiceWorkerStatusCode expected_status) {
-    RunOnIOThread(base::Bind(&self::SetUpRegistrationOnIOThread,
-                             base::Unretained(this), worker_url));
     ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
     base::RunLoop run_loop;
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&self::ActivateOnIOThread, base::Unretained(this),
                    run_loop.QuitClosure(), &status));
     run_loop.Run();
     ASSERT_EQ(expected_status, status);
   }
 
@@ skipping 219 matching lines @@
     ServiceWorkerVersion* version =
         wrapper()->context()->GetLiveVersion(version_id);
     wrapper()->context()->storage()->StoreRegistration(
         registration_.get(), version,
         CreateReceiver(BrowserThread::UI, done, result));
   }
 
   void ActivateOnIOThread(const base::Closure& done,
                           ServiceWorkerStatusCode* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    version_->set_fetch_handler_existence(
-        ServiceWorkerVersion::FetchHandlerExistence::EXISTS);
-    version_->SetMainScriptHttpResponseInfo(CreateHttpResponseInfo());
     version_->SetStatus(ServiceWorkerVersion::ACTIVATING);
     registration_->SetActiveVersion(version_.get());
     version_->RunAfterStartWorker(
         ServiceWorkerMetrics::EventType::ACTIVATE,
         base::Bind(&self::DispatchActivateEventOnIOThread,
                    base::Unretained(this), done, result),
         CreateReceiver(BrowserThread::UI, done, result));
   }
 
   void DispatchActivateEventOnIOThread(const base::Closure& done,
@@ skipping 137 matching lines @@
                            base::Unretained(this), registration_->id()));
   FindRegistrationForId(registration_->id(),
                         registration_->pattern().GetOrigin(),
                         SERVICE_WORKER_ERROR_NOT_FOUND);
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
                        ReadResourceFailure_WaitingWorker) {
   StartServerAndNavigateToSetup();
   // Create a registration and active version.
-  RunOnIOThread(base::Bind(&self::SetUpRegistrationOnIOThread,
-                           base::Unretained(this),
-                           "/service_worker/worker.js"));
-  base::RunLoop activate_run_loop;
-  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&self::ActivateOnIOThread, base::Unretained(this),
-                 activate_run_loop.QuitClosure(), &status));
-  activate_run_loop.Run();
-  EXPECT_EQ(SERVICE_WORKER_OK, status);
+  InstallTestHelper("/service_worker/worker.js", SERVICE_WORKER_OK);
+  ActivateTestHelper("/service_worker/worker.js", SERVICE_WORKER_OK);
   ASSERT_TRUE(registration_->active_version());
 
   // Give the version a controllee.
   RunOnIOThread(
       base::Bind(&self::AddControlleeOnIOThread, base::Unretained(this)));
 
   // Add a non-existent resource to the version.
-  std::vector<ServiceWorkerDatabase::ResourceRecord> records;
-  records.push_back(
-      ServiceWorkerDatabase::ResourceRecord(30, version_->script_url(), 100));
-  version_->script_cache_map()->SetResources(records);
+  version_->script_cache_map()->resource_map_[version_->script_url()] =
+      ServiceWorkerDatabase::ResourceRecord(30, version_->script_url(), 100);
 
   // Make a waiting version and store it.
   RunOnIOThread(base::Bind(&self::AddWaitingWorkerOnIOThread,
                            base::Unretained(this),
                            "/service_worker/worker.js"));
+  std::vector<ServiceWorkerDatabase::ResourceRecord> records = {
+      ServiceWorkerDatabase::ResourceRecord(31, version_->script_url(), 100)};
   registration_->waiting_version()->script_cache_map()->SetResources(records);
   StoreRegistration(registration_->waiting_version()->version_id(),
                     SERVICE_WORKER_OK);
 
   // Start the broken worker. We'll fail to read from disk and the worker should
   // be doomed.
   StopWorker(SERVICE_WORKER_OK);  // in case it's already running
   StartWorker(SERVICE_WORKER_ERROR_DISK_CACHE);
   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, version_->status());
 
@@ skipping 40 matching lines @@
                        ServiceWorkerScriptHeader) {
   embedded_test_server()->RegisterRequestHandler(
       base::Bind(&VerifyServiceWorkerHeaderInRequest));
   StartServerAndNavigateToSetup();
   InstallTestHelper("/service_worker/generated_sw.js", SERVICE_WORKER_OK);
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
                        Activate_NoEventListener) {
   StartServerAndNavigateToSetup();
+  InstallTestHelper("/service_worker/worker.js", SERVICE_WORKER_OK);
   ActivateTestHelper("/service_worker/worker.js", SERVICE_WORKER_OK);
   ASSERT_EQ(ServiceWorkerVersion::ACTIVATING, version_->status());
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, Activate_Rejected) {
   StartServerAndNavigateToSetup();
+  InstallTestHelper("/service_worker/worker_activate_rejected.js",
+                    SERVICE_WORKER_OK);
   ActivateTestHelper("/service_worker/worker_activate_rejected.js",
                      SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED);
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
                        InstallWithWaitUntil_Rejected) {
   StartServerAndNavigateToSetup();
   InstallTestHelper("/service_worker/worker_install_rejected.js",
                     SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED);
 }
@@ skipping 116 matching lines @@
   // Terminating a worker, even one in an infinite loop, is treated as if
   // waitUntil was rejected in the renderer code.
   EXPECT_EQ(SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED, status);
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, FetchEvent_Response) {
   StartServerAndNavigateToSetup();
   ServiceWorkerFetchEventResult result;
   ServiceWorkerResponse response;
   std::unique_ptr<storage::BlobDataHandle> blob_data_handle;
+  InstallTestHelper("/service_worker/fetch_event.js", SERVICE_WORKER_OK);
   ActivateTestHelper("/service_worker/fetch_event.js", SERVICE_WORKER_OK);
 
   FetchOnRegisteredWorker(&result, &response, &blob_data_handle);
   ASSERT_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, result);
   EXPECT_EQ(301, response.status_code);
   EXPECT_EQ("Moved Permanently", response.status_text);
   ServiceWorkerHeaderMap expected_headers;
   expected_headers["content-language"] = "fi";
   expected_headers["content-type"] = "text/html; charset=UTF-8";
   EXPECT_EQ(expected_headers, response.headers);
 
   std::string body;
   RunOnIOThread(
       base::Bind(&ReadResponseBody,
                  &body, base::Owned(blob_data_handle.release())));
   EXPECT_EQ("This resource is gone. Gone, gone, gone.", body);
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
                        FetchEvent_ResponseViaCache) {
   StartServerAndNavigateToSetup();
   ServiceWorkerFetchEventResult result;
   ServiceWorkerResponse response1;
   ServiceWorkerResponse response2;
   std::unique_ptr<storage::BlobDataHandle> blob_data_handle;
   const base::Time start_time(base::Time::Now());
+  InstallTestHelper("/service_worker/fetch_event_response_via_cache.js",
+                    SERVICE_WORKER_OK);
   ActivateTestHelper("/service_worker/fetch_event_response_via_cache.js",
                      SERVICE_WORKER_OK);
 
   FetchOnRegisteredWorker(&result, &response1, &blob_data_handle);
   ASSERT_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, result);
   EXPECT_EQ(200, response1.status_code);
   EXPECT_EQ("OK", response1.status_text);
   EXPECT_TRUE(response1.response_time >= start_time);
   EXPECT_FALSE(response1.is_in_cache_storage);
   EXPECT_EQ(std::string(), response2.cache_storage_cache_name);
 
   FetchOnRegisteredWorker(&result, &response2, &blob_data_handle);
   ASSERT_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, result);
   EXPECT_EQ(200, response2.status_code);
   EXPECT_EQ("OK", response2.status_text);
   EXPECT_EQ(response1.response_time, response2.response_time);
   EXPECT_TRUE(response2.is_in_cache_storage);
   EXPECT_EQ("cache_name", response2.cache_storage_cache_name);
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
                        FetchEvent_respondWithRejection) {
   StartServerAndNavigateToSetup();
   ServiceWorkerFetchEventResult result;
   ServiceWorkerResponse response;
   std::unique_ptr<storage::BlobDataHandle> blob_data_handle;
+  InstallTestHelper("/service_worker/fetch_event_rejected.js",
+                    SERVICE_WORKER_OK);
   ActivateTestHelper("/service_worker/fetch_event_rejected.js",
                      SERVICE_WORKER_OK);
 
   ConsoleListener console_listener;
   RunOnIOThread(base::Bind(&EmbeddedWorkerInstance::AddListener,
                            base::Unretained(version_->embedded_worker()),
                            &console_listener));
 
   FetchOnRegisteredWorker(&result, &response, &blob_data_handle);
   const base::string16 expected1 = base::ASCIIToUTF16(
@@ skipping 1316 matching lines @@
   base::RunLoop cached_metadata_run_loop;
   cache_updated_closure_ = cached_metadata_run_loop.QuitClosure();
 
   // Start a worker.
   StartWorker(SERVICE_WORKER_OK);
 
   // Wait for the matadata is stored. This run loop should finish when
   // OnCachedMetadataUpdated() is called.
   cached_metadata_run_loop.Run();
 
-  // Activate the worker.
-  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
-  base::RunLoop activate_run_loop;
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&self::ActivateOnIOThread, base::Unretained(this),
-                 activate_run_loop.QuitClosure(), &status));
-  activate_run_loop.Run();
-  ASSERT_EQ(SERVICE_WORKER_OK, status);
   // Stop the worker.
   StopWorker(SERVICE_WORKER_OK);
   // Restart the worker.
   StartWorker(SERVICE_WORKER_OK);
   // Stop the worker.
   StopWorker(SERVICE_WORKER_OK);
 }
 
 class CacheStorageSideDataSizeChecker
     : public base::RefCountedThreadSafe<CacheStorageSideDataSizeChecker> {
@@ skipping 409 matching lines @@
 };
 
 // MemoryCoordinatorWithServiceWorkerTest checks if a process won't be
 // suspended when it has one or more shared workers or service workers.
 // TODO(shimazu): Enable these tests on macos when MemoryMonitorMac is
 // implemented.
 #if !defined(OS_MACOSX)
 IN_PROC_BROWSER_TEST_F(MemoryCoordinatorWithServiceWorkerTest,
                        CannotSuspendRendererWithServiceWorker) {
   StartServerAndNavigateToSetup();
+  InstallTestHelper("/service_worker/fetch_event.js", SERVICE_WORKER_OK);
   ActivateTestHelper("/service_worker/fetch_event.js", SERVICE_WORKER_OK);
 
   MemoryCoordinatorImpl* memory_coordinator =
       MemoryCoordinatorImpl::GetInstance();
   memory_coordinator->SetDelegateForTesting(
       base::MakeUnique<TestMemoryCoordinatorDelegate>());
 
   // Ensure only one process host exists.
   ASSERT_EQ(1, CountRenderProcessHosts());
   ASSERT_EQ(1u, memory_coordinator->children().size());
 
   // Check the number of workers.
   int render_process_id = memory_coordinator->children().begin()->first;
   RenderProcessHost* rph = RenderProcessHost::FromID(render_process_id);
   EXPECT_EQ(1u, rph->GetWorkerRefCount());
 
   // A process should be backgrounded to ensure the worker reference count takes
   // effect in CanSuspendRenderer().
   shell()->web_contents()->WasHidden();
   EXPECT_TRUE(rph->IsProcessBackgrounded());
 
   // The process which has service worker thread shouldn't be suspended.
   EXPECT_FALSE(memory_coordinator->CanSuspendRenderer(render_process_id));
 }
 #endif
 
 }  // namespace content