content/browser/dom_storage/dom_storage_namespace.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_namespace.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/bind.h"
   9 #include "base/location.h"
  10 #include "base/logging.h"
  11 #include "content/browser/dom_storage/dom_storage_area.h"
  12 #include "content/browser/dom_storage/dom_storage_task_runner.h"
  13 #include "content/browser/dom_storage/session_storage_database.h"
  14 #include "content/common/dom_storage/dom_storage_types.h"
  15
  16 namespace content {
  17
  18 DOMStorageNamespace::DOMStorageNamespace(
  19     const base::FilePath& directory,
  20     DOMStorageTaskRunner* task_runner)
  21     : namespace_id_(kLocalStorageNamespaceId),
  22       directory_(directory),
  23       task_runner_(task_runner) {
  24 }
  25
  26 DOMStorageNamespace::DOMStorageNamespace(
  27     int64 namespace_id,
  28     const std::string& persistent_namespace_id,
  29     SessionStorageDatabase* session_storage_database,
  30     DOMStorageTaskRunner* task_runner)
  31     : namespace_id_(namespace_id),
  32       persistent_namespace_id_(persistent_namespace_id),
  33       task_runner_(task_runner),
  34       session_storage_database_(session_storage_database) {
  35   DCHECK_NE(kLocalStorageNamespaceId, namespace_id);
  36 }
  37
  38 DOMStorageNamespace::~DOMStorageNamespace() {
  39 }
  40
  41 DOMStorageArea* DOMStorageNamespace::OpenStorageArea(const GURL& origin) {
  42   if (AreaHolder* holder = GetAreaHolder(origin)) {
  43     ++(holder->open_count_);
  44     return holder->area_.get();
  45   }
  46   DOMStorageArea* area;
  47   if (namespace_id_ == kLocalStorageNamespaceId) {
  48     area = new DOMStorageArea(origin, directory_, task_runner_.get());
  49   } else {
  50     area = new DOMStorageArea(
  51         namespace_id_, persistent_namespace_id_, origin,
  52         session_storage_database_.get(), task_runner_.get());
  53   }
  54   areas_[origin] = AreaHolder(area, 1);
  55   return area;
  56 }
  57
  58 void DOMStorageNamespace::CloseStorageArea(DOMStorageArea* area) {
  59   AreaHolder* holder = GetAreaHolder(area->origin());
  60   DCHECK(holder);
  61   DCHECK_EQ(holder->area_.get(), area);
  62   --(holder->open_count_);
  63   // TODO(michaeln): Clean up areas that aren't needed in memory anymore.
  64   // The in-process-webkit based impl didn't do this either, but would be nice.
  65 }
  66
  67 DOMStorageArea* DOMStorageNamespace::GetOpenStorageArea(const GURL& origin) {
  68   AreaHolder* holder = GetAreaHolder(origin);
  69   if (holder && holder->open_count_)
  70     return holder->area_.get();
  71   return NULL;
  72 }
  73
  74 DOMStorageNamespace* DOMStorageNamespace::Clone(
  75     int64 clone_namespace_id,
  76     const std::string& clone_persistent_namespace_id) {
  77   DCHECK_NE(kLocalStorageNamespaceId, namespace_id_);
  78   DCHECK_NE(kLocalStorageNamespaceId, clone_namespace_id);
  79   DOMStorageNamespace* clone = new DOMStorageNamespace(
  80       clone_namespace_id, clone_persistent_namespace_id,
  81       session_storage_database_.get(), task_runner_.get());
  82   AreaMap::const_iterator it = areas_.begin();
  83   // Clone the in-memory structures.
  84   for (; it != areas_.end(); ++it) {
  85     DOMStorageArea* area = it->second.area_->ShallowCopy(
  86         clone_namespace_id, clone_persistent_namespace_id);
  87     clone->areas_[it->first] = AreaHolder(area, 0);
  88   }
  89   // And clone the on-disk structures, too.
  90   if (session_storage_database_.get()) {
  91     task_runner_->PostShutdownBlockingTask(
  92         FROM_HERE,
  93         DOMStorageTaskRunner::COMMIT_SEQUENCE,
  94         base::Bind(base::IgnoreResult(&SessionStorageDatabase::CloneNamespace),
  95                    session_storage_database_.get(), persistent_namespace_id_,
  96                    clone_persistent_namespace_id));
  97   }
  98   return clone;
  99 }
 100
 101 void DOMStorageNamespace::DeleteLocalStorageOrigin(const GURL& origin) {
 102   DCHECK(!session_storage_database_.get());
 103   AreaHolder* holder = GetAreaHolder(origin);
 104   if (holder) {
 105     holder->area_->DeleteOrigin();
 106     return;
 107   }
 108   if (!directory_.empty()) {
 109     scoped_refptr<DOMStorageArea> area =
 110         new DOMStorageArea(origin, directory_, task_runner_.get());
 111     area->DeleteOrigin();
 112   }
 113 }
 114
 115 void DOMStorageNamespace::DeleteSessionStorageOrigin(const GURL& origin) {
 116   DOMStorageArea* area = OpenStorageArea(origin);
 117   area->FastClear();
 118   CloseStorageArea(area);
 119 }
 120
 121 void DOMStorageNamespace::PurgeMemory(PurgeOption option) {
 122   if (directory_.empty())
 123     return;  // We can't purge w/o backing on disk.
 124   AreaMap::iterator it = areas_.begin();
 125   while (it != areas_.end()) {
 126     // Leave it alone if changes are pending
 127     if (it->second.area_->HasUncommittedChanges()) {
 128       ++it;
 129       continue;
 130     }
 131
 132     // If not in use, we can shut it down and remove
 133     // it from our collection entirely.
 134     if (it->second.open_count_ == 0) {
 135       it->second.area_->Shutdown();
 136       areas_.erase(it++);
 137       continue;
 138     }
 139
 140     if (option == PURGE_AGGRESSIVE) {
 141       // If aggressive is true, we clear caches and such
 142       // for opened areas.
 143       it->second.area_->PurgeMemory();
 144     }
 145
 146     ++it;
 147   }
 148 }
 149
 150 void DOMStorageNamespace::Shutdown() {
 151   AreaMap::const_iterator it = areas_.begin();
 152   for (; it != areas_.end(); ++it)
 153     it->second.area_->Shutdown();
 154 }
 155
 156 unsigned int DOMStorageNamespace::CountInMemoryAreas() const {
 157   unsigned int area_count = 0;
 158   for (AreaMap::const_iterator it = areas_.begin(); it != areas_.end(); ++it) {
 159     if (it->second.area_->IsLoadedInMemory())
 160       ++area_count;
 161   }
 162   return area_count;
 163 }
 164
 165 DOMStorageNamespace::AreaHolder*
 166 DOMStorageNamespace::GetAreaHolder(const GURL& origin) {
 167   AreaMap::iterator found = areas_.find(origin);
 168   if (found == areas_.end())
 169     return NULL;
 170   return &(found->second);
 171 }
 172
 173 // AreaHolder
 174
 175 DOMStorageNamespace::AreaHolder::AreaHolder()
 176     : open_count_(0) {
 177 }
 178
 179 DOMStorageNamespace::AreaHolder::AreaHolder(
 180     DOMStorageArea* area, int count)
 181     : area_(area), open_count_(count) {
 182 }
 183
 184 DOMStorageNamespace::AreaHolder::~AreaHolder() {
 185 }
 186
 187 }  // namespace content