Create and store persistent unique ids for sessionStorage.

webkit/dom_storage/dom_storage_context.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 "webkit/dom_storage/dom_storage_context.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
+#include "base/guid.h"
 #include "base/location.h"
 #include "base/time.h"
 #include "webkit/dom_storage/dom_storage_area.h"
 #include "webkit/dom_storage/dom_storage_namespace.h"
 #include "webkit/dom_storage/dom_storage_task_runner.h"
 #include "webkit/dom_storage/dom_storage_types.h"
 #include "webkit/quota/special_storage_policy.h"
 
 using file_util::FileEnumerator;
 
@@ skipping 143 matching lines @@
 }
 
 void DomStorageContext::NotifyAreaCleared(
     const DomStorageArea* area,
     const GURL& page_url) {
   FOR_EACH_OBSERVER(
       EventObserver, event_observers_,
       OnDomStorageAreaCleared(area, page_url));
 }
 
+std::string DomStorageContext::AllocatePersistentSessionId() {
+  std::string guid = base::GenerateGUID();
+  std::replace(guid.begin(), guid.end(), '-', '_');
+  return guid;
+}
+
 void DomStorageContext::CreateSessionNamespace(
-    int64 namespace_id) {
+    int64 namespace_id,
+    const std::string& persistent_namespace_id) {
   if (is_shutdown_)
     return;
   DCHECK(namespace_id != kLocalStorageNamespaceId);
   DCHECK(namespaces_.find(namespace_id) == namespaces_.end());
   namespaces_[namespace_id] = new DomStorageNamespace(
-      namespace_id, task_runner_);
+      namespace_id, persistent_namespace_id, task_runner_);
 }
 
 void DomStorageContext::DeleteSessionNamespace(
     int64 namespace_id) {
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id);
   namespaces_.erase(namespace_id);
 }
 
 void DomStorageContext::CloneSessionNamespace(
-    int64 existing_id, int64 new_id) {
+    int64 existing_id, int64 new_id,
+    const std::string& new_persistent_id) {
   if (is_shutdown_)
     return;
   DCHECK_NE(kLocalStorageNamespaceId, existing_id);
   DCHECK_NE(kLocalStorageNamespaceId, new_id);
   StorageNamespaceMap::iterator found = namespaces_.find(existing_id);
   if (found != namespaces_.end())
-    namespaces_[new_id] = found->second->Clone(new_id);
+    namespaces_[new_id] = found->second->Clone(new_id, new_persistent_id);
   else
-    CreateSessionNamespace(new_id);
+    CreateSessionNamespace(new_id, new_persistent_id);
 }
 
 void DomStorageContext::ClearSessionOnlyOrigins() {
   std::vector<UsageInfo> infos;
   const bool kDontIncludeFileInfo = false;
   GetUsageInfo(&infos, kDontIncludeFileInfo);
   for (size_t i = 0; i < infos.size(); ++i) {
     const GURL& origin = infos[i].origin;
     if (special_storage_policy_->IsStorageProtected(origin))
       continue;
     if (!special_storage_policy_->IsStorageSessionOnly(origin))
       continue;
 
     const bool kNotRecursive = false;
     FilePath database_file_path = localstorage_directory_.Append(
         DomStorageArea::DatabaseFileNameFromOrigin(origin));
     file_util::Delete(database_file_path, kNotRecursive);
     file_util::Delete(
         DomStorageDatabase::GetJournalFilePath(database_file_path),
         kNotRecursive);
   }
 }
 
 }  // namespace dom_storage