ServiceWorker: Run ServiceWorkerContextTest.DeleteAndStartOver on disk

content/browser/service_worker/service_worker_context_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/public/browser/service_worker_context.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "content/browser/browser_thread_impl.h"
@@ skipping 61 matching lines @@
   if (expect_active) {
     EXPECT_TRUE(registration->active_version());
   } else {
     EXPECT_FALSE(registration->active_version());
   }
 }
 
 class RejectInstallTestHelper : public EmbeddedWorkerTestHelper {
  public:
   explicit RejectInstallTestHelper(int mock_render_process_id)
-      : EmbeddedWorkerTestHelper(mock_render_process_id) {}
+      : EmbeddedWorkerTestHelper(base::FilePath(), mock_render_process_id) {}
 
   void OnInstallEvent(int embedded_worker_id,
                       int request_id) override {
     SimulateSend(
         new ServiceWorkerHostMsg_InstallEventFinished(
             embedded_worker_id, request_id,
             blink::WebServiceWorkerEventResultRejected));
   }
 };
 
 class RejectActivateTestHelper : public EmbeddedWorkerTestHelper {
  public:
   explicit RejectActivateTestHelper(int mock_render_process_id)
-      : EmbeddedWorkerTestHelper(mock_render_process_id) {}
+      : EmbeddedWorkerTestHelper(base::FilePath(), mock_render_process_id) {}
 
   void OnActivateEvent(int embedded_worker_id, int request_id) override {
     SimulateSend(
         new ServiceWorkerHostMsg_ActivateEventFinished(
             embedded_worker_id, request_id,
             blink::WebServiceWorkerEventResultRejected));
   }
 };
 
 enum NotificationType {
@@ skipping 11 matching lines @@
 }  // namespace
 
 class ServiceWorkerContextTest : public ServiceWorkerContextObserver,
                                  public testing::Test {
  public:
   ServiceWorkerContextTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
         render_process_id_(99) {}
 
   void SetUp() override {
-    helper_.reset(new EmbeddedWorkerTestHelper(render_process_id_));
+    helper_.reset(
+        new EmbeddedWorkerTestHelper(base::FilePath(), render_process_id_));
     helper_->context_wrapper()->AddObserver(this);
   }
 
   void TearDown() override { helper_.reset(); }
 
   // ServiceWorkerContextObserver overrides.
   void OnRegistrationStored(int64 registration_id,
                             const GURL& pattern) override {
     NotificationLog log;
     log.type = REGISTRATION_STORED;
@@ skipping 373 matching lines @@
 
   ASSERT_EQ(2u, notifications_.size());
   EXPECT_EQ(REGISTRATION_STORED, notifications_[0].type);
   EXPECT_EQ(pattern, notifications_[0].pattern);
   EXPECT_EQ(old_registration_id, notifications_[0].registration_id);
   EXPECT_EQ(REGISTRATION_STORED, notifications_[1].type);
   EXPECT_EQ(pattern, notifications_[1].pattern);
   EXPECT_EQ(old_registration_id, notifications_[1].registration_id);
 }
 
-// TODO(nhiroki): Test this for on-disk storage.
 TEST_F(ServiceWorkerContextTest, DeleteAndStartOver) {
   GURL pattern("http://www.example.com/");
   GURL script_url("http://www.example.com/service_worker.js");
 
+  // Reinitialize the helper to test on-disk storage.
+  base::ScopedTempDir user_data_directory;
+  ASSERT_TRUE(user_data_directory.CreateUniqueTempDir());
+  helper_.reset(new EmbeddedWorkerTestHelper(user_data_directory.path(),
+                                             render_process_id_));
+  helper_->context_wrapper()->AddObserver(this);
+
   int64 registration_id = kInvalidServiceWorkerRegistrationId;
   bool called = false;
   context()->RegisterServiceWorker(
       pattern,
       script_url,
       NULL,
       MakeRegisteredCallback(&called, &registration_id));
 
   ASSERT_FALSE(called);
   base::RunLoop().RunUntilIdle();
@@ skipping 138 matching lines @@
   EXPECT_EQ(1u, results.size());
   EXPECT_TRUE(ContainsKey(results, host2));
 
   context()->RemoveProviderHost(kRenderProcessId1, 1);
   context()->RemoveProviderHost(kRenderProcessId2, 2);
   context()->RemoveProviderHost(kRenderProcessId2, 3);
   context()->RemoveProviderHost(kRenderProcessId2, 4);
 }
 
 }  // namespace content