Service Worker: Respect the "clear on exit" content setting

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 <string>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_disk_cache.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_storage.h"
 #include "content/browser/service_worker/service_worker_utils.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/service_worker/service_worker_status_code.h"
+#include "content/public/test/mock_special_storage_policy.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"
 
 using net::IOBuffer;
 using net::TestCompletionCallback;
 using net::WrappedIOBuffer;
@@ skipping 156 matching lines @@
 
 }  // namespace
 
 class ServiceWorkerStorageTest : public testing::Test {
  public:
   ServiceWorkerStorageTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {
   }
 
   virtual void SetUp() OVERRIDE {
+    special_storage_policy_ = new MockSpecialStoragePolicy();
     context_.reset(
         new ServiceWorkerContextCore(GetUserDataDirectory(),
                                      base::ThreadTaskRunnerHandle::Get(),
                                      base::ThreadTaskRunnerHandle::Get(),
                                      base::ThreadTaskRunnerHandle::Get(),
                                      NULL,
+                                     special_storage_policy_.get(),
                                      NULL,
                                      NULL));
     context_ptr_ = context_->AsWeakPtr();
   }
 
   virtual void TearDown() OVERRIDE {
     context_.reset();
   }
 
   virtual base::FilePath GetUserDataDirectory() { return base::FilePath(); }
@@ skipping 102 matching lines @@
     storage()->FindRegistrationForId(
         registration_id, origin,
         MakeFindCallback(&was_called, &result, registration));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
   scoped_ptr<ServiceWorkerContextCore> context_;
   base::WeakPtr<ServiceWorkerContextCore> context_ptr_;
+  scoped_refptr<MockSpecialStoragePolicy> special_storage_policy_;
   TestBrowserThreadBundle browser_thread_bundle_;
 };
 
 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 int64 kRegistrationId = 0;
   const int64 kVersionId = 0;
   const base::Time kToday = base::Time::Now();
@@ skipping 476 matching lines @@
 
   // Simulate browser shutdown. The purgeable and uncommitted resources are now
   // stale.
   context_.reset();
   context_.reset(
       new ServiceWorkerContextCore(GetUserDataDirectory(),
                                    base::ThreadTaskRunnerHandle::Get(),
                                    base::ThreadTaskRunnerHandle::Get(),
                                    base::ThreadTaskRunnerHandle::Get(),
                                    NULL,
+                                   special_storage_policy_.get(),
                                    NULL,
                                    NULL));
   storage()->LazyInitialize(base::Bind(&base::DoNothing));
   base::RunLoop().RunUntilIdle();
 
   // Store a new uncommitted resource. This triggers stale resource cleanup.
   int64 kNewResourceId = storage()->NewResourceId();
   WriteBasicResponse(storage(), kNewResourceId);
   storage()->StoreUncommittedResponseId(kNewResourceId);
   base::RunLoop().RunUntilIdle();
 
   // The stale resources should be purged, but the new resource should persist.
   verify_ids.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             storage()->database_->GetUncommittedResourceIds(&verify_ids));
   ASSERT_EQ(1u, verify_ids.size());
   EXPECT_EQ(kNewResourceId, *verify_ids.begin());
 
   verify_ids.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             storage()->database_->GetPurgeableResourceIds(&verify_ids));
   EXPECT_TRUE(verify_ids.empty());
   EXPECT_FALSE(VerifyBasicResponse(storage(), resource_id1_, false));
   EXPECT_FALSE(VerifyBasicResponse(storage(), resource_id2_, false));
   EXPECT_FALSE(
       VerifyBasicResponse(storage(), kStaleUncommittedResourceId, false));
   EXPECT_TRUE(VerifyBasicResponse(storage(), kNewResourceId, true));
 }
 
+TEST_F(ServiceWorkerResourceStorageDiskTest, ClearOnExit) {
+  // Store a new registration.
+  GURL cleared_scope("http://www.test.clear/scope/");
+  GURL cleared_script("http://www.test.clear/script.js");
+  int64 cleared_registration_id = storage()->NewRegistrationId();
+  int64 cleared_version_id = storage()->NewVersionId();
+
+  RegistrationData data;
+  data.registration_id = cleared_registration_id;
+  data.scope = cleared_scope;
+  data.script = cleared_script;
+  data.version_id = cleared_version_id;
+  data.is_active = false;
+
+  scoped_refptr<ServiceWorkerRegistration> cleared_registration =
+      storage()->GetOrCreateRegistration(data, std::vector<ResourceRecord>());
+  cleared_registration->waiting_version()->SetStatus(ServiceWorkerVersion::NEW);

[michaeln1, 2014/10/08 19:28:57]

to more closely mimic actual usage, i think the waiting versions status should
be INSTALLED

+  EXPECT_EQ(SERVICE_WORKER_OK,
+            StoreRegistration(cleared_registration,
+                              cleared_registration->waiting_version()));
+
+  // Set its origin as session-only.
+  special_storage_policy_->AddSessionOnly(cleared_scope.GetOrigin());
+
+  // Simulate browser restart.
+  context_.reset();
+  context_.reset(
+      new ServiceWorkerContextCore(GetUserDataDirectory(),
+                                   base::ThreadTaskRunnerHandle::Get(),
+                                   base::ThreadTaskRunnerHandle::Get(),
+                                   base::ThreadTaskRunnerHandle::Get(),
+                                   NULL,
+                                   special_storage_policy_.get(),
+                                   NULL,
+                                   NULL));
+  storage()->LazyInitialize(base::Bind(&base::DoNothing));
+  base::RunLoop().RunUntilIdle();
+
+  // Verify that only the session-only origin is gone.
+  scoped_refptr<ServiceWorkerRegistration> found_registration;
+  EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
+            FindRegistrationForId(cleared_registration_id,

[michaeln1, 2014/10/08 19:28:57]

maybe test that it actually can be found prior to similating restart

+                                  cleared_scope.GetOrigin(),
+                                  &found_registration));
+  EXPECT_EQ(SERVICE_WORKER_OK,
+            FindRegistrationForId(
+                registration_id_, scope_.GetOrigin(), &found_registration));
+}
+
 TEST_F(ServiceWorkerResourceStorageTest, UpdateRegistration) {
   // Promote the worker to active worker and add a controllee.
   registration_->SetActiveVersion(registration_->waiting_version());
   storage()->UpdateToActiveState(
       registration_.get(), base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   scoped_ptr<ServiceWorkerProviderHost> host(
       new ServiceWorkerProviderHost(33 /* dummy render process id */,
                                     1 /* dummy provider_id */,
                                     context_->AsWeakPtr(),
                                     NULL));
@@ skipping 180 matching lines @@
   are_equal = true;
   storage()->CompareScriptResources(
       5, 6,
       base::Bind(&OnCompareComplete, &status, &are_equal));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_FALSE(are_equal);
 }
 
 }  // namespace content