Add suborigin logic to url::Origin

content/browser/dom_storage/dom_storage_context_impl.cc

 // Copyright (c) 2012 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/dom_storage/dom_storage_context_impl.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 #include <stdlib.h>
 
@@ skipping 12 matching lines @@
 #include "base/trace_event/process_memory_dump.h"
 #include "content/browser/dom_storage/dom_storage_area.h"
 #include "content/browser/dom_storage/dom_storage_database.h"
 #include "content/browser/dom_storage/dom_storage_namespace.h"
 #include "content/browser/dom_storage/dom_storage_task_runner.h"
 #include "content/browser/dom_storage/session_storage_database.h"
 #include "content/common/dom_storage/dom_storage_types.h"
 #include "content/public/browser/dom_storage_context.h"
 #include "content/public/browser/local_storage_usage_info.h"
 #include "content/public/browser/session_storage_usage_info.h"
-#include "content/public/common/origin_util.h"
 #include "storage/browser/quota/special_storage_policy.h"
+#include "url/gurl.h"
+#include "url/origin.h"
 
 namespace content {
 namespace {
 
 // Limits on the cache size and number of areas in memory, over which the areas
 // are purged.
 #if defined(OS_ANDROID)
 const unsigned kMaxStorageAreaCount = 20;
 const size_t kMaxCacheSize = 2 * 1024 * 1024;
 #else
@@ skipping 149 matching lines @@
     for (std::vector<GURL>::const_iterator origin_it = it->second.begin();
          origin_it != it->second.end(); ++origin_it) {
       SessionStorageUsageInfo info;
       info.persistent_namespace_id = it->first;
       info.origin = *origin_it;
       infos->push_back(info);
     }
   }
 }
 
-void DOMStorageContextImpl::DeleteLocalStorage(const GURL& origin) {
+void DOMStorageContextImpl::DeleteLocalStorageForPhysicalOrigin(
+    const GURL& origin_url) {
   DCHECK(!is_shutdown_);
+  url::Origin origin(origin_url);
   DOMStorageNamespace* local = GetStorageNamespace(kLocalStorageNamespaceId);
   std::vector<GURL> origins;
   local->GetOriginsWithAreas(&origins);
-  // Suborigin storage should be deleted in tandem with the physical origin's
-  // storage. https://w3c.github.io/webappsec-suborigins/
-  for (auto origin_candidate : origins) {
+  // Suborigin at the physical origin of |origin_url| should have their storage
+  // deleted as well.
+  // https://w3c.github.io/webappsec-suborigins/
+  for (const auto& origin_candidate_url : origins) {
+    url::Origin origin_candidate(origin_candidate_url);
     // |origin| is guaranteed to be deleted below, so don't delete it until
-    // then.
-    if (origin_candidate == origin ||
-        StripSuboriginFromUrl(origin_candidate) != origin) {
-      continue;
+    // then. That is, only suborigins at the same physical origin as |origin|
+    // should be deleted at this point.
+    if (!origin_candidate.IsSameOriginWith(origin) &&
+        origin_candidate.IsSamePhysicalOriginWith(origin)) {
+      DeleteLocalStorage(origin_candidate_url);
     }
-    DeleteAndClearStorageNamespaceForOrigin(origin_candidate, local);
   }
   // It is important to always explicitly delete |origin|. If it does not appear
   // it |origins| above, there still may be a directory open in the namespace in
   // preparation for this storage, and this call will make sure that the
   // directory is deleted.
-  DeleteAndClearStorageNamespaceForOrigin(origin, local);
+  DeleteLocalStorage(origin_url);
+}
+
+void DOMStorageContextImpl::DeleteLocalStorage(const GURL& origin_url) {
+  DOMStorageNamespace* local = GetStorageNamespace(kLocalStorageNamespaceId);
+  local->DeleteLocalStorageOrigin(origin_url);
+  // Synthesize a 'cleared' event if the area is open so CachedAreas in
+  // renderers get emptied out too.
+  DOMStorageArea* area = local->GetOpenStorageArea(origin_url);
+  if (area)
+    NotifyAreaCleared(area, origin_url);
 }
 
 void DOMStorageContextImpl::DeleteSessionStorage(
     const SessionStorageUsageInfo& usage_info) {
   DCHECK(!is_shutdown_);
   DOMStorageNamespace* dom_storage_namespace = NULL;
   std::map<std::string, int64_t>::const_iterator it =
       persistent_namespace_id_to_namespace_id_.find(
           usage_info.persistent_namespace_id);
   if (it != persistent_namespace_id_to_namespace_id_.end()) {
@@ skipping 378 matching lines @@
   deletable_persistent_namespace_ids_.pop_back();
   if (!deletable_persistent_namespace_ids_.empty()) {
     task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(
             &DOMStorageContextImpl::DeleteNextUnusedNamespace,
             this),
         base::TimeDelta::FromSeconds(kSessionStoraceScavengingSeconds));
   }
 }
 
-void DOMStorageContextImpl::DeleteAndClearStorageNamespaceForOrigin(
-    const GURL& origin,
-    DOMStorageNamespace* local) {
-  local->DeleteLocalStorageOrigin(origin);
-  // Synthesize a 'cleared' event if the area is open so CachedAreas in
-  // renderers get emptied out too.
-  DOMStorageArea* area = local->GetOpenStorageArea(origin);
-  if (area)
-    NotifyAreaCleared(area, origin);
-}
-
 }  // namespace content