content/browser/dom_storage/dom_storage_session.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/dom_storage/dom_storage_session.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/logging.h"
  10 #include "base/single_thread_task_runner.h"
  11 #include "base/thread_task_runner_handle.h"
  12 #include "base/tracked_objects.h"
  13 #include "content/browser/dom_storage/dom_storage_context_impl.h"
  14 #include "content/browser/dom_storage/dom_storage_task_runner.h"
  15
  16 namespace content {
  17
  18 namespace {
  19
  20 void PostMergeTaskResult(
  21     const SessionStorageNamespace::MergeResultCallback& callback,
  22     SessionStorageNamespace::MergeResult result) {
  23   callback.Run(result);
  24 }
  25
  26 void RunMergeTaskAndPostResult(
  27     const base::Callback<SessionStorageNamespace::MergeResult(void)>& task,
  28     scoped_refptr<base::SingleThreadTaskRunner> result_loop,
  29     const SessionStorageNamespace::MergeResultCallback& callback) {
  30   SessionStorageNamespace::MergeResult result = task.Run();
  31   result_loop->PostTask(
  32       FROM_HERE, base::Bind(&PostMergeTaskResult, callback, result));
  33 }
  34
  35 }  // namespace
  36
  37 DOMStorageSession::DOMStorageSession(DOMStorageContextImpl* context)
  38     : context_(context),
  39       namespace_id_(context->AllocateSessionId()),
  40       persistent_namespace_id_(context->AllocatePersistentSessionId()),
  41       should_persist_(false) {
  42   context->task_runner()->PostTask(
  43       FROM_HERE,
  44       base::Bind(&DOMStorageContextImpl::CreateSessionNamespace,
  45                  context_, namespace_id_, persistent_namespace_id_));
  46 }
  47
  48 DOMStorageSession::DOMStorageSession(DOMStorageContextImpl* context,
  49                                      const std::string& persistent_namespace_id)
  50     : context_(context),
  51       namespace_id_(context->AllocateSessionId()),
  52       persistent_namespace_id_(persistent_namespace_id),
  53       should_persist_(false) {
  54   context->task_runner()->PostTask(
  55       FROM_HERE,
  56       base::Bind(&DOMStorageContextImpl::CreateSessionNamespace,
  57                  context_, namespace_id_, persistent_namespace_id_));
  58 }
  59
  60 DOMStorageSession::DOMStorageSession(
  61     DOMStorageSession* master_dom_storage_session)
  62     : context_(master_dom_storage_session->context_),
  63       namespace_id_(master_dom_storage_session->context_->AllocateSessionId()),
  64       persistent_namespace_id_(
  65           master_dom_storage_session->persistent_namespace_id()),
  66       should_persist_(false) {
  67   context_->task_runner()->PostTask(
  68       FROM_HERE,
  69       base::Bind(&DOMStorageContextImpl::CreateAliasSessionNamespace,
  70                  context_,
  71                  master_dom_storage_session->namespace_id(),
  72                  namespace_id_,
  73                  persistent_namespace_id_));
  74 }
  75
  76 void DOMStorageSession::SetShouldPersist(bool should_persist) {
  77   should_persist_ = should_persist;
  78 }
  79
  80 bool DOMStorageSession::should_persist() const {
  81   return should_persist_;
  82 }
  83
  84 bool DOMStorageSession::IsFromContext(DOMStorageContextImpl* context) {
  85   return context_.get() == context;
  86 }
  87
  88 DOMStorageSession* DOMStorageSession::Clone() {
  89   return CloneFrom(context_.get(), namespace_id_);
  90 }
  91
  92 // static
  93 DOMStorageSession* DOMStorageSession::CloneFrom(DOMStorageContextImpl* context,
  94                                                 int64 namepace_id_to_clone) {
  95   int64 clone_id = context->AllocateSessionId();
  96   std::string persistent_clone_id = context->AllocatePersistentSessionId();
  97   context->task_runner()->PostTask(
  98       FROM_HERE,
  99       base::Bind(&DOMStorageContextImpl::CloneSessionNamespace,
 100                  context, namepace_id_to_clone, clone_id, persistent_clone_id));
 101   return new DOMStorageSession(context, clone_id, persistent_clone_id);
 102 }
 103
 104 DOMStorageSession::DOMStorageSession(DOMStorageContextImpl* context,
 105                                      int64 namespace_id,
 106                                      const std::string& persistent_namespace_id)
 107     : context_(context),
 108       namespace_id_(namespace_id),
 109       persistent_namespace_id_(persistent_namespace_id),
 110       should_persist_(false) {
 111   // This ctor is intended for use by the Clone() method.
 112 }
 113
 114 DOMStorageSession::~DOMStorageSession() {
 115   context_->task_runner()->PostTask(
 116       FROM_HERE,
 117       base::Bind(&DOMStorageContextImpl::DeleteSessionNamespace,
 118                  context_, namespace_id_, should_persist_));
 119 }
 120
 121 void DOMStorageSession::AddTransactionLogProcessId(int process_id) {
 122   context_->task_runner()->PostTask(
 123       FROM_HERE,
 124       base::Bind(&DOMStorageContextImpl::AddTransactionLogProcessId,
 125                  context_, namespace_id_, process_id));
 126 }
 127
 128 void DOMStorageSession::RemoveTransactionLogProcessId(int process_id) {
 129   context_->task_runner()->PostTask(
 130       FROM_HERE,
 131       base::Bind(&DOMStorageContextImpl::RemoveTransactionLogProcessId,
 132                  context_, namespace_id_, process_id));
 133 }
 134
 135 void DOMStorageSession::Merge(
 136     bool actually_merge,
 137     int process_id,
 138     DOMStorageSession* other,
 139     const SessionStorageNamespace::MergeResultCallback& callback) {
 140   scoped_refptr<base::SingleThreadTaskRunner> current_loop(
 141       base::ThreadTaskRunnerHandle::Get());
 142   SessionStorageNamespace::MergeResultCallback cb =
 143       base::Bind(&DOMStorageSession::ProcessMergeResult,
 144                  this,
 145                  actually_merge,
 146                  callback,
 147                  other->persistent_namespace_id());
 148   context_->task_runner()->PostTask(
 149       FROM_HERE,
 150       base::Bind(&RunMergeTaskAndPostResult,
 151                  base::Bind(&DOMStorageContextImpl::MergeSessionStorage,
 152                             context_, namespace_id_, actually_merge, process_id,
 153                             other->namespace_id_),
 154                  current_loop,
 155                  cb));
 156 }
 157
 158 void DOMStorageSession::ProcessMergeResult(
 159     bool actually_merge,
 160     const SessionStorageNamespace::MergeResultCallback& callback,
 161     const std::string& new_persistent_namespace_id,
 162     SessionStorageNamespace::MergeResult result) {
 163   if (actually_merge &&
 164       (result == SessionStorageNamespace::MERGE_RESULT_MERGEABLE ||
 165        result == SessionStorageNamespace::MERGE_RESULT_NO_TRANSACTIONS)) {
 166     persistent_namespace_id_ = new_persistent_namespace_id;
 167   }
 168   callback.Run(result);
 169 }
 170
 171 }  // namespace content