ServiceWorker: Migrate the script cache backend from BlockFile to Simple

content/browser/service_worker/service_worker_disk_cache_migrator_unittest.cc

 // Copyright 2015 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_disk_cache_migrator.h"
 
+#include <string>
+#include <vector>
+
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_storage.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
@@ skipping 21 matching lines @@
         body(body),
         metadata(metadata) {}
 };
 
 void OnDiskCacheMigrated(const base::Closure& callback,
                          ServiceWorkerStatusCode status) {
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   callback.Run();
 }
 
+void OnRegistrationFound(
+    const base::Closure& callback,
+    ServiceWorkerStatusCode status,
+    const scoped_refptr<ServiceWorkerRegistration>& registration) {
+  callback.Run();
+}
+
 }  // namespace
 
 class ServiceWorkerDiskCacheMigratorTest : public testing::Test {
  public:
   ServiceWorkerDiskCacheMigratorTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {}
 
   void SetUp() override {
     ASSERT_TRUE(user_data_directory_.CreateUniqueTempDir());
     scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager(
         new MockServiceWorkerDatabaseTaskManager(
             base::ThreadTaskRunnerHandle::Get()));
 
     context_.reset(new ServiceWorkerContextCore(
         user_data_directory_.path(), database_task_manager.Pass(),
         base::ThreadTaskRunnerHandle::Get(), nullptr, nullptr, nullptr,
         nullptr));
   }
 
   void TearDown() override {
     context_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
-  base::FilePath GetOldDiskCachePath() {
-    return user_data_directory_.path().AppendASCII("SrcCache");
-  }
-  base::FilePath GetDiskCachePath() {
-    return user_data_directory_.path().AppendASCII("DestCache");
-  }
-
   scoped_ptr<ServiceWorkerDiskCache> CreateSrcDiskCache() {
 #if defined(OS_ANDROID)
     // Android has already used the Simple backend.
     scoped_ptr<ServiceWorkerDiskCache> src(
         ServiceWorkerDiskCache::CreateWithSimpleBackend());
 #else
     scoped_ptr<ServiceWorkerDiskCache> src(
         ServiceWorkerDiskCache::CreateWithBlockFileBackend());
 #endif  // defined(OS_ANDROID)
 
     net::TestCompletionCallback cb;
     src->InitWithDiskBackend(
-        GetOldDiskCachePath(), kMaxDiskCacheSize, false /* force */,
+        storage()->GetOldDiskCachePath(), kMaxDiskCacheSize, false /* force */,
         base::ThreadTaskRunnerHandle::Get(), cb.callback());
     EXPECT_EQ(net::OK, cb.WaitForResult());
     return src.Pass();
   }
 
   scoped_ptr<ServiceWorkerDiskCache> CreateDestDiskCache() {
     scoped_ptr<ServiceWorkerDiskCache> dest(
         ServiceWorkerDiskCache::CreateWithSimpleBackend());
     net::TestCompletionCallback cb;
     dest->InitWithDiskBackend(
-        GetDiskCachePath(), kMaxDiskCacheSize, false /* force */,
+        storage()->GetDiskCachePath(), kMaxDiskCacheSize, false /* force */,
         base::ThreadTaskRunnerHandle::Get(), cb.callback());
     EXPECT_EQ(net::OK, cb.WaitForResult());
     return dest.Pass();
   }
 
   scoped_ptr<ServiceWorkerDiskCacheMigrator> CreateMigrator() {
     return make_scoped_ptr(new ServiceWorkerDiskCacheMigrator(
-        GetOldDiskCachePath(), GetDiskCachePath(), kMaxDiskCacheSize,
-        base::ThreadTaskRunnerHandle::Get()));
+        storage()->GetOldDiskCachePath(), storage()->GetDiskCachePath(),
+        kMaxDiskCacheSize, base::ThreadTaskRunnerHandle::Get()));
   }
 
   bool WriteResponse(ServiceWorkerDiskCache* disk_cache,
                      const ResponseData& response) {
     scoped_ptr<ServiceWorkerResponseWriter> writer(
         new ServiceWorkerResponseWriter(response.resource_id, disk_cache));
 
     // Write the response info.
     scoped_ptr<net::HttpResponseInfo> info(new net::HttpResponseInfo);
     info->request_time = base::Time() + base::TimeDelta::FromSeconds(10);
@@ skipping 69 matching lines @@
     reader->ReadData(body_buffer.get(), kBigEnough, cb2.callback());
     rv = cb2.WaitForResult();
     ASSERT_EQ(static_cast<int>(expected.body.length()), rv);
     EXPECT_EQ(0, memcmp(expected.body.data(), body_buffer->data(), rv));
   }
 
   int32 GetEntryCount(ServiceWorkerDiskCache* disk_cache) {
     return disk_cache->disk_cache()->GetEntryCount();
   }
 
