net/disk_cache/cache_creator.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 "base/files/file_path.h"
   6 #include "base/metrics/field_trial.h"
   7 #include "base/single_thread_task_runner.h"
   8 #include "base/strings/stringprintf.h"
   9 #include "net/base/cache_type.h"
  10 #include "net/base/net_errors.h"
  11 #include "net/disk_cache/blockfile/backend_impl.h"
  12 #include "net/disk_cache/cache_util.h"
  13 #include "net/disk_cache/disk_cache.h"
  14 #include "net/disk_cache/memory/mem_backend_impl.h"
  15 #include "net/disk_cache/simple/simple_backend_impl.h"
  16
  17 namespace {
  18
  19 // Builds an instance of the backend depending on platform, type, experiments
  20 // etc. Takes care of the retry state. This object will self-destroy when
  21 // finished.
  22 class CacheCreator {
  23  public:
  24   CacheCreator(const base::FilePath& path,
  25                bool force,
  26                int max_bytes,
  27                net::CacheType type,
  28                net::BackendType backend_type,
  29                uint32 flags,
  30                const scoped_refptr<base::SingleThreadTaskRunner>& thread,
  31                net::NetLog* net_log,
  32                scoped_ptr<disk_cache::Backend>* backend,
  33                const net::CompletionCallback& callback);
  34
  35   // Creates the backend.
  36   int Run();
  37
  38  private:
  39   ~CacheCreator();
  40
  41   void DoCallback(int result);
  42
  43   void OnIOComplete(int result);
  44
  45   const base::FilePath path_;
  46   bool force_;
  47   bool retry_;
  48   int max_bytes_;
  49   net::CacheType type_;
  50   net::BackendType backend_type_;
  51   uint32 flags_;
  52   scoped_refptr<base::SingleThreadTaskRunner> thread_;
  53   scoped_ptr<disk_cache::Backend>* backend_;
  54   net::CompletionCallback callback_;
  55   scoped_ptr<disk_cache::Backend> created_cache_;
  56   net::NetLog* net_log_;
  57
  58   DISALLOW_COPY_AND_ASSIGN(CacheCreator);
  59 };
  60
  61 CacheCreator::CacheCreator(
  62     const base::FilePath& path,
  63     bool force,
  64     int max_bytes,
  65     net::CacheType type,
  66     net::BackendType backend_type,
  67     uint32 flags,
  68     const scoped_refptr<base::SingleThreadTaskRunner>& thread,
  69     net::NetLog* net_log,
  70     scoped_ptr<disk_cache::Backend>* backend,
  71     const net::CompletionCallback& callback)
  72     : path_(path),
  73       force_(force),
  74       retry_(false),
  75       max_bytes_(max_bytes),
  76       type_(type),
  77       backend_type_(backend_type),
  78       flags_(flags),
  79       thread_(thread),
  80       backend_(backend),
  81       callback_(callback),
  82       net_log_(net_log) {
  83 }
  84
  85 CacheCreator::~CacheCreator() {
  86 }
  87
  88 int CacheCreator::Run() {
  89 #if defined(OS_ANDROID)
  90   static const bool kSimpleBackendIsDefault = true;
  91 #else
  92   static const bool kSimpleBackendIsDefault = false;
  93 #endif
  94   if (backend_type_ == net::CACHE_BACKEND_SIMPLE ||
  95       (backend_type_ == net::CACHE_BACKEND_DEFAULT &&
  96        kSimpleBackendIsDefault)) {
  97     disk_cache::SimpleBackendImpl* simple_cache =
  98         new disk_cache::SimpleBackendImpl(
  99             path_, max_bytes_, type_, thread_, net_log_);
 100     created_cache_.reset(simple_cache);
 101     return simple_cache->Init(
 102         base::Bind(&CacheCreator::OnIOComplete, base::Unretained(this)));
 103   }
 104
 105   // Avoid references to blockfile functions on Android to reduce binary size.
 106 #if defined(OS_ANDROID)
 107   return net::ERR_FAILED;
 108 #else
 109   disk_cache::BackendImpl* new_cache =
 110       new disk_cache::BackendImpl(path_, thread_, net_log_);
 111   created_cache_.reset(new_cache);
 112   new_cache->SetMaxSize(max_bytes_);
 113   new_cache->SetType(type_);
 114   new_cache->SetFlags(flags_);
 115   int rv = new_cache->Init(
 116       base::Bind(&CacheCreator::OnIOComplete, base::Unretained(this)));
 117   DCHECK_EQ(net::ERR_IO_PENDING, rv);
 118   return rv;
 119 #endif
 120 }
 121
 122 void CacheCreator::DoCallback(int result) {
 123   DCHECK_NE(net::ERR_IO_PENDING, result);
 124   if (result == net::OK) {
 125 #ifndef USE_TRACING_CACHE_BACKEND
 126     *backend_ = created_cache_.Pass();
 127 #else
 128     *backend_.reset(
 129         new disk_cache::TracingCacheBackend(created_cache_.Pass()));
 130 #endif
 131   } else {
 132     LOG(ERROR) << "Unable to create cache";
 133     created_cache_.reset();
 134   }
 135   callback_.Run(result);
 136   delete this;
 137 }
 138
 139 // If the initialization of the cache fails, and |force| is true, we will
 140 // discard the whole cache and create a new one.
 141 void CacheCreator::OnIOComplete(int result) {
 142   if (result == net::OK || !force_ || retry_)
 143     return DoCallback(result);
 144
 145   // This is a failure and we are supposed to try again, so delete the object,
 146   // delete all the files, and try again.
 147   retry_ = true;
 148   created_cache_.reset();
 149   if (!disk_cache::DelayedCacheCleanup(path_))
 150     return DoCallback(result);
 151
 152   // The worker thread will start deleting files soon, but the original folder
 153   // is not there anymore... let's create a new set of files.
 154   int rv = Run();
 155   DCHECK_EQ(net::ERR_IO_PENDING, rv);
 156 }
 157
 158 }  // namespace
 159
 160 namespace disk_cache {
 161
 162 int CreateCacheBackend(
 163     net::CacheType type,
 164     net::BackendType backend_type,
 165     const base::FilePath& path,
 166     int max_bytes,
 167     bool force,
 168     const scoped_refptr<base::SingleThreadTaskRunner>& thread,
 169     net::NetLog* net_log,
 170     scoped_ptr<Backend>* backend,
 171     const net::CompletionCallback& callback) {
 172   DCHECK(!callback.is_null());
 173   if (type == net::MEMORY_CACHE) {
 174     *backend = disk_cache::MemBackendImpl::CreateBackend(max_bytes, net_log);
 175     return *backend ? net::OK : net::ERR_FAILED;
 176   }
 177   DCHECK(thread.get());
 178   CacheCreator* creator = new CacheCreator(path,
 179                                            force,
 180                                            max_bytes,
 181                                            type,
 182                                            backend_type,
 183                                            kNone,
 184                                            thread,
 185                                            net_log,
 186                                            backend,
 187                                            callback);
 188   return creator->Run();
 189 }
 190
 191 }  // namespace disk_cache