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 "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"
 #include "net/http/http_response_headers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
@@ skipping 24 matching lines @@
 
 }  // namespace
 
 class ServiceWorkerDiskCacheMigratorTest : public testing::Test {
  public:
   ServiceWorkerDiskCacheMigratorTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {}
 
   void SetUp() override {
     ASSERT_TRUE(user_data_directory_.CreateUniqueTempDir());
-    const base::FilePath kSrcDiskCachePath =
-        user_data_directory_.path().AppendASCII("SrcCache");
-    const base::FilePath kDestDiskCachePath =
-        user_data_directory_.path().AppendASCII("DestCache");
+    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));
+    ServiceWorkerStorage* storage = context_->storage();
 
     // Initialize the src BlockFile diskcache.
     src_ = ServiceWorkerDiskCache::CreateWithBlockFileBackend();
     net::TestCompletionCallback cb1;
     src_->InitWithDiskBackend(
-        kSrcDiskCachePath, kMaxDiskCacheSize, false /* force */,
+        storage->GetOldDiskCachePath(), kMaxDiskCacheSize, false /* force */,
         base::ThreadTaskRunnerHandle::Get(), cb1.callback());
     ASSERT_EQ(net::OK, cb1.WaitForResult());
 
     // Initialize the dest Simple diskcache.
     dest_ = ServiceWorkerDiskCache::CreateWithSimpleBackend();
     net::TestCompletionCallback cb2;
     dest_->InitWithDiskBackend(
-        kDestDiskCachePath, kMaxDiskCacheSize, false /* force */,
+        storage->GetDiskCachePath(), kMaxDiskCacheSize, false /* force */,
         base::ThreadTaskRunnerHandle::Get(), cb2.callback());
     ASSERT_EQ(net::OK, cb2.WaitForResult());
 
     migrator_.reset(
         new ServiceWorkerDiskCacheMigrator(src_.get(), dest_.get()));
   }
 
   bool WriteResponse(ServiceWorkerDiskCache* disk_cache,
                      const ResponseData& response) {
     scoped_ptr<ServiceWorkerResponseWriter> writer(
@@ skipping 84 matching lines @@
   }
 
   int32 GetEntryCount(ServiceWorkerDiskCache* disk_cache) {
     return disk_cache->disk_cache()->GetEntryCount();
   }
 
   void SetMaxNumberOfInflightTasks(size_t max_number) {
     migrator_->set_max_number_of_inflight_tasks(max_number);
   }
 
+  void LazyInitialize() {
+    base::RunLoop run_loop;
+    context_->storage()->LazyInitialize(run_loop.QuitClosure());
+    run_loop.Run();
+  }
+
+  base::FilePath GetSrcDiskCachePath() {
+    return context_->storage()->GetOldDiskCachePath();
+  }
+
+  ServiceWorkerDiskCache* disk_cache() {
+    return context_->storage()->disk_cache();
+  }
+
  protected:
   TestBrowserThreadBundle browser_thread_bundle_;
   base::ScopedTempDir user_data_directory_;
+
+  scoped_ptr<ServiceWorkerContextCore> context_;
+
   scoped_ptr<ServiceWorkerDiskCache> src_;
   scoped_ptr<ServiceWorkerDiskCache> dest_;
   scoped_ptr<ServiceWorkerDiskCacheMigrator> migrator_;
 };
 
 TEST_F(ServiceWorkerDiskCacheMigratorTest, Basic) {
   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", ""));
@@ skipping 38 matching lines @@
 
   // Migration should hit the limit, but not crash.
   StartMigration();
 
   // Verify the migrated contents in the dest diskcache.
   for (const ResponseData& response : responses)
     VerifyResponse(dest_.get(), response);
   EXPECT_EQ(static_cast<int>(responses.size()), GetEntryCount(dest_.get()));
 }
 
+TEST_F(ServiceWorkerDiskCacheMigratorTest, MigrateDuringLazyInitialize) {
+  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 data in the src diskcache.
+  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(GetSrcDiskCachePath()));
+
+  // LazyInitialize ignites the migrator.
+  LazyInitialize();

[kinuko, 2015/06/02 06:18:52]

Is it possible to also test that concurrent requests made during LazyInitialize
are delayed until the migration's done?

[kinuko, 2015/06/02 06:18:52]

Did you check the local histogram to see how long it took?

[nhiroki, 2015/06/02 09:18:32]

Done.

[nhiroki, 2015/06/02 09:18:32]

I tried the migration 3 times (Linux, SSD, Release build) and checked its local
histograms:

- NumberOfMigratedResources: 4
- MigrationTime: 7 msec, 7 msec, 8 msec

Instructions:
(1) Build chromium without this patch
(2) Browse Trained-to-Thrill, SVGOMG and SimplePushDemo (4 resources are cached)
(3) Build chromium with this patch
(4) Open chromium and start the migration
(5) Check "chrome://histograms"

+
+  // Verify the migrated contents in the dest diskcache.
+  for (const ResponseData& response : responses)
+    VerifyResponse(disk_cache(), response);
+  EXPECT_EQ(static_cast<int>(responses.size()), GetEntryCount(disk_cache()));
+
+  // The src DiskCache should be deleted after migration.
+  EXPECT_FALSE(base::DirectoryExists(GetSrcDiskCachePath()));
+}
+

[falken, 2015/06/01 04:31:49]

Should we also do a test for if the migration fails?

[nhiroki, 2015/06/02 09:18:32]

I haven't found a handy way to fail the migration yet... (still investigating)

 }  // namespace content