webkit/browser/appcache/appcache_disk_cache.cc

   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 "webkit/browser/appcache/appcache_disk_cache.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/files/file_path.h"
  10 #include "base/logging.h"
  11 #include "base/stl_util.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "net/base/cache_type.h"
  14 #include "net/base/net_errors.h"
  15
  16 namespace appcache {
  17
  18 // A callback shim that provides storage for the 'backend_ptr' value
  19 // and will delete a resulting ptr if completion occurs after its
  20 // been canceled.
  21 class AppCacheDiskCache::CreateBackendCallbackShim
  22     : public base::RefCounted<CreateBackendCallbackShim> {
  23  public:
  24   explicit CreateBackendCallbackShim(AppCacheDiskCache* object)
  25       : appcache_diskcache_(object) {
  26   }
  27
  28   void Cancel() {
  29     appcache_diskcache_ = NULL;
  30   }
  31
  32   void Callback(int rv) {
  33     if (appcache_diskcache_)
  34       appcache_diskcache_->OnCreateBackendComplete(rv);
  35   }
  36
  37   scoped_ptr<disk_cache::Backend> backend_ptr_;  // Accessed directly.
  38
  39  private:
  40   friend class base::RefCounted<CreateBackendCallbackShim>;
  41
  42   ~CreateBackendCallbackShim() {
  43   }
  44
  45   AppCacheDiskCache* appcache_diskcache_;  // Unowned pointer.
  46 };
  47
  48 // An implementation of AppCacheDiskCacheInterface::Entry that's a thin
  49 // wrapper around disk_cache::Entry.
  50 class AppCacheDiskCache::EntryImpl : public Entry {
  51  public:
  52   explicit EntryImpl(disk_cache::Entry* disk_cache_entry)
  53       : disk_cache_entry_(disk_cache_entry) {
  54     DCHECK(disk_cache_entry);
  55   }
  56
  57   // Entry implementation.
  58   virtual int Read(int index, int64 offset, net::IOBuffer* buf, int buf_len,
  59                    const net::CompletionCallback& callback) OVERRIDE {
  60     if (offset < 0 || offset > kint32max)
  61       return net::ERR_INVALID_ARGUMENT;
  62     return disk_cache_entry_->ReadData(
  63         index, static_cast<int>(offset), buf, buf_len, callback);
  64   }
  65
  66   virtual int Write(int index, int64 offset, net::IOBuffer* buf, int buf_len,
  67                     const net::CompletionCallback& callback) OVERRIDE {
  68     if (offset < 0 || offset > kint32max)
  69       return net::ERR_INVALID_ARGUMENT;
  70     const bool kTruncate = true;
  71     return disk_cache_entry_->WriteData(
  72         index, static_cast<int>(offset), buf, buf_len, callback, kTruncate);
  73   }
  74
  75   virtual int64 GetSize(int index) OVERRIDE {
  76     return disk_cache_entry_->GetDataSize(index);
  77   }
  78
  79   virtual void Close() OVERRIDE {
  80     disk_cache_entry_->Close();
  81     delete this;
  82   }
  83
  84  private:
  85   disk_cache::Entry* disk_cache_entry_;
  86 };
  87
  88 // Separate object to hold state for each Create, Delete, or Doom call
  89 // while the call is in-flight and to produce an EntryImpl upon completion.
  90 class AppCacheDiskCache::ActiveCall {
  91  public:
  92   explicit ActiveCall(AppCacheDiskCache* owner)
  93       : entry_(NULL),
  94         owner_(owner),
  95         entry_ptr_(NULL) {
  96   }
  97
  98   int CreateEntry(int64 key, Entry** entry,
  99                   const net::CompletionCallback& callback) {
 100     int rv = owner_->disk_cache()->CreateEntry(
 101         base::Int64ToString(key), &entry_ptr_,
 102         base::Bind(&ActiveCall::OnAsyncCompletion, base::Unretained(this)));
 103     return HandleImmediateReturnValue(rv, entry, callback);
 104   }
 105
 106   int OpenEntry(int64 key, Entry** entry,
 107                 const net::CompletionCallback& callback) {
 108     int rv = owner_->disk_cache()->OpenEntry(
 109         base::Int64ToString(key), &entry_ptr_,
 110         base::Bind(&ActiveCall::OnAsyncCompletion, base::Unretained(this)));
 111     return HandleImmediateReturnValue(rv, entry, callback);
 112   }
 113
 114   int DoomEntry(int64 key, const net::CompletionCallback& callback) {
 115     int rv = owner_->disk_cache()->DoomEntry(
 116         base::Int64ToString(key),
 117         base::Bind(&ActiveCall::OnAsyncCompletion, base::Unretained(this)));
 118     return HandleImmediateReturnValue(rv, NULL, callback);
 119   }
 120
 121  private:
 122   int HandleImmediateReturnValue(int rv, Entry** entry,
 123                                  const net::CompletionCallback& callback) {
 124     if (rv == net::ERR_IO_PENDING) {
 125       // OnAsyncCompletion will be called later.
 126       callback_ = callback;
 127       entry_ = entry;
 128       owner_->AddActiveCall(this);
 129       return net::ERR_IO_PENDING;
 130     }
 131     if (rv == net::OK && entry)
 132       *entry = new EntryImpl(entry_ptr_);
 133     delete this;
 134     return rv;
 135   }
 136
 137   void OnAsyncCompletion(int rv) {
 138     owner_->RemoveActiveCall(this);
 139     if (rv == net::OK && entry_)
 140       *entry_ = new EntryImpl(entry_ptr_);
 141     callback_.Run(rv);
 142     callback_.Reset();
 143     delete this;
 144   }
 145
 146   Entry** entry_;
 147   net::CompletionCallback callback_;
 148   AppCacheDiskCache* owner_;
 149   disk_cache::Entry* entry_ptr_;
 150 };
 151
 152 AppCacheDiskCache::AppCacheDiskCache()
 153     : is_disabled_(false) {
 154 }
 155
 156 AppCacheDiskCache::~AppCacheDiskCache() {
 157   if (create_backend_callback_.get()) {
 158     create_backend_callback_->Cancel();
 159     create_backend_callback_ = NULL;
 160     OnCreateBackendComplete(net::ERR_ABORTED);
 161   }
 162   disk_cache_.reset();
 163   STLDeleteElements(&active_calls_);
 164 }
 165
 166 int AppCacheDiskCache::InitWithDiskBackend(
 167     const base::FilePath& disk_cache_directory, int disk_cache_size, bool force,
 168     base::MessageLoopProxy* cache_thread,
 169     const net::CompletionCallback& callback) {
 170   return Init(net::APP_CACHE, disk_cache_directory,
 171               disk_cache_size, force, cache_thread, callback);
 172 }
 173
 174 int AppCacheDiskCache::InitWithMemBackend(
 175     int mem_cache_size, const net::CompletionCallback& callback) {
 176   return Init(net::MEMORY_CACHE, base::FilePath(), mem_cache_size, false, NULL,
 177               callback);
 178 }
 179
 180 void AppCacheDiskCache::Disable() {
 181   if (is_disabled_)
 182     return;
 183
 184   is_disabled_ = true;
 185
 186   if (create_backend_callback_.get()) {
 187     create_backend_callback_->Cancel();
 188     create_backend_callback_ = NULL;
 189     OnCreateBackendComplete(net::ERR_ABORTED);
 190   }
 191 }
 192
 193 int AppCacheDiskCache::CreateEntry(int64 key, Entry** entry,
 194                                    const net::CompletionCallback& callback) {
 195   DCHECK(entry);
 196   DCHECK(!callback.is_null());
 197   if (is_disabled_)
 198     return net::ERR_ABORTED;
 199
 200   if (is_initializing()) {
 201     pending_calls_.push_back(PendingCall(CREATE, key, entry, callback));
 202     return net::ERR_IO_PENDING;
 203   }
 204
 205   if (!disk_cache_)
 206     return net::ERR_FAILED;
 207
 208   return (new ActiveCall(this))->CreateEntry(key, entry, callback);
 209 }
 210
 211 int AppCacheDiskCache::OpenEntry(int64 key, Entry** entry,
 212                                  const net::CompletionCallback& callback) {
 213   DCHECK(entry);
 214   DCHECK(!callback.is_null());
 215   if (is_disabled_)
 216     return net::ERR_ABORTED;
 217
 218   if (is_initializing()) {
 219     pending_calls_.push_back(PendingCall(OPEN, key, entry, callback));
 220     return net::ERR_IO_PENDING;
 221   }
 222
 223   if (!disk_cache_)
 224     return net::ERR_FAILED;
 225
 226   return (new ActiveCall(this))->OpenEntry(key, entry, callback);
 227 }
 228
 229 int AppCacheDiskCache::DoomEntry(int64 key,
 230                                  const net::CompletionCallback& callback) {
 231   DCHECK(!callback.is_null());
 232   if (is_disabled_)
 233     return net::ERR_ABORTED;
 234
 235   if (is_initializing()) {
 236     pending_calls_.push_back(PendingCall(DOOM, key, NULL, callback));
 237     return net::ERR_IO_PENDING;
 238   }
 239
 240   if (!disk_cache_)
 241     return net::ERR_FAILED;
 242
 243   return (new ActiveCall(this))->DoomEntry(key, callback);
 244 }
 245
 246 AppCacheDiskCache::PendingCall::PendingCall()
 247     : call_type(CREATE),
 248       key(0),
 249       entry(NULL) {
 250 }
 251
 252 AppCacheDiskCache::PendingCall::PendingCall(PendingCallType call_type,
 253     int64 key,
 254     Entry** entry,
 255     const net::CompletionCallback& callback)
 256     : call_type(call_type),
 257       key(key),
 258       entry(entry),
 259       callback(callback) {
 260 }
 261
 262 AppCacheDiskCache::PendingCall::~PendingCall() {}
 263
 264 int AppCacheDiskCache::Init(net::CacheType cache_type,
 265                             const base::FilePath& cache_directory,
 266                             int cache_size, bool force,
 267                             base::MessageLoopProxy* cache_thread,
 268                             const net::CompletionCallback& callback) {
 269   DCHECK(!is_initializing() && !disk_cache_.get());
 270   is_disabled_ = false;
 271   create_backend_callback_ = new CreateBackendCallbackShim(this);
 272
 273   int rv = disk_cache::CreateCacheBackend(
 274       cache_type, net::CACHE_BACKEND_DEFAULT, cache_directory, cache_size,
 275       force, cache_thread, NULL, &(create_backend_callback_->backend_ptr_),
 276       base::Bind(&CreateBackendCallbackShim::Callback,
 277                  create_backend_callback_));
 278   if (rv == net::ERR_IO_PENDING)
 279     init_callback_ = callback;
 280   else
 281     OnCreateBackendComplete(rv);
 282   return rv;
 283 }
 284
 285 void AppCacheDiskCache::OnCreateBackendComplete(int rv) {
 286   if (rv == net::OK) {
 287     disk_cache_ = create_backend_callback_->backend_ptr_.Pass();
 288   }
 289   create_backend_callback_ = NULL;
 290
 291   // Invoke our clients callback function.
 292   if (!init_callback_.is_null()) {
 293     init_callback_.Run(rv);
 294     init_callback_.Reset();
 295   }
 296
 297   // Service pending calls that were queued up while we were initializing.
 298   for (PendingCalls::const_iterator iter = pending_calls_.begin();
 299        iter < pending_calls_.end(); ++iter) {
 300     int rv = net::ERR_FAILED;
 301     switch (iter->call_type) {
 302       case CREATE:
 303         rv = CreateEntry(iter->key, iter->entry, iter->callback);
 304         break;
 305       case OPEN:
 306         rv = OpenEntry(iter->key, iter->entry, iter->callback);
 307         break;
 308       case DOOM:
 309         rv = DoomEntry(iter->key, iter->callback);
 310         break;
 311       default:
 312         NOTREACHED();
 313         break;
 314     }
 315     if (rv != net::ERR_IO_PENDING)
 316       iter->callback.Run(rv);
 317   }
 318   pending_calls_.clear();
 319 }
 320
 321 }  // namespace appcache