Discard uncommitted changes when shutting down DOMStorageArea

content/browser/dom_storage/dom_storage_context_impl_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 "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 84 matching lines @@
 TEST_F(DOMStorageContextImplTest, UsageInfo) {
   // Should be empty initially
   std::vector<LocalStorageUsageInfo> infos;
   context_->GetLocalStorageUsage(&infos, kDontIncludeFileInfo);
   EXPECT_TRUE(infos.empty());
   context_->GetLocalStorageUsage(&infos, kDoIncludeFileInfo);
   EXPECT_TRUE(infos.empty());
 
   // Put some data into local storage and shutdown the context
   // to ensure data is written to disk.
+  auto* area = context_->GetStorageNamespace(kLocalStorageNamespaceId)->
+      OpenStorageArea(kOrigin);
   base::NullableString16 old_value;
-  EXPECT_TRUE(context_->GetStorageNamespace(kLocalStorageNamespaceId)->
-      OpenStorageArea(kOrigin)->SetItem(kKey, kValue, &old_value));
+  EXPECT_TRUE(area->SetItem(kKey, kValue, &old_value));
+  area->ScheduleImmediateCommit();
   context_->Shutdown();
   context_ = NULL;
   base::MessageLoop::current()->RunUntilIdle();
 
   // Create a new context that points to the same directory, see that
   // it knows about the origin that we stored data for.
   context_ = new DOMStorageContextImpl(temp_dir_.path(), base::FilePath(),
                                        NULL, NULL);
   context_->GetLocalStorageUsage(&infos, kDontIncludeFileInfo);
   EXPECT_EQ(1u, infos.size());
   EXPECT_EQ(kOrigin, infos[0].origin);
   EXPECT_EQ(0u, infos[0].data_size);
   EXPECT_EQ(base::Time(), infos[0].last_modified);
   infos.clear();
   context_->GetLocalStorageUsage(&infos, kDoIncludeFileInfo);
   EXPECT_EQ(1u, infos.size());
   EXPECT_EQ(kOrigin, infos[0].origin);
   EXPECT_NE(0u, infos[0].data_size);
   EXPECT_NE(base::Time(), infos[0].last_modified);
 }
 
 TEST_F(DOMStorageContextImplTest, SessionOnly) {
   const GURL kSessionOnlyOrigin("http://www.sessiononly.com/");
   storage_policy_->AddSessionOnly(kSessionOnlyOrigin);
 
   // Store data for a normal and a session-only origin and then
   // invoke Shutdown() which should delete data for session-only
   // origins.
+  auto* dom_namespace = context_->GetStorageNamespace(kLocalStorageNamespaceId);
   base::NullableString16 old_value;
-  EXPECT_TRUE(context_->GetStorageNamespace(kLocalStorageNamespaceId)->
-      OpenStorageArea(kOrigin)->SetItem(kKey, kValue, &old_value));
-  EXPECT_TRUE(context_->GetStorageNamespace(kLocalStorageNamespaceId)->
-      OpenStorageArea(kSessionOnlyOrigin)->SetItem(kKey, kValue, &old_value));
+  auto* area = dom_namespace->OpenStorageArea(kOrigin);
+  EXPECT_TRUE(area->SetItem(kKey, kValue, &old_value));
+  area->ScheduleImmediateCommit();
+  auto* session_only_area = dom_namespace->OpenStorageArea(kSessionOnlyOrigin);
+  EXPECT_TRUE(session_only_area->SetItem(kKey, kValue, &old_value));
+  session_only_area->ScheduleImmediateCommit();
   context_->Shutdown();
   context_ = NULL;
   base::MessageLoop::current()->RunUntilIdle();
 
   // Verify that the session-only origin data is gone.
   VerifySingleOriginRemains(kOrigin);
 }
 
 TEST_F(DOMStorageContextImplTest, SetForceKeepSessionState) {
   const GURL kSessionOnlyOrigin("http://www.sessiononly.com/");
   storage_policy_->AddSessionOnly(kSessionOnlyOrigin);
 
   // Store data for a session-only origin, setup to save session data, then
   // shutdown.
+  auto* area = context_->GetStorageNamespace(kLocalStorageNamespaceId)->
+      OpenStorageArea(kSessionOnlyOrigin);
   base::NullableString16 old_value;
-  EXPECT_TRUE(context_->GetStorageNamespace(kLocalStorageNamespaceId)->
-      OpenStorageArea(kSessionOnlyOrigin)->SetItem(kKey, kValue, &old_value));
+  EXPECT_TRUE(area->SetItem(kKey, kValue, &old_value));
+  area->ScheduleImmediateCommit();
   context_->SetForceKeepSessionState();  // Should override clear behavior.
   context_->Shutdown();
   context_ = NULL;
   base::MessageLoop::current()->RunUntilIdle();
 
   VerifySingleOriginRemains(kSessionOnlyOrigin);
 }
 
 TEST_F(DOMStorageContextImplTest, PersistentIds) {
   const int kFirstSessionStorageNamespaceId = 1 + session_id_offset();
@@ skipping 38 matching lines @@
   const std::string kPersistentId = "persistent";
   context_->CreateSessionNamespace(kSessionStorageNamespaceId,
                                    kPersistentId);
   DOMStorageNamespace* dom_namespace =
       context_->GetStorageNamespace(kSessionStorageNamespaceId);
   DOMStorageArea* area = dom_namespace->OpenStorageArea(kOrigin);
   const base::string16 kKey(ASCIIToUTF16("foo"));
   const base::string16 kValue(ASCIIToUTF16("bar"));
   base::NullableString16 old_nullable_value;
   area->SetItem(kKey, kValue, &old_nullable_value);
+  area->ScheduleImmediateCommit();
   dom_namespace->CloseStorageArea(area);
 
   // Destroy and recreate the DOMStorageContextImpl.
   context_->Shutdown();
   context_ = NULL;
   base::MessageLoop::current()->RunUntilIdle();
   context_ = new DOMStorageContextImpl(
       temp_dir_.path(), temp_dir_.path(),
       storage_policy_.get(), task_runner_.get());
   context_->SetSaveSessionStorageOnDisk();
 
   // Read the data back.
   context_->CreateSessionNamespace(kSessionStorageNamespaceId,
                                    kPersistentId);
   dom_namespace = context_->GetStorageNamespace(kSessionStorageNamespaceId);
   area = dom_namespace->OpenStorageArea(kOrigin);
   base::NullableString16 read_value;
   read_value = area->GetItem(kKey);
   EXPECT_EQ(kValue, read_value.string());
   dom_namespace->CloseStorageArea(area);
 
   SessionStorageUsageInfo info;
   info.origin = kOrigin;
   info.persistent_namespace_id = kPersistentId;
   context_->DeleteSessionStorage(info);
+  area->ScheduleImmediateCommit();
 
   // Destroy and recreate again.
   context_->Shutdown();
   context_ = NULL;
   base::MessageLoop::current()->RunUntilIdle();
   context_ = new DOMStorageContextImpl(
       temp_dir_.path(), temp_dir_.path(),
       storage_policy_.get(), task_runner_.get());
   context_->SetSaveSessionStorageOnDisk();
 
   // Now there should be no data.
   context_->CreateSessionNamespace(kSessionStorageNamespaceId,
                                    kPersistentId);
   dom_namespace = context_->GetStorageNamespace(kSessionStorageNamespaceId);
   area = dom_namespace->OpenStorageArea(kOrigin);
   read_value = area->GetItem(kKey);
   EXPECT_TRUE(read_value.is_null());
   dom_namespace->CloseStorageArea(area);
   context_->Shutdown();
   context_ = NULL;
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 }  // namespace content