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/content_browser_client.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"
+#include "content/common/content_client.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebStorageArea.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebStorageNamespace.h"
 #include "webkit/glue/webkit_glue.h"
 
 using WebKit::WebStorageArea;
 using WebKit::WebStorageNamespace;
 using WebKit::WebString;
 
+namespace {
+
+void CreateStorageAreaInWebKitThread(DOMStorageNamespace* dom_storage_namespace,
+                                     const string16& origin,
+                                     bool allow_permanent_storage,
+                                     DOMStorageNamespace::Delegate* delegate,
+                                     IPC::Message* reply_msg) {
+  // It's possible that the same origin has been requested by multiple
+  // renderers. There can be multiple CreateStorageAreaInWebKitThread tasks in
+  // the event queue and the WebKit thread will process them sequentally. Each
+  // task needs to check if the storage area got created by a previous task.
+  DOMStorageArea* storage_area =
+      dom_storage_namespace->GetExistingStorageArea(origin);
+  if (storage_area) {
+    if (delegate)
+      delegate->OnGotStorageArea(storage_area, reply_msg);
+    return;
+  }
+  dom_storage_namespace->CreateStorageAreaInWebKitThread(
+      origin,
+      allow_permanent_storage,
+      delegate,
+      reply_msg);
+}
+
+void ReadContentSettingsOnIOThread(
+    DOMStorageContext* dom_storage_context,
+    const string16& origin,
+    const string16& first_party_origin,
+    DOMStorageNamespace* dom_storage_namespace,
+    DOMStorageNamespace::Delegate* delegate,
+    IPC::Message* reply_msg) {
+  content::ContentBrowserClient* content_browser_client =
+      content::GetContentClient()->browser();
+  bool allow_permanent_storage =
+      content_browser_client->AllowPermanentStorage(
+          GURL(origin),
+          GURL(first_party_origin),
+          dom_storage_context->GetResourceContext());
+  BrowserThread::PostTask(BrowserThread::WEBKIT,
+                            FROM_HERE,
+                          NewRunnableFunction(
+                              CreateStorageAreaInWebKitThread,
+                                dom_storage_namespace,
+                                origin,
+                                allow_permanent_storage,
+                                delegate,
+                                reply_msg));
+}
+
+}  // namespace
+
 /* static */
 DOMStorageNamespace* DOMStorageNamespace::CreateLocalStorageNamespace(
     DOMStorageContext* dom_storage_context, const FilePath& data_dir_path) {
   int64 id = kLocalStorageNamespaceId;
   DCHECK(!dom_storage_context->GetStorageNamespace(id, false));
   return new DOMStorageNamespace(dom_storage_context, id,
       webkit_glue::FilePathToWebString(data_dir_path), DOM_STORAGE_LOCAL);
 }
 
 /* static */
 DOMStorageNamespace* DOMStorageNamespace::CreateSessionStorageNamespace(
     DOMStorageContext* dom_storage_context, int64 id) {
   DCHECK(!dom_storage_context->GetStorageNamespace(id, false));
   return new DOMStorageNamespace(dom_storage_context, id, WebString(),
                                  DOM_STORAGE_SESSION);
 }
 
 DOMStorageNamespace::DOMStorageNamespace(DOMStorageContext* dom_storage_context,
                                          int64 id,
                                          const WebString& data_dir_path,
                                          DOMStorageType dom_storage_type)
     : dom_storage_context_(dom_storage_context),
       id_(id),
       data_dir_path_(data_dir_path),
       dom_storage_type_(dom_storage_type) {
+  if (dom_storage_type == DOM_STORAGE_LOCAL && !data_dir_path.isEmpty()) {
+    // This DOMStorageNamespace represents permanent storage; create a sibling
+    // namespace that represents the corresponding session-only storage.
+    session_only_local_storage_.reset(
+        new DOMStorageNamespace(dom_storage_context,
+                                id,
+                                WebString(),
+                                dom_storage_type));
+  }
   DCHECK(dom_storage_context_);
 }
 
 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,
+                                                    Delegate* delegate,
+                                                    IPC::Message* reply_msg) {
   // 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;
+  // Else, we need to create a new DOMStorageArea.
 
-  // 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;
+  if (session_only_local_storage_.get()) {
+    // We have a session-only sibling DOMStorageNamespace, so we need to check
+    // whether to create it in this or in the sibling. We're now in the WebKit
+    // thread, but the content settings need to be accessed in the IO thread.
+    BrowserThread::PostTask(BrowserThread::IO,
+                            FROM_HERE,
+                            NewRunnableFunction(
+                                ReadContentSettingsOnIOThread,
+                                dom_storage_context_,
+                                origin,
+                                // FIXME(marja): get the first-party url
+                                origin,
+                                this,
+                                delegate,
+                                reply_msg));
+    return NULL;
+  }
+  else {
+    // No sibling; handle creation here.
+    return CreateStorageAreaInWebKitThread(origin, true, NULL, NULL);
+  }
 }
 
 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;
+
+  // Our 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()) {
+    iter = session_only_local_storage_->origin_to_storage_area_.find(origin);
+    if (iter != session_only_local_storage_->origin_to_storage_area_.end())
+      return iter->second;
+  }
+  return NULL;
+}
+
+DOMStorageArea* DOMStorageNamespace::CreateStorageAreaInWebKitThread(
+    const string16& origin,
+    bool allow_permanent_storage,
+    Delegate* delegate,
+    IPC::Message* reply_msg) {
+  DOMStorageArea* storage_area = NULL;
+  if (session_only_local_storage_.get() &&
+      !allow_permanent_storage) {
+    // For that origin, only session-only data is allowed, and we have a
+    // sibling namespace taking care of it. This will finish immediately,
+    // since the sibling won't check again whether the permanent storage is
+    // allowed.
+    storage_area =
+        session_only_local_storage_->GetStorageArea(origin, NULL, NULL);
+  } else {
+    int64 id = dom_storage_context_->AllocateStorageAreaId();
+    DCHECK(!dom_storage_context_->GetStorageArea(id));
+    storage_area = new DOMStorageArea(origin, id, this);
+    origin_to_storage_area_[origin] = storage_area;
+    dom_storage_context_->RegisterStorageArea(storage_area);
+  }
+  if (delegate)
+    delegate->OnGotStorageArea(storage_area, reply_msg);
+  return storage_area;
+}