Add suborigin logic to url::Origin

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/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "content/browser/dom_storage/dom_storage_area.h"
 #include "content/browser/dom_storage/dom_storage_context_impl.h"
 #include "content/browser/dom_storage/dom_storage_namespace.h"
 #include "content/browser/dom_storage/dom_storage_task_runner.h"
 #include "content/public/browser/local_storage_usage_info.h"
 #include "content/public/browser/session_storage_usage_info.h"
 #include "content/public/test/mock_special_storage_policy.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+#include "url/origin.h"
 
 using base::ASCIIToUTF16;
 
 namespace content {
 
 class DOMStorageContextImplTest : public testing::Test {
  public:
   DOMStorageContextImplTest()
-    : kOrigin(GURL("http://dom_storage/")),
-      kKey(ASCIIToUTF16("key")),
-      kValue(ASCIIToUTF16("value")),
-      kDontIncludeFileInfo(false),
-      kDoIncludeFileInfo(true) {
-  }
+      : kOrigin(GURL("http://dom_storage/")),
+        kSuborigin(GURL("http-so://foobar.dom_storage/")),
+        kKey(ASCIIToUTF16("key")),
+        kValue(ASCIIToUTF16("value")),
+        kDontIncludeFileInfo(false),
+        kDoIncludeFileInfo(true) {}
 
   const GURL kOrigin;
+  const GURL kSuborigin;
   const base::string16 kKey;
   const base::string16 kValue;
   const bool kDontIncludeFileInfo;
   const bool kDoIncludeFileInfo;
 
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     storage_policy_ = new MockSpecialStoragePolicy;
     task_runner_ =
         new MockDOMStorageTaskRunner(base::ThreadTaskRunnerHandle::Get().get());
@@ skipping 241 matching lines @@
   // Call commit directly instead of posting task.
   area2->CommitChanges(area2->commit_batch_.get());
   area2->commit_batch_ = nullptr;
 
   // PURGE_AGGRESSIVE clears the cache in the open area.
   EXPECT_NE(0u, dom_namespace->GetUsageStatistics().total_cache_size);
   context_->PurgeMemory(DOMStorageContextImpl::PURGE_AGGRESSIVE);
   EXPECT_EQ(0u, dom_namespace->GetUsageStatistics().total_cache_size);
 }
 
+// Verifies that deleting the local storage for an origin will delete any
+// suborigins also present, and similarly, deleting a suborigin will delete the
+// physical origin as well.
+TEST_F(DOMStorageContextImplTest, DeleteSuboriginLocalStorage) {
+  context_->Shutdown();
+  context_ =
+      new DOMStorageContextImpl(temp_dir_.GetPath(), temp_dir_.GetPath(),
+                                storage_policy_.get(), task_runner_.get());
+
+  DOMStorageNamespace* dom_namespace =
+      context_->GetStorageNamespace(kLocalStorageNamespaceId);
+  DOMStorageArea* origin_area = dom_namespace->OpenStorageArea(kOrigin);
+  DOMStorageArea* suborigin_area = dom_namespace->OpenStorageArea(kSuborigin);
+
+  const base::string16 kOriginKey(ASCIIToUTF16("foo"));
+  const base::string16 kOriginValue(ASCIIToUTF16("bar"));
+  const base::string16 kSuboriginKey(ASCIIToUTF16("foz"));
+  const base::string16 kSuboriginValue(ASCIIToUTF16("baz"));
+  base::NullableString16 old_nullable_value;
+
+  // Setup data for the first deletion (of the origin rather than the suborigin)
+  origin_area->SetItem(kOriginKey, kOriginValue, &old_nullable_value);
+  suborigin_area->SetItem(kSuboriginKey, kSuboriginValue, &old_nullable_value);
+
+  base::NullableString16 read_value;
+  read_value = origin_area->GetItem(kOriginKey);
+  EXPECT_EQ(kOriginValue, read_value.string());
+  read_value = suborigin_area->GetItem(kSuboriginKey);
+  EXPECT_EQ(kSuboriginValue, read_value.string());
+
+  // Deleting the data for the physical origin should delete the data in the
+  // suborigin as  well.
+  context_->DeleteLocalStorageForPhysicalOrigin(kOrigin);
+
+  read_value = origin_area->GetItem(kOriginKey);
+  EXPECT_TRUE(read_value.is_null());
+  read_value = suborigin_area->GetItem(kSuboriginKey);
+  EXPECT_TRUE(read_value.is_null());
+
+  // Setup data again for the second deletion (of the suborigin rather than the
+  // origin)
+  origin_area->SetItem(kOriginKey, kOriginValue, &old_nullable_value);
+  suborigin_area->SetItem(kSuboriginKey, kSuboriginValue, &old_nullable_value);
+
+  read_value = origin_area->GetItem(kOriginKey);
+  EXPECT_EQ(kOriginValue, read_value.string());
+  read_value = suborigin_area->GetItem(kSuboriginKey);
+  EXPECT_EQ(kSuboriginValue, read_value.string());
+
+  // Delete the suborigin by physical origin this time. This should delete both
+  // the suborigin and physical origin.
+  context_->DeleteLocalStorageForPhysicalOrigin(kSuborigin);
+
+  read_value = origin_area->GetItem(kOriginKey);
+  EXPECT_TRUE(read_value.is_null());
+  read_value = suborigin_area->GetItem(kSuboriginKey);
+  EXPECT_TRUE(read_value.is_null());
+
+  // Setup data again for the third deletion, to test deleting the storage one
+  // at a time.
+  origin_area->SetItem(kOriginKey, kOriginValue, &old_nullable_value);
+  suborigin_area->SetItem(kSuboriginKey, kSuboriginValue, &old_nullable_value);
+
+  read_value = origin_area->GetItem(kOriginKey);
+  EXPECT_EQ(kOriginValue, read_value.string());
+  read_value = suborigin_area->GetItem(kSuboriginKey);
+  EXPECT_EQ(kSuboriginValue, read_value.string());
+
+  // Delete the origin only. This should leave the suborigin.
+  context_->DeleteLocalStorage(kOrigin);
+
+  read_value = origin_area->GetItem(kOriginKey);
+  EXPECT_TRUE(read_value.is_null());
+  read_value = suborigin_area->GetItem(kSuboriginKey);
+  EXPECT_EQ(kSuboriginValue, read_value.string());
+
+  // Put the origin value back so suborigin deletion can be tested.
+  origin_area->SetItem(kOriginKey, kOriginValue, &old_nullable_value);
+
+  read_value = origin_area->GetItem(kOriginKey);
+  EXPECT_EQ(kOriginValue, read_value.string());
+
+  // Delete the suborigin only. This should leave the origin.
+  context_->DeleteLocalStorage(kSuborigin);
+
+  read_value = origin_area->GetItem(kOriginKey);
+  EXPECT_EQ(kOriginValue, read_value.string());
+  read_value = suborigin_area->GetItem(kSuboriginKey);
+  EXPECT_TRUE(read_value.is_null());
+}
+
 }  // namespace content