ServiceWorker: Make ServiceWorkerStorage more self-defensive

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 64 matching lines @@
 
 ServiceWorkerStorage::FindRegistrationCallback MakeFindCallback(
     bool* was_called,
     ServiceWorkerStatusCode* result,
     scoped_refptr<ServiceWorkerRegistration>* found) {
   return base::Bind(&FindCallback, was_called, result, found);
 }
 
 void GetAllCallback(
     bool* was_called,
+    ServiceWorkerStatusCode* result,
     std::vector<scoped_refptr<ServiceWorkerRegistration>>* all_out,
+    ServiceWorkerStatusCode status,
     const std::vector<scoped_refptr<ServiceWorkerRegistration>>& all) {
   *was_called = true;
+  *result = status;
   *all_out = all;
 }
 
 void GetAllInfosCallback(
     bool* was_called,
+    ServiceWorkerStatusCode* result,
     std::vector<ServiceWorkerRegistrationInfo>* all_out,
+    ServiceWorkerStatusCode status,
     const std::vector<ServiceWorkerRegistrationInfo>& all) {
   *was_called = true;
+  *result = status;
   *all_out = all;
 }
 
 ServiceWorkerStorage::GetRegistrationsCallback MakeGetRegistrationsCallback(
     bool* was_called,
+    ServiceWorkerStatusCode* status,
     std::vector<scoped_refptr<ServiceWorkerRegistration>>* all) {
-  return base::Bind(&GetAllCallback, was_called, all);
+  return base::Bind(&GetAllCallback, was_called, status, all);
 }
 
 ServiceWorkerStorage::GetRegistrationsInfosCallback
 MakeGetRegistrationsInfosCallback(
     bool* was_called,
+    ServiceWorkerStatusCode* status,
     std::vector<ServiceWorkerRegistrationInfo>* all) {
-  return base::Bind(&GetAllInfosCallback, was_called, all);
+  return base::Bind(&GetAllInfosCallback, was_called, status, all);
 }
 
 void GetUserDataCallback(
     bool* was_called,
     std::string* data_out,
     ServiceWorkerStatusCode* status_out,
     const std::string& data,
     ServiceWorkerStatusCode status) {
   *was_called = true;
   *data_out = data;
   *status_out = status;
 }
 
 void GetUserDataForAllRegistrationsCallback(
     bool* was_called,
     std::vector<std::pair<int64_t, std::string>>* data_out,
     ServiceWorkerStatusCode* status_out,
     const std::vector<std::pair<int64_t, std::string>>& data,
     ServiceWorkerStatusCode status) {
   *was_called = true;
   *data_out = data;
   *status_out = status;
 }
 
