Home | History | Annotate | Download | only in indexed_db 
      1 // Copyright (c) 2012 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/indexed_db/indexed_db_quota_client.h"
      6 
      7 #include <vector>
      8 
      9 #include "base/logging.h"
     10 #include "content/browser/indexed_db/indexed_db_context_impl.h"
     11 #include "content/public/browser/browser_thread.h"
     12 #include "net/base/net_util.h"
     13 #include "storage/browser/database/database_util.h"
     14 
     15 using storage::QuotaClient;
     16 using storage::DatabaseUtil;
     17 
     18 namespace content {
     19 namespace {
     20 
     21 storage::QuotaStatusCode DeleteOriginDataOnIndexedDBThread(
     22     IndexedDBContextImpl* context,
     23     const GURL& origin) {
     24   context->DeleteForOrigin(origin);
     25   return storage::kQuotaStatusOk;
     26 }
     27 
     28 int64 GetOriginUsageOnIndexedDBThread(IndexedDBContextImpl* context,
     29                                       const GURL& origin) {
     30   DCHECK(context->TaskRunner()->RunsTasksOnCurrentThread());
     31   return context->GetOriginDiskUsage(origin);
     32 }
     33 
     34 void GetAllOriginsOnIndexedDBThread(IndexedDBContextImpl* context,
     35                                     std::set<GURL>* origins_to_return) {
     36   DCHECK(context->TaskRunner()->RunsTasksOnCurrentThread());
     37   std::vector<GURL> all_origins = context->GetAllOrigins();
     38   origins_to_return->insert(all_origins.begin(), all_origins.end());
     39 }
     40 
     41 void DidGetOrigins(const IndexedDBQuotaClient::GetOriginsCallback& callback,
     42                    const std::set<GURL>* origins) {
     43   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     44   callback.Run(*origins);
     45 }
     46 
     47 void GetOriginsForHostOnIndexedDBThread(IndexedDBContextImpl* context,
     48                                         const std::string& host,
     49                                         std::set<GURL>* origins_to_return) {
     50   DCHECK(context->TaskRunner()->RunsTasksOnCurrentThread());
     51   std::vector<GURL> all_origins = context->GetAllOrigins();
     52   for (std::vector<GURL>::const_iterator iter = all_origins.begin();
     53        iter != all_origins.end();
     54        ++iter) {
     55     if (host == net::GetHostOrSpecFromURL(*iter))
     56       origins_to_return->insert(*iter);
     57   }
     58 }
     59 
     60 }  // namespace
     61 
     62 // IndexedDBQuotaClient --------------------------------------------------------
     63 
     64 IndexedDBQuotaClient::IndexedDBQuotaClient(
     65     IndexedDBContextImpl* indexed_db_context)
     66     : indexed_db_context_(indexed_db_context) {}
     67 
     68 IndexedDBQuotaClient::~IndexedDBQuotaClient() {}
     69 
     70 QuotaClient::ID IndexedDBQuotaClient::id() const { return kIndexedDatabase; }
     71 
     72 void IndexedDBQuotaClient::OnQuotaManagerDestroyed() { delete this; }
     73 
     74 void IndexedDBQuotaClient::GetOriginUsage(const GURL& origin_url,
     75                                           storage::StorageType type,
     76                                           const GetUsageCallback& callback) {
     77   DCHECK(!callback.is_null());
     78   DCHECK(indexed_db_context_.get());
     79 
     80   // IndexedDB is in the temp namespace for now.
     81   if (type != storage::kStorageTypeTemporary) {
     82     callback.Run(0);
     83     return;
     84   }
     85 
     86   // No task runner means unit test; no cleanup necessary.
     87   if (!indexed_db_context_->TaskRunner()) {
     88     callback.Run(0);
     89     return;
     90   }
     91 
     92   base::PostTaskAndReplyWithResult(
     93       indexed_db_context_->TaskRunner(),
     94       FROM_HERE,
     95       base::Bind(
     96           &GetOriginUsageOnIndexedDBThread, indexed_db_context_, origin_url),
     97       callback);
     98 }
     99 
    100 void IndexedDBQuotaClient::GetOriginsForType(
    101     storage::StorageType type,
    102     const GetOriginsCallback& callback) {
    103   DCHECK(!callback.is_null());
    104   DCHECK(indexed_db_context_.get());
    105 
    106   // All databases are in the temp namespace for now.
    107   if (type != storage::kStorageTypeTemporary) {
    108     callback.Run(std::set<GURL>());
    109     return;
    110   }
    111 
    112   // No task runner means unit test; no cleanup necessary.
    113   if (!indexed_db_context_->TaskRunner()) {
    114     callback.Run(std::set<GURL>());
    115     return;
    116   }
    117 
    118   std::set<GURL>* origins_to_return = new std::set<GURL>();
    119   indexed_db_context_->TaskRunner()->PostTaskAndReply(
    120       FROM_HERE,
    121       base::Bind(&GetAllOriginsOnIndexedDBThread,
    122                  indexed_db_context_,
    123                  base::Unretained(origins_to_return)),
    124       base::Bind(&DidGetOrigins, callback, base::Owned(origins_to_return)));
    125 }
    126 
    127 void IndexedDBQuotaClient::GetOriginsForHost(
    128     storage::StorageType type,
    129     const std::string& host,
    130     const GetOriginsCallback& callback) {
    131   DCHECK(!callback.is_null());
    132   DCHECK(indexed_db_context_.get());
    133 
    134   // All databases are in the temp namespace for now.
    135   if (type != storage::kStorageTypeTemporary) {
    136     callback.Run(std::set<GURL>());
    137     return;
    138   }
    139 
    140   // No task runner means unit test; no cleanup necessary.
    141   if (!indexed_db_context_->TaskRunner()) {
    142     callback.Run(std::set<GURL>());
    143     return;
    144   }
    145 
    146   std::set<GURL>* origins_to_return = new std::set<GURL>();
    147   indexed_db_context_->TaskRunner()->PostTaskAndReply(
    148       FROM_HERE,
    149       base::Bind(&GetOriginsForHostOnIndexedDBThread,
    150                  indexed_db_context_,
    151                  host,
    152                  base::Unretained(origins_to_return)),
    153       base::Bind(&DidGetOrigins, callback, base::Owned(origins_to_return)));
    154 }
    155 
    156 void IndexedDBQuotaClient::DeleteOriginData(const GURL& origin,
    157                                             storage::StorageType type,
    158                                             const DeletionCallback& callback) {
    159   if (type != storage::kStorageTypeTemporary) {
    160     callback.Run(storage::kQuotaErrorNotSupported);
    161     return;
    162   }
    163 
    164   // No task runner means unit test; no cleanup necessary.
    165   if (!indexed_db_context_->TaskRunner()) {
    166     callback.Run(storage::kQuotaStatusOk);
    167     return;
    168   }
    169 
    170   base::PostTaskAndReplyWithResult(
    171       indexed_db_context_->TaskRunner(),
    172       FROM_HERE,
    173       base::Bind(
    174           &DeleteOriginDataOnIndexedDBThread, indexed_db_context_, origin),
    175       callback);
    176 }
    177 
    178 bool IndexedDBQuotaClient::DoesSupport(storage::StorageType type) const {
    179   return type == storage::kStorageTypeTemporary;
    180 }
    181 
    182 }  // namespace content
    183