Adding session-only localStorage.

content/browser/in_process_webkit/dom_storage_namespace.cc

 // Copyright (c) 2010 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/in_process_webkit/dom_storage_namespace.h"
 
 #include "base/file_path.h"
 #include "content/browser/in_process_webkit/dom_storage_area.h"
 #include "content/browser/in_process_webkit/dom_storage_context.h"
 #include "content/browser/in_process_webkit/dom_storage_message_filter.h"
@@ skipping 36 matching lines @@
 DOMStorageNamespace::~DOMStorageNamespace() {
   // TODO(jorlow): If the DOMStorageContext is being destructed, there's no need
   //               to do these calls.  Maybe we should add a fast path?
   for (OriginToStorageAreaMap::iterator iter(origin_to_storage_area_.begin());
        iter != origin_to_storage_area_.end(); ++iter) {
     dom_storage_context_->UnregisterStorageArea(iter->second);
     delete iter->second;
   }
 }
 
-DOMStorageArea* DOMStorageNamespace::GetStorageArea(const string16& origin) {
+DOMStorageArea* DOMStorageNamespace::GetStorageArea(
+    const string16& origin,
+    bool enforce_session_only_storage) {
   // We may have already created it for another dispatcher host.
-  OriginToStorageAreaMap::iterator iter = origin_to_storage_area_.find(origin);
-  if (iter != origin_to_storage_area_.end())
-    return iter->second;
+  DOMStorageArea* storage_area = GetExistingStorageArea(origin);
+  if (storage_area)
+    return storage_area;
 
-  // We need to create a new one.
-  int64 id = dom_storage_context_->AllocateStorageAreaId();
-  DCHECK(!dom_storage_context_->GetStorageArea(id));
-  DOMStorageArea* storage_area = new DOMStorageArea(origin, id, this);
-  origin_to_storage_area_[origin] = storage_area;
-  dom_storage_context_->RegisterStorageArea(storage_area);
-  return storage_area;
+  // Also, our session-only sibling might have it. (This is independent of what
+  // the content settings say; it might be that the settings were changed after
+  // the DOMStorageArea was created.)
+  if (session_only_local_storage_.get()) {
+    storage_area = session_only_local_storage_->GetExistingStorageArea(origin);
+    if (storage_area)
+      return storage_area;
+  }
+
+  // Else, we need to create a new DOMStorageArea.
+  if (enforce_session_only_storage && ShouldHaveSessionOnlyLocalStorage()) {
+    EnsureSessionOnlyLocalStorageCreated();
+    return session_only_local_storage_->CreateStorageArea(origin);
+  }
+  return CreateStorageArea(origin);
 }
 
 DOMStorageNamespace* DOMStorageNamespace::Copy(int64 id) {
   DCHECK(dom_storage_type_ == DOM_STORAGE_SESSION);
   DCHECK(!dom_storage_context_->GetStorageNamespace(id, false));
   DOMStorageNamespace* new_storage_namespace = new DOMStorageNamespace(
       dom_storage_context_, id, data_dir_path_, dom_storage_type_);
   // If we haven't used the namespace yet, there's nothing to copy.
   if (storage_namespace_.get())
     new_storage_namespace->storage_namespace_.reset(storage_namespace_->copy());
@@ skipping 20 matching lines @@
 
   if (dom_storage_type_ == DOM_STORAGE_LOCAL) {
     storage_namespace_.reset(
         WebStorageNamespace::createLocalStorageNamespace(data_dir_path_,
             WebStorageNamespace::m_localStorageQuota));
   } else {
     storage_namespace_.reset(WebStorageNamespace::createSessionStorageNamespace(
         WebStorageNamespace::m_sessionStorageQuota));
   }
 }
+
+DOMStorageArea* DOMStorageNamespace::GetExistingStorageArea(
+    const string16& origin) {
+  OriginToStorageAreaMap::iterator iter = origin_to_storage_area_.find(origin);
+  if (iter != origin_to_storage_area_.end())
+    return iter->second;
+  return NULL;
+}
+
+DOMStorageArea* DOMStorageNamespace::CreateStorageArea(const string16& origin) {
+  int64 id = dom_storage_context_->AllocateStorageAreaId();
+  DCHECK(!dom_storage_context_->GetStorageArea(id));
+  DOMStorageArea* storage_area = new DOMStorageArea(origin, id, this);
+  origin_to_storage_area_[origin] = storage_area;
+  dom_storage_context_->RegisterStorageArea(storage_area);
+  return storage_area;
+}
+
+bool DOMStorageNamespace::ShouldHaveSessionOnlyLocalStorage() const {
+  if (dom_storage_type_ == DOM_STORAGE_LOCAL && !data_dir_path_.isEmpty()) {
+    // This DOMStorageNamespace represents a permanent localStorage; it should
+    // have a sibling DOMStorageNamespace that represents the corresponding
+    // session-only storage.
+    return true;

[michaeln, 2011/08/04 20:21:51]

maybe simplify as
return (type == LOCAL) && !path.isEmpty();

[marja, 2011/08/05 13:15:53]

Done.

+  }
+  return false;
+}
+
+void DOMStorageNamespace::EnsureSessionOnlyLocalStorageCreated() {
+  if (session_only_local_storage_.get() == NULL) {
+    session_only_local_storage_.reset(
+        new DOMStorageNamespace(dom_storage_context_,
+                                id_,
+                                WebString(),
+                                dom_storage_type_));
+  }
+}