Create and store persistent unique ids for sessionStorage.

webkit/dom_storage/dom_storage_area.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_area.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 34 matching lines @@
 }
 
 // static
 GURL DomStorageArea::OriginFromDatabaseFileName(const FilePath& name) {
   DCHECK(name.MatchesExtension(kDatabaseFileExtension));
   WebKit::WebString origin_id = webkit_glue::FilePathToWebString(
       name.BaseName().RemoveExtension());
   return DatabaseUtil::GetOriginFromIdentifier(origin_id);
 }
 
-DomStorageArea::DomStorageArea(
-    int64 namespace_id, const GURL& origin,
-    const FilePath& directory, DomStorageTaskRunner* task_runner)
-    : namespace_id_(namespace_id), origin_(origin),
+DomStorageArea::DomStorageArea(const GURL& origin, const FilePath& directory,
+                               DomStorageTaskRunner* task_runner)
+    : namespace_id_(kLocalStorageNamespaceId), origin_(origin),
       directory_(directory),
       task_runner_(task_runner),
       map_(new DomStorageMap(kPerAreaQuota + kPerAreaOverQuotaAllowance)),
       is_initial_import_done_(true),
       is_shutdown_(false),
       commit_batches_in_flight_(0) {
-  if (namespace_id == kLocalStorageNamespaceId && !directory.empty()) {
+  if (!directory.empty()) {
     FilePath path = directory.Append(DatabaseFileNameFromOrigin(origin_));
     backing_.reset(new DomStorageDatabase(path));
     is_initial_import_done_ = false;
   }
 }
 
+DomStorageArea::DomStorageArea(
+    int64 namespace_id,
+    const std::string& persistent_namespace_id,
+    const GURL& origin,
+    DomStorageTaskRunner* task_runner)
+    : namespace_id_(namespace_id),
+      persistent_namespace_id_(persistent_namespace_id),
+      origin_(origin),
+      task_runner_(task_runner),
+      map_(new DomStorageMap(kPerAreaQuota + kPerAreaOverQuotaAllowance)),
+      is_initial_import_done_(true),
+      is_shutdown_(false),
+      commit_batches_in_flight_(0) {
+  DCHECK(namespace_id != kLocalStorageNamespaceId);
+}
+
 DomStorageArea::~DomStorageArea() {
 }
 
 void DomStorageArea::ExtractValues(ValuesMap* map) {
   if (is_shutdown_)
     return;
   InitialImportIfNeeded();
   map_->ExtractValues(map);
 }
 
@@ skipping 59 matching lines @@
 
   if (backing_.get()) {
     CommitBatch* commit_batch = CreateCommitBatchIfNeeded();
     commit_batch->clear_all_first = true;
     commit_batch->changed_values.clear();
   }
 
   return true;
 }
 
-DomStorageArea* DomStorageArea::ShallowCopy(int64 destination_namespace_id) {
+DomStorageArea* DomStorageArea::ShallowCopy(
+    int64 destination_namespace_id,
+    const std::string& destination_persistent_namespace_id) {
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id_);
   DCHECK_NE(kLocalStorageNamespaceId, destination_namespace_id);
   DCHECK(!backing_.get());  // SessionNamespaces aren't stored on disk.
 
-  DomStorageArea* copy = new DomStorageArea(destination_namespace_id, origin_,
-                                            FilePath(), task_runner_);
+  DomStorageArea* copy = new DomStorageArea(
+      destination_namespace_id, destination_persistent_namespace_id, origin_,
+      task_runner_);
   copy->map_ = map_;
   copy->is_shutdown_ = is_shutdown_;
   return copy;
 }
 
 bool DomStorageArea::HasUncommittedChanges() const {
   DCHECK(!is_shutdown_);
   return commit_batch_.get() || commit_batches_in_flight_;
 }
 
@@ skipping 135 matching lines @@
     bool success = backing_->CommitChanges(
         commit_batch_->clear_all_first,
         commit_batch_->changed_values);
     DCHECK(success);
   }
   commit_batch_.reset();
   backing_.reset();
 }
 
 }  // namespace dom_storage