Revert of Evict Service Worker when reading it from disk cache fails.

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 "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
@@ skipping 554 matching lines @@
 
     AssociateRendererProcessToPattern(pattern);
   }
 
   void TimeoutWorkerOnIOThread() {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     version_->PingWorker();
     version_->OnPingTimeout();
   }
 
-  void AddControlleeOnIOThread() {
-    ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    scoped_ptr<ServiceWorkerProviderHost> host(new ServiceWorkerProviderHost(
-        33 /* dummy render process id */,
-        MSG_ROUTING_NONE /* render_frame_id */, 1 /* dummy provider_id */,
-        SERVICE_WORKER_PROVIDER_FOR_WINDOW, wrapper()->context()->AsWeakPtr(),
-        NULL));
-    host->SetDocumentUrl(
-        embedded_test_server()->GetURL("/service_worker/host"));
-    host->AssociateRegistration(registration_.get(),
-                                false /* notify_controllerchange */);
-    wrapper()->context()->AddProviderHost(host.Pass());
-  }
-
-  void AddWaitingWorkerOnIOThread(const std::string& worker_url) {
-    ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    scoped_refptr<ServiceWorkerVersion> waiting_version(
-        new ServiceWorkerVersion(
-            registration_.get(), embedded_test_server()->GetURL(worker_url),
-            wrapper()->context()->storage()->NewVersionId(),
-            wrapper()->context()->AsWeakPtr()));
-    waiting_version->SetStatus(ServiceWorkerVersion::INSTALLED);
-    registration_->SetWaitingVersion(waiting_version.get());
-    registration_->ActivateWaitingVersionWhenReady();
-  }
-
   void StartWorker(ServiceWorkerStatusCode expected_status) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI));
     ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
     base::RunLoop start_run_loop;
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                             base::Bind(&self::StartOnIOThread, this,
                                        start_run_loop.QuitClosure(),
                                        &status));
     start_run_loop.Run();
     ASSERT_EQ(expected_status, status);
@@ skipping 22 matching lines @@
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     version_->SetStatus(ServiceWorkerVersion::INSTALLING);
     version_->DispatchInstallEvent(
         CreateReceiver(BrowserThread::UI, done, result));
   }
 
   void ActivateOnIOThread(const base::Closure& done,
                           ServiceWorkerStatusCode* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     version_->SetStatus(ServiceWorkerVersion::ACTIVATING);
-    registration_->SetActiveVersion(version_.get());
     version_->DispatchActivateEvent(
         CreateReceiver(BrowserThread::UI, done, result));
   }
 
   void FetchOnIOThread(const base::Closure& done,
                        bool* prepare_result,
                        FetchResult* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     ServiceWorkerFetchRequest request(
         embedded_test_server()->GetURL("/service_worker/empty.html"),
@@ skipping 96 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, StartNotFound) {
   RunOnIOThread(base::Bind(&self::SetUpRegistrationOnIOThread, this,
                            "/service_worker/nonexistent.js"));
 
   // Start a worker for nonexistent URL.
   StartWorker(SERVICE_WORKER_ERROR_NETWORK);
 }
 
-IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, ReadResourceFailure) {
-  RunOnIOThread(base::Bind(&self::SetUpRegistrationOnIOThread, this,
-                           "/service_worker/worker.js"));
-  version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
-
-  // 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);
-
-  // We'll fail to read from disk and the worker should be doomed.
-  StartWorker(SERVICE_WORKER_ERROR_DISK_CACHE);
-  EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, version_->status());
-
-  // The registration should be deleted since the version was the stored one.
-  EXPECT_TRUE(registration_->is_deleted());
-}
-
-IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
-                       ReadResourceFailure_WaitingWorker) {
-  RunOnIOThread(base::Bind(&self::SetUpRegistrationOnIOThread, this,
-                           "/service_worker/worker.js"));
-  base::RunLoop acrivate_run_loop;
-  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(&self::ActivateOnIOThread, this,
-                                     acrivate_run_loop.QuitClosure(), &status));
-  acrivate_run_loop.Run();
-  ASSERT_TRUE(registration_->active_version());
-
-  // Give the version a controllee.
-  RunOnIOThread(base::Bind(&self::AddControlleeOnIOThread, 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);
-
-  // Make a waiting version.
-  RunOnIOThread(base::Bind(&self::AddWaitingWorkerOnIOThread, this,
-                           "/service_worker/worker.js"));
-
-  // Start the 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());
-
-  // The registration is still alive since the waiting version was the stored
-  // one.
-  EXPECT_FALSE(registration_->is_deleted());
-}
-
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, Install) {
   InstallTestHelper("/service_worker/worker.js", SERVICE_WORKER_OK);
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
                        InstallWithWaitUntil_Fulfilled) {
   InstallTestHelper("/service_worker/worker_install_fulfilled.js",
                     SERVICE_WORKER_OK);
 }
 
@@ skipping 543 matching lines @@
   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);
 }
 
 }  // namespace content