-void WriteResponse(ServiceWorkerStorage* storage,
-                   int64_t id,
-                   const std::string& headers,
-                   IOBuffer* body,
-                   int length) {
+int WriteResponse(ServiceWorkerStorage* storage,
+                  int64_t id,
+                  const std::string& headers,
+                  IOBuffer* body,
+                  int length) {
   scoped_ptr<ServiceWorkerResponseWriter> writer =
       storage->CreateResponseWriter(id);
 
   scoped_ptr<net::HttpResponseInfo> info(new net::HttpResponseInfo);
   info->request_time = base::Time::Now();
   info->response_time = base::Time::Now();
   info->was_cached = false;
   info->headers = new net::HttpResponseHeaders(headers);
   scoped_refptr<HttpResponseInfoIOBuffer> info_buffer =
       new HttpResponseInfoIOBuffer(info.release());
+  int rv = 0;
   {
     TestCompletionCallback cb;
     writer->WriteInfo(info_buffer.get(), cb.callback());
-    int rv = cb.WaitForResult();
-    EXPECT_LT(0, rv);
+    rv = cb.WaitForResult();
+    if (rv < 0)
+      return rv;
   }
   {
     TestCompletionCallback cb;
     writer->WriteData(body, length, cb.callback());
-    int rv = cb.WaitForResult();
-    EXPECT_EQ(length, rv);
+    rv = cb.WaitForResult();
   }
+  return rv;
 }
 
-void WriteStringResponse(ServiceWorkerStorage* storage,
-                         int64_t id,
-                         const std::string& headers,
-                         const std::string& body) {
+int WriteStringResponse(ServiceWorkerStorage* storage,
+                        int64_t id,
+                        const std::string& headers,
+                        const std::string& body) {
   scoped_refptr<IOBuffer> body_buffer(new WrappedIOBuffer(body.data()));
-  WriteResponse(storage, id, headers, body_buffer.get(), body.length());
+  return WriteResponse(storage, id, headers, body_buffer.get(), body.length());
 }
 
-void WriteBasicResponse(ServiceWorkerStorage* storage, int64_t id) {
-  scoped_ptr<ServiceWorkerResponseWriter> writer =
-      storage->CreateResponseWriter(id);
-
+int WriteBasicResponse(ServiceWorkerStorage* storage, int64_t id) {
   const char kHttpHeaders[] = "HTTP/1.0 200 HONKYDORY\0Content-Length: 5\0\0";
   const char kHttpBody[] = "Hello";
   std::string headers(kHttpHeaders, arraysize(kHttpHeaders));
-  WriteStringResponse(storage, id, headers, std::string(kHttpBody));
+  return WriteStringResponse(storage, id, headers, std::string(kHttpBody));
+}
+
+int ReadResponseInfo(ServiceWorkerStorage* storage,
+                     int64_t id,
+                     HttpResponseInfoIOBuffer* info_buffer) {
+  scoped_ptr<ServiceWorkerResponseReader> reader =
+      storage->CreateResponseReader(id);
+  TestCompletionCallback cb;
+  reader->ReadInfo(info_buffer, cb.callback());
+  return cb.WaitForResult();
 }
 
 bool VerifyBasicResponse(ServiceWorkerStorage* storage,
                          int64_t id,
                          bool expected_positive_result) {
   const std::string kExpectedHttpBody("Hello");
   scoped_ptr<ServiceWorkerResponseReader> reader =
       storage->CreateResponseReader(id);
   scoped_refptr<HttpResponseInfoIOBuffer> info_buffer =
       new HttpResponseInfoIOBuffer();
-  {
-    TestCompletionCallback cb;
-    reader->ReadInfo(info_buffer.get(), cb.callback());
-    int rv = cb.WaitForResult();
-    if (expected_positive_result)
-      EXPECT_LT(0, rv);
-    if (rv <= 0)
-      return false;
-  }
+  int rv = ReadResponseInfo(storage, id, info_buffer.get());
+  if (expected_positive_result)
+    EXPECT_LT(0, rv);
+  if (rv <= 0)
+    return false;
 
   std::string received_body;
-  {
-    const int kBigEnough = 512;
-    scoped_refptr<net::IOBuffer> buffer = new IOBuffer(kBigEnough);
-    TestCompletionCallback cb;
-    reader->ReadData(buffer.get(), kBigEnough, cb.callback());
-    int rv = cb.WaitForResult();
-    EXPECT_EQ(static_cast<int>(kExpectedHttpBody.size()), rv);
-    if (rv <= 0)
-      return false;
-    received_body.assign(buffer->data(), rv);
-  }
+  const int kBigEnough = 512;
+  scoped_refptr<net::IOBuffer> buffer = new IOBuffer(kBigEnough);
+  TestCompletionCallback cb;
+  reader->ReadData(buffer.get(), kBigEnough, cb.callback());
+  rv = cb.WaitForResult();
+  EXPECT_EQ(static_cast<int>(kExpectedHttpBody.size()), rv);
+  if (rv <= 0)
+    return false;
+  received_body.assign(buffer->data(), rv);
 
   bool status_match =
       std::string("HONKYDORY") ==
           info_buffer->http_info->headers->GetStatusText();
   bool data_match = kExpectedHttpBody == received_body;
 
   EXPECT_TRUE(status_match);
   EXPECT_TRUE(data_match);
   return status_match && data_match;
 }
@@ skipping 93 matching lines @@
  protected:
   void LazyInitialize() {
     storage()->LazyInitialize(base::Bind(&base::DoNothing));
     base::RunLoop().RunUntilIdle();
   }
 
   ServiceWorkerStatusCode StoreRegistration(
       scoped_refptr<ServiceWorkerRegistration> registration,
       scoped_refptr<ServiceWorkerVersion> version) {
     bool was_called = false;
-    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
+    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_MAX_VALUE;
     storage()->StoreRegistration(registration.get(),
                                  version.get(),
                                  MakeStatusCallback(&was_called, &result));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
   ServiceWorkerStatusCode DeleteRegistration(int64_t registration_id,
                                              const GURL& origin) {
     bool was_called = false;
-    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
+    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_MAX_VALUE;
     storage()->DeleteRegistration(
         registration_id, origin, MakeStatusCallback(&was_called, &result));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
-  void GetAllRegistrationsInfos(
+  ServiceWorkerStatusCode GetAllRegistrationsInfos(
       std::vector<ServiceWorkerRegistrationInfo>* registrations) {
     bool was_called = false;
+    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_MAX_VALUE;
     storage()->GetAllRegistrationsInfos(
-        MakeGetRegistrationsInfosCallback(&was_called, registrations));
+        MakeGetRegistrationsInfosCallback(&was_called, &result, registrations));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
+    return result;
   }
 
-  void GetRegistrationsForOrigin(
+  ServiceWorkerStatusCode GetRegistrationsForOrigin(
       const GURL& origin,
       std::vector<scoped_refptr<ServiceWorkerRegistration>>* registrations) {
     bool was_called = false;
+    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_MAX_VALUE;
     storage()->GetRegistrationsForOrigin(
-        origin, MakeGetRegistrationsCallback(&was_called, registrations));
+        origin,
+        MakeGetRegistrationsCallback(&was_called, &result, registrations));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
+    return result;
   }
 
   ServiceWorkerStatusCode GetUserData(int64_t registration_id,
                                       const std::string& key,
                                       std::string* data) {
     bool was_called = false;
-    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
+    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_MAX_VALUE;
     storage()->GetUserData(
         registration_id, key,
         base::Bind(&GetUserDataCallback, &was_called, data, &result));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
   ServiceWorkerStatusCode StoreUserData(int64_t registration_id,
                                         const GURL& origin,
                                         const std::string& key,
                                         const std::string& data) {
     bool was_called = false;
-    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
+    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_MAX_VALUE;
     storage()->StoreUserData(
         registration_id, origin, key, data,
         MakeStatusCallback(&was_called, &result));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
   ServiceWorkerStatusCode ClearUserData(int64_t registration_id,
                                         const std::string& key) {
     bool was_called = false;
-    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
+    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_MAX_VALUE;
     storage()->ClearUserData(
         registration_id, key, MakeStatusCallback(&was_called, &result));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
   ServiceWorkerStatusCode GetUserDataForAllRegistrations(
       const std::string& key,
       std::vector<std::pair<int64_t, std::string>>* data) {
     bool was_called = false;
-    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
+    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_MAX_VALUE;
     storage()->GetUserDataForAllRegistrations(
         key, base::Bind(&GetUserDataForAllRegistrationsCallback, &was_called,
                         data, &result));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
   ServiceWorkerStatusCode UpdateToActiveState(
-      scoped_refptr<ServiceWorkerRegistration> registration) {
+      const scoped_refptr<ServiceWorkerRegistration>& registration) {
     bool was_called = false;
-    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
+    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_MAX_VALUE;
     storage()->UpdateToActiveState(registration.get(),
                                    MakeStatusCallback(&was_called, &result));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
-  void UpdateLastUpdateCheckTime(ServiceWorkerRegistration* registration) {
-    storage()->UpdateLastUpdateCheckTime(registration);
+  void UpdateLastUpdateCheckTime(
+      const scoped_refptr<ServiceWorkerRegistration>& registration) {
+    storage()->UpdateLastUpdateCheckTime(registration.get());
     base::RunLoop().RunUntilIdle();
   }
 
   ServiceWorkerStatusCode FindRegistrationForDocument(
       const GURL& document_url,
       scoped_refptr<ServiceWorkerRegistration>* registration) {
     bool was_called = false;
-    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
+    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_MAX_VALUE;
     storage()->FindRegistrationForDocument(
         document_url, MakeFindCallback(&was_called, &result, registration));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
   ServiceWorkerStatusCode FindRegistrationForPattern(
       const GURL& scope,
       scoped_refptr<ServiceWorkerRegistration>* registration) {
     bool was_called = false;
-    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
+    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_MAX_VALUE;
     storage()->FindRegistrationForPattern(
         scope, MakeFindCallback(&was_called, &result, registration));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
   ServiceWorkerStatusCode FindRegistrationForId(
       int64_t registration_id,
       const GURL& origin,
       scoped_refptr<ServiceWorkerRegistration>* registration) {
     bool was_called = false;
-    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
+    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_MAX_VALUE;
     storage()->FindRegistrationForId(
         registration_id, origin,
         MakeFindCallback(&was_called, &result, registration));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
   ServiceWorkerStatusCode FindRegistrationForIdOnly(
       int64_t registration_id,
       scoped_refptr<ServiceWorkerRegistration>* registration) {
     bool was_called = false;
-    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
+    ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_MAX_VALUE;
     storage()->FindRegistrationForIdOnly(
         registration_id, MakeFindCallback(&was_called, &result, registration));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
   // user_data_directory_ must be declared first to preserve destructor order.
   base::ScopedTempDir user_data_directory_;
   scoped_ptr<EmbeddedWorkerTestHelper> helper_;
   TestBrowserThreadBundle browser_thread_bundle_;
 };
 
+TEST_F(ServiceWorkerStorageTest, DisabledStorage) {
+  const GURL kScope("http://www.example.com/scope/");
+  const GURL kScript("http://www.example.com/script.js");
+  const GURL kDocumentUrl("http://www.example.com/scope/document.html");
+  const int64_t kRegistrationId = 0;
+  const int64_t kVersionId = 0;
+  const int64_t kResourceId = 0;
+
+  LazyInitialize();
+  storage()->Disable();
+
+  scoped_refptr<ServiceWorkerRegistration> found_registration;
+  EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT,
+            FindRegistrationForDocument(kDocumentUrl, &found_registration));
+  EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT,
+            FindRegistrationForPattern(kScope, &found_registration));
+  EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT,
+            FindRegistrationForId(kRegistrationId, kScope.GetOrigin(),
+                                  &found_registration));
+  EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT,
+            FindRegistrationForIdOnly(kRegistrationId, &found_registration));
+  EXPECT_FALSE(storage()->GetUninstallingRegistration(kScope.GetOrigin()));
+
+  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());
+  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()));
+
+  // Response reader and writer created by the disabled storage should fail to
+  // access the disk cache.
+  scoped_refptr<HttpResponseInfoIOBuffer> info_buffer =
+      new HttpResponseInfoIOBuffer();
+  EXPECT_EQ(net::ERR_CACHE_MISS,
+            ReadResponseInfo(storage(), kResourceId, info_buffer.get()));
+  EXPECT_EQ(net::ERR_FAILED, WriteBasicResponse(storage(), kResourceId));
+  EXPECT_EQ(net::ERR_FAILED,
+            WriteResponseMetadata(storage(), kResourceId, "foo"));
+
+  const std::string kUserDataKey = "key";
+  std::string user_data_out;
+  EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT,
+            GetUserData(kRegistrationId, kUserDataKey, &user_data_out));
+  EXPECT_EQ(
+      SERVICE_WORKER_ERROR_ABORT,
+      StoreUserData(kRegistrationId, kScope.GetOrigin(), kUserDataKey, "foo"));
+  EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT,
+            ClearUserData(kRegistrationId, kUserDataKey));
+  std::vector<std::pair<int64_t, std::string>> data_list_out;
+  EXPECT_EQ(SERVICE_WORKER_ERROR_ABORT,
+            GetUserDataForAllRegistrations(kUserDataKey, &data_list_out));
+
+  EXPECT_FALSE(
+      storage()->OriginHasForeignFetchRegistrations(kScope.GetOrigin()));
+
+  // Next available ids should be invalid.
+  EXPECT_EQ(kInvalidServiceWorkerRegistrationId,
+            storage()->NewRegistrationId());
+  EXPECT_EQ(kInvalidServiceWorkerVersionId, storage()->NewVersionId());
+  EXPECT_EQ(kInvalidServiceWorkerResourceId, storage()->NewRegistrationId());
+}
+
 TEST_F(ServiceWorkerStorageTest, StoreFindUpdateDeleteRegistration) {
   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 GURL kResource1("http://www.test.not/scope/resource1.js");
   const int64_t kResource1Size = 1591234;
   const GURL kResource2("http://www.test.not/scope/resource2.js");
   const int64_t kResource2Size = 51;
   const int64_t kRegistrationId = 0;
   const int64_t kVersionId = 0;
@@ skipping 79 matching lines @@
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
   ASSERT_TRUE(found_registration.get());
   EXPECT_EQ(kRegistrationId, found_registration->id());
   EXPECT_TRUE(found_registration->HasOneRef());
 
   // Check that sizes are populated correctly
   EXPECT_EQ(live_version.get(), found_registration->waiting_version());
   EXPECT_EQ(kResource1Size + kResource2Size,
             found_registration->resources_total_size_bytes());
   std::vector<ServiceWorkerRegistrationInfo> all_registrations;
-  GetAllRegistrationsInfos(&all_registrations);
+  EXPECT_EQ(SERVICE_WORKER_OK, GetAllRegistrationsInfos(&all_registrations));
   EXPECT_EQ(1u, all_registrations.size());
   ServiceWorkerRegistrationInfo info = all_registrations[0];
   EXPECT_EQ(kResource1Size + kResource2Size, info.stored_version_size_bytes);
   all_registrations.clear();
 
   // Finding by origin should provide the same result if origin is kScope.
   std::vector<scoped_refptr<ServiceWorkerRegistration>>
       registrations_for_origin;
-  GetRegistrationsForOrigin(kScope.GetOrigin(), &registrations_for_origin);
+  EXPECT_EQ(
+      SERVICE_WORKER_OK,
+      GetRegistrationsForOrigin(kScope.GetOrigin(), &registrations_for_origin));
   EXPECT_EQ(1u, registrations_for_origin.size());
   registrations_for_origin.clear();
 
-  GetRegistrationsForOrigin(GURL("http://example.com/").GetOrigin(),
-                            &registrations_for_origin);
+  EXPECT_EQ(SERVICE_WORKER_OK,
+            GetRegistrationsForOrigin(GURL("http://example.com/").GetOrigin(),
+                                      &registrations_for_origin));
   EXPECT_TRUE(registrations_for_origin.empty());
 
   found_registration = NULL;
 
   // Drop the live version too.
   live_version = NULL;
 
   // And FindRegistrationForPattern is always async.
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForPattern(kScope, &found_registration));
@@ skipping 93 matching lines @@
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
   EXPECT_FALSE(found_registration.get());
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForPattern(kScope, &found_registration));
   EXPECT_FALSE(found_registration.get());
 
   std::vector<ServiceWorkerRegistrationInfo> all_registrations;
-  GetAllRegistrationsInfos(&all_registrations);
+  EXPECT_EQ(SERVICE_WORKER_OK, GetAllRegistrationsInfos(&all_registrations));
   EXPECT_TRUE(all_registrations.empty());
 
   std::vector<scoped_refptr<ServiceWorkerRegistration>>
       registrations_for_origin;
-  GetRegistrationsForOrigin(kScope.GetOrigin(), &registrations_for_origin);
+  EXPECT_EQ(
+      SERVICE_WORKER_OK,
+      GetRegistrationsForOrigin(kScope.GetOrigin(), &registrations_for_origin));
   EXPECT_TRUE(registrations_for_origin.empty());
 
-  GetRegistrationsForOrigin(GURL("http://example.com/").GetOrigin(),
-                            &registrations_for_origin);
+  EXPECT_EQ(SERVICE_WORKER_OK,
+            GetRegistrationsForOrigin(GURL("http://example.com/").GetOrigin(),
+                                      &registrations_for_origin));
   EXPECT_TRUE(registrations_for_origin.empty());
 
   // Notify storage of it being installed.
   storage()->NotifyInstallingRegistration(live_registration.get());
 
   // Now should be findable.
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForId(
                 kRegistrationId, kScope.GetOrigin(), &found_registration));
   EXPECT_EQ(live_registration, found_registration);
   found_registration = NULL;
 
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForIdOnly(kRegistrationId, &found_registration));
   EXPECT_EQ(live_registration, found_registration);
   found_registration = NULL;
 
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
   EXPECT_EQ(live_registration, found_registration);
   found_registration = NULL;
 
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForPattern(kScope, &found_registration));
   EXPECT_EQ(live_registration, found_registration);
   found_registration = NULL;
 
-  GetAllRegistrationsInfos(&all_registrations);
+  EXPECT_EQ(SERVICE_WORKER_OK, GetAllRegistrationsInfos(&all_registrations));
   EXPECT_EQ(1u, all_registrations.size());
   all_registrations.clear();
 
   // Finding by origin should provide the same result if origin is kScope.
-  GetRegistrationsForOrigin(kScope.GetOrigin(), &registrations_for_origin);
+  EXPECT_EQ(
+      SERVICE_WORKER_OK,
+      GetRegistrationsForOrigin(kScope.GetOrigin(), &registrations_for_origin));
   EXPECT_EQ(1u, registrations_for_origin.size());
   registrations_for_origin.clear();
 
-  GetRegistrationsForOrigin(GURL("http://example.com/").GetOrigin(),
-                            &registrations_for_origin);
+  EXPECT_EQ(SERVICE_WORKER_OK,
+            GetRegistrationsForOrigin(GURL("http://example.com/").GetOrigin(),
+                                      &registrations_for_origin));
   EXPECT_TRUE(registrations_for_origin.empty());
 
   // Notify storage of installation no longer happening.
   storage()->NotifyDoneInstallingRegistration(
       live_registration.get(), NULL, SERVICE_WORKER_OK);
 
   // Once again, should not be findable.
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForId(
                 kRegistrationId, kScope.GetOrigin(), &found_registration));
   EXPECT_FALSE(found_registration.get());
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForIdOnly(kRegistrationId, &found_registration));
   EXPECT_FALSE(found_registration.get());
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
   EXPECT_FALSE(found_registration.get());
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForPattern(kScope, &found_registration));
   EXPECT_FALSE(found_registration.get());
 