+  ServiceWorkerStorage* storage() { return context_->storage(); }
+
  private:
   TestBrowserThreadBundle browser_thread_bundle_;
   base::ScopedTempDir user_data_directory_;
 
   scoped_ptr<ServiceWorkerContextCore> context_;
 };
 
 TEST_F(ServiceWorkerDiskCacheMigratorTest, MigrateDiskCache) {
   std::vector<ResponseData> responses;
   responses.push_back(ResponseData(1, "HTTP/1.1 200 OK\0\0", "Hello", ""));
@@ skipping 111 matching lines @@
   migrator->Start(base::Bind(&OnDiskCacheMigrated, run_loop.QuitClosure()));
   run_loop.Run();
 
   // Verify the migrated contents in the dest diskcache.
   scoped_ptr<ServiceWorkerDiskCache> dest(CreateDestDiskCache());
   for (const ResponseData& response : responses)
     VerifyResponse(dest.get(), response);
   EXPECT_EQ(static_cast<int>(responses.size()), GetEntryCount(dest.get()));
 }
 
+TEST_F(ServiceWorkerDiskCacheMigratorTest, MigrateOnDiskCacheAccess) {
+  std::vector<ResponseData> responses;
+  responses.push_back(ResponseData(1, "HTTP/1.1 200 OK\0\0", "Hello", ""));
+  responses.push_back(ResponseData(2, "HTTP/1.1 200 OK\0\0", "Service", ""));
+  responses.push_back(ResponseData(5, "HTTP/1.1 200 OK\0\0", "Worker", ""));
+  responses.push_back(ResponseData(3, "HTTP/1.1 200 OK\0\0", "World", "meta"));
+
+  // Populate initial resources in the src diskcache.
+  scoped_ptr<ServiceWorkerDiskCache> src(CreateSrcDiskCache());
+  for (const ResponseData& response : responses) {
+    ASSERT_TRUE(WriteResponse(src.get(), response));
+    VerifyResponse(src.get(), response);
+  }
+  ASSERT_EQ(static_cast<int>(responses.size()), GetEntryCount(src.get()));
+  ASSERT_TRUE(base::DirectoryExists(storage()->GetOldDiskCachePath()));
+  src.reset();
+
+  scoped_ptr<ServiceWorkerDatabase> database(
+      new ServiceWorkerDatabase(storage()->GetDatabasePath()));
+
+  // This is necessary to make the storage schedule diskcache migration.
+  database->set_skip_writing_diskcache_migration_state_on_init_for_testing();
+
+  // Simulate an existing database.
+  std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
+  resources.push_back(ServiceWorkerDatabase::ResourceRecord(
+      1, GURL("https://example.com/foo"), 10));
+  ServiceWorkerDatabase::RegistrationData deleted_version;
+  std::vector<int64> newly_purgeable_resources;
+  ServiceWorkerDatabase::RegistrationData data;
+  data.registration_id = 100;
+  data.scope = GURL("https://example.com/");
+  data.script = GURL("https://example.com/script.js");
+  data.version_id = 200;
+  data.resources_total_size_bytes = 10;
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data, resources, &deleted_version,
+                                        &newly_purgeable_resources));
+  database.reset();
+
+  // LazyInitialize() reads initial data and should schedule to migrate.
+  ASSERT_FALSE(storage()->disk_cache_migration_needed_);
+  base::RunLoop run_loop;
+  storage()->LazyInitialize(run_loop.QuitClosure());
+  run_loop.Run();
+  EXPECT_TRUE(storage()->disk_cache_migration_needed_);
+
+  // DiskCache access should start the migration.
+  ServiceWorkerDiskCache* dest = storage()->disk_cache();
+
+  // Verify the migrated contents in the dest diskcache.
+  for (const ResponseData& response : responses)
+    VerifyResponse(dest, response);
+  EXPECT_EQ(static_cast<int>(responses.size()), GetEntryCount(dest));
+
+  // After the migration, the src diskcache should be deleted.
+  EXPECT_FALSE(base::DirectoryExists(storage()->GetOldDiskCachePath()));
+
+  // After the migration, the migration state should be updated.
+  bool migration_needed = false;
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      storage()->database_->IsDiskCacheMigrationNeeded(&migration_needed));
+  EXPECT_FALSE(migration_needed);
+  bool deletion_needed = false;
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      storage()->database_->IsOldDiskCacheDeletionNeeded(&deletion_needed));
+  EXPECT_FALSE(deletion_needed);
+}
+
+TEST_F(ServiceWorkerDiskCacheMigratorTest, NotMigrateOnDatabaseAccess) {
+  std::vector<ResponseData> responses;
+  responses.push_back(ResponseData(1, "HTTP/1.1 200 OK\0\0", "Hello", ""));
+  responses.push_back(ResponseData(2, "HTTP/1.1 200 OK\0\0", "Service", ""));
+  responses.push_back(ResponseData(5, "HTTP/1.1 200 OK\0\0", "Worker", ""));
+  responses.push_back(ResponseData(3, "HTTP/1.1 200 OK\0\0", "World", "meta"));
+
+  // Populate initial resources in the src diskcache.
+  scoped_ptr<ServiceWorkerDiskCache> src(CreateSrcDiskCache());
+  for (const ResponseData& response : responses) {
+    ASSERT_TRUE(WriteResponse(src.get(), response));
+    VerifyResponse(src.get(), response);
+  }
+  ASSERT_EQ(static_cast<int>(responses.size()), GetEntryCount(src.get()));
+  ASSERT_TRUE(base::DirectoryExists(storage()->GetOldDiskCachePath()));
+
+  scoped_ptr<ServiceWorkerDatabase> database(
+      new ServiceWorkerDatabase(storage()->GetDatabasePath()));
+
+  // This is necessary to make the storage schedule diskcache migration.
+  database->set_skip_writing_diskcache_migration_state_on_init_for_testing();
+
+  // Simulate an existing database.
+  std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
+  resources.push_back(ServiceWorkerDatabase::ResourceRecord(
+      1, GURL("https://example.com/foo"), 10));
+  ServiceWorkerDatabase::RegistrationData deleted_version;
+  std::vector<int64> newly_purgeable_resources;
+  ServiceWorkerDatabase::RegistrationData data;
+  data.registration_id = 100;
+  data.scope = GURL("https://example.com/");
+  data.script = GURL("https://example.com/script.js");
+  data.version_id = 200;
+  data.resources_total_size_bytes = 10;
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data, resources, &deleted_version,
+                                        &newly_purgeable_resources));
+  database.reset();
+
+  // LazyInitialize() reads initial data and should schedule to migrate.
+  ASSERT_FALSE(storage()->disk_cache_migration_needed_);
+  base::RunLoop run_loop1;
+  storage()->LazyInitialize(run_loop1.QuitClosure());
+  run_loop1.Run();
+  EXPECT_TRUE(storage()->disk_cache_migration_needed_);
+
+  // Database access should not start the migration.
+  base::RunLoop run_loop2;
+  storage()->FindRegistrationForDocument(
+      GURL("http://example.com/"),
+      base::Bind(&OnRegistrationFound, run_loop2.QuitClosure()));
+  run_loop2.Run();
+
+  // Verify that the migration didn't happen.
+  scoped_ptr<ServiceWorkerDiskCache> dest(CreateDestDiskCache());
+  EXPECT_EQ(static_cast<int>(responses.size()), GetEntryCount(src.get()));
+  EXPECT_EQ(0, GetEntryCount(dest.get()));
+  EXPECT_TRUE(base::DirectoryExists(storage()->GetOldDiskCachePath()));
+}
+
+TEST_F(ServiceWorkerDiskCacheMigratorTest, NotMigrateForEmptyDatabase) {
+  std::vector<ResponseData> responses;
+  responses.push_back(ResponseData(1, "HTTP/1.1 200 OK\0\0", "Hello", ""));
+  responses.push_back(ResponseData(2, "HTTP/1.1 200 OK\0\0", "Service", ""));
+  responses.push_back(ResponseData(5, "HTTP/1.1 200 OK\0\0", "Worker", ""));
+  responses.push_back(ResponseData(3, "HTTP/1.1 200 OK\0\0", "World", "meta"));
+
+  // Populate initial resources in the src diskcache.
+  scoped_ptr<ServiceWorkerDiskCache> src(CreateSrcDiskCache());
+  for (const ResponseData& response : responses) {
+    ASSERT_TRUE(WriteResponse(src.get(), response));
+    VerifyResponse(src.get(), response);
+  }
+  ASSERT_EQ(static_cast<int>(responses.size()), GetEntryCount(src.get()));
+  ASSERT_TRUE(base::DirectoryExists(storage()->GetOldDiskCachePath()));
+  src.reset();
+
+  // LazyInitialize() reads initial data and should not schedule to migrate
+  // because the database is empty.
+  ASSERT_FALSE(storage()->disk_cache_migration_needed_);
+  base::RunLoop run_loop;
+  storage()->LazyInitialize(run_loop.QuitClosure());
+  run_loop.Run();
+  EXPECT_FALSE(storage()->disk_cache_migration_needed_);
+
+  // DiskCache access should not start the migration.
+  ServiceWorkerDiskCache* dest = storage()->disk_cache();
+
+  // Verify that the migration didn't happen.
+  src = CreateSrcDiskCache();
+  for (const ResponseData& response : responses)
+    VerifyResponse(src.get(), response);
+  EXPECT_EQ(static_cast<int>(responses.size()), GetEntryCount(src.get()));
+  EXPECT_TRUE(base::DirectoryExists(storage()->GetOldDiskCachePath()));
+  EXPECT_EQ(0, GetEntryCount(dest));
+
+  // After the diskcache initialization, the migration state should be updated.
+  bool migration_needed = false;
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      storage()->database_->IsDiskCacheMigrationNeeded(&migration_needed));
+  EXPECT_FALSE(migration_needed);
+  bool deletion_needed = false;
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      storage()->database_->IsOldDiskCacheDeletionNeeded(&deletion_needed));
+  EXPECT_FALSE(deletion_needed);
+}
+
 }  // namespace content