ServiceWorker: ReadRegistration should return NOT_FOUND when the database is not initialized

content/browser/service_worker/service_worker_database_unittest.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 "content/browser/service_worker/service_worker_database.h"
 
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 480 matching lines @@
             database->WriteRegistration(
                 data, resources, &deleted_version, &newly_purgeable_resources));
   EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id);
   EXPECT_TRUE(newly_purgeable_resources.empty());
 
   // Make sure that the registration and resource records are stored.
   RegistrationData data_out;
   std::vector<Resource> resources_out;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->ReadRegistration(
-      data.registration_id, origin, &data_out, &resources_out));
+                data.registration_id, origin, &data_out, &resources_out));
   VerifyRegistrationData(data, data_out);
   VerifyResourceRecords(resources, resources_out);
 
   // Make sure that the resource is removed from the uncommitted list.
   uncommitted_ids_out.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetUncommittedResourceIds(&uncommitted_ids_out));
   EXPECT_TRUE(uncommitted_ids_out.empty());
 
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
@@ skipping 222 matching lines @@
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources1[1].resource_id));
 
   // Make sure that registration2 is still alive.
   resources_out.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
       data2.registration_id, origin, &data_out, &resources_out));
   VerifyRegistrationData(data2, data_out);
   VerifyResourceRecords(resources2, resources_out);
 }
 
+TEST(ServiceWorkerDatabaseTest, Registration_UninitializedDatabase) {
+  scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
+  const GURL origin("http://example.com");
+
+  // Should be failed because the database does not exist.
+  RegistrationData data_out;
+  std::vector<Resource> resources_out;
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+            database->ReadRegistration(
+                100, origin, &data_out, &resources_out));
+  EXPECT_EQ(kInvalidServiceWorkerRegistrationId, data_out.registration_id);
+  EXPECT_TRUE(resources_out.empty());
+
+  // Deleting non-existent registration should succeed.
+  RegistrationData deleted_version;
+  std::vector<int64> newly_purgeable_resources;
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->DeleteRegistration(
+                100, origin, &deleted_version, &newly_purgeable_resources));
+  EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id);
+  EXPECT_TRUE(newly_purgeable_resources.empty());
+
+  // Actually create a new database, but not initialized yet.
+  database->LazyOpen(true);
+
+  // Should be failed because the database is not initialized.
+  ASSERT_EQ(ServiceWorkerDatabase::UNINITIALIZED, database->state_);
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+            database->ReadRegistration(
+                100, origin, &data_out, &resources_out));
+  EXPECT_EQ(kInvalidServiceWorkerRegistrationId, data_out.registration_id);
+  EXPECT_TRUE(resources_out.empty());
+
+  // Deleting non-existent registration should succeed.
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->DeleteRegistration(
+                100, origin, &deleted_version, &newly_purgeable_resources));
+  EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id);
+  EXPECT_TRUE(newly_purgeable_resources.empty());
+}
+
 TEST(ServiceWorkerDatabaseTest, UserData_Basic) {
   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
   const GURL kOrigin("http://example.com");
 
-  // Should be failed because the database does not exist.
-  std::string user_data_out;
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
-            database->WriteUserData(100, kOrigin, "key1", "data"));
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
-            database->ReadUserData(100, "key1", &user_data_out));
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->DeleteUserData(100, "key1"));
-
   // Add a registration.
   RegistrationData data;
   data.registration_id = 100;
   data.scope = URL(kOrigin, "/foo");
   data.script = URL(kOrigin, "/script.js");
   data.version_id = 200;
 
   std::vector<Resource> resources;
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64> newly_purgeable_resources;
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(
                 data, resources, &deleted_version, &newly_purgeable_resources));
 
   // Write user data associated with the stored registration.
+  std::string user_data_out;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteUserData(
                 data.registration_id, kOrigin, "key1", "data"));
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->ReadUserData(
                 data.registration_id, "key1", &user_data_out));
   EXPECT_EQ("data", user_data_out);
 
   // Writing user data not associated with the stored registration should be
   // failed.
@@ skipping 189 matching lines @@
                 data1.registration_id, "key1", &user_data_out));
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
             database->ReadUserData(
                 data1.registration_id, "key2", &user_data_out));
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->ReadUserData(
                 data2.registration_id, "key3", &user_data_out));
   EXPECT_EQ("data3", user_data_out);
 }
 
+TEST(ServiceWorkerDatabaseTest, UserData_UninitializedDatabase) {
+  scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
+  const GURL kOrigin("http://example.com");
+
+  // Should be failed because the database does not exist.
+  std::string user_data_out;
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+            database->ReadUserData(100, "key", &user_data_out));
+
+  // Should be failed because the associated registration does not exist.
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+            database->WriteUserData(100, kOrigin, "key", "data"));
+
+  // Deleting non-existent entry should succeed.
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->DeleteUserData(100, "key"));
+
+  // Actually create a new database, but not initialized yet.
+  database->LazyOpen(true);
+
+  // Should be failed because the database is not initialized.
+  ASSERT_EQ(ServiceWorkerDatabase::UNINITIALIZED, database->state_);
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+            database->ReadUserData(100, "key", &user_data_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+            database->WriteUserData(100, kOrigin, "key", "data"));

[falken, 2015/01/09 07:54:35]

nit: Maybe comment here that it should succeed or else add whitespace so it
doesn't look like line 1034 pertains to it.

[nhiroki, 2015/01/09 08:23:28]

Done.

+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->DeleteUserData(100, "key"));
+}
+
 TEST(ServiceWorkerDatabaseTest, UpdateVersionToActive) {
   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
   GURL origin("http://example.com");
 
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64> newly_purgeable_resources;
 
   // Should be false because a registration does not exist.
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
             database->UpdateVersionToActive(0, origin));
@@ skipping 345 matching lines @@
       CreateDatabase(database_dir.path()));
 
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true));
   ASSERT_TRUE(base::DirectoryExists(database_dir.path()));
 
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->DestroyDatabase());
   ASSERT_FALSE(base::DirectoryExists(database_dir.path()));
 }
 
 }  // namespace content