-  GetAllRegistrationsInfos(&all_registrations);
+  EXPECT_EQ(SERVICE_WORKER_OK, GetAllRegistrationsInfos(&all_registrations));
   EXPECT_TRUE(all_registrations.empty());
 
-  GetRegistrationsForOrigin(kScope.GetOrigin(), &registrations_for_origin);
+  EXPECT_EQ(
+      SERVICE_WORKER_OK,
+      GetRegistrationsForOrigin(kScope.GetOrigin(), &registrations_for_origin));
   EXPECT_TRUE(registrations_for_origin.empty());
 
-  GetRegistrationsForOrigin(GURL("http://example.com/").GetOrigin(),
-                            &registrations_for_origin);
+  EXPECT_EQ(SERVICE_WORKER_OK,
+            GetRegistrationsForOrigin(GURL("http://example.com/").GetOrigin(),
+                                      &registrations_for_origin));
   EXPECT_TRUE(registrations_for_origin.empty());
 }
 
 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();
@@ skipping 421 matching lines @@
       VerifyBasicResponse(storage(), kStaleUncommittedResourceId, false));
   EXPECT_TRUE(VerifyBasicResponse(storage(), kNewResourceId, true));
 }
 
 TEST_F(ServiceWorkerResourceStorageDiskTest, DeleteAndStartOver) {
   EXPECT_FALSE(storage()->IsDisabled());
   ASSERT_TRUE(base::DirectoryExists(storage()->GetDiskCachePath()));
   ASSERT_TRUE(base::DirectoryExists(storage()->GetDatabasePath()));
 
   base::RunLoop run_loop;
-  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_ABORT;
+  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE;
   storage()->DeleteAndStartOver(
       base::Bind(&StatusAndQuitCallback, &status, run_loop.QuitClosure()));
   run_loop.Run();
 
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_TRUE(storage()->IsDisabled());
   EXPECT_FALSE(base::DirectoryExists(storage()->GetDiskCachePath()));
   EXPECT_FALSE(base::DirectoryExists(storage()->GetDatabasePath()));
 }
 
 TEST_F(ServiceWorkerResourceStorageDiskTest,
        DeleteAndStartOver_UnrelatedFileExists) {
   EXPECT_FALSE(storage()->IsDisabled());
   ASSERT_TRUE(base::DirectoryExists(storage()->GetDiskCachePath()));
   ASSERT_TRUE(base::DirectoryExists(storage()->GetDatabasePath()));
 
   // Create an unrelated file in the database directory to make sure such a file
   // does not prevent DeleteAndStartOver.
   base::FilePath file_path;
   ASSERT_TRUE(
       base::CreateTemporaryFileInDir(storage()->GetDatabasePath(), &file_path));
   ASSERT_TRUE(base::PathExists(file_path));
 
   base::RunLoop run_loop;
-  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_ABORT;
+  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE;
   storage()->DeleteAndStartOver(
       base::Bind(&StatusAndQuitCallback, &status, run_loop.QuitClosure()));
   run_loop.Run();
 
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_TRUE(storage()->IsDisabled());
   EXPECT_FALSE(base::DirectoryExists(storage()->GetDiskCachePath()));
   EXPECT_FALSE(base::DirectoryExists(storage()->GetDatabasePath()));
 }
 
 TEST_F(ServiceWorkerResourceStorageDiskTest,
        DeleteAndStartOver_OpenedFileExists) {
   EXPECT_FALSE(storage()->IsDisabled());
   ASSERT_TRUE(base::DirectoryExists(storage()->GetDiskCachePath()));
   ASSERT_TRUE(base::DirectoryExists(storage()->GetDatabasePath()));
 
   // Create an unrelated opened file in the database directory to make sure such
   // a file does not prevent DeleteAndStartOver on non-Windows platforms.
   base::FilePath file_path;
   base::ScopedFILE file(base::CreateAndOpenTemporaryFileInDir(
       storage()->GetDatabasePath(), &file_path));
   ASSERT_TRUE(file);
   ASSERT_TRUE(base::PathExists(file_path));
 
   base::RunLoop run_loop;
-  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_ABORT;
+  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE;
   storage()->DeleteAndStartOver(
       base::Bind(&StatusAndQuitCallback, &status, run_loop.QuitClosure()));
   run_loop.Run();
 
 #if defined(OS_WIN)
   // On Windows, deleting the directory containing an opened file should fail.
   EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status);
   EXPECT_TRUE(storage()->IsDisabled());
   EXPECT_TRUE(base::DirectoryExists(storage()->GetDiskCachePath()));
   EXPECT_TRUE(base::DirectoryExists(storage()->GetDatabasePath()));
@@ skipping 262 matching lines @@
   // Remove other registration at first origin.
   EXPECT_EQ(SERVICE_WORKER_OK,
             DeleteRegistration(kRegistrationId2, kScope2.GetOrigin()));
 
   // No foreign fetch registrations remain.
   EXPECT_FALSE(storage()->OriginHasForeignFetchRegistrations(kOrigin1));
   EXPECT_FALSE(storage()->OriginHasForeignFetchRegistrations(kOrigin2));
 }
 
 }  // namespace content