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.
5 #include "base/files/file_path.h"
6 #include "base/metrics/field_trial.h"
7 #include "base/strings/stringprintf.h"
8 #include "net/base/cache_type.h"
9 #include "net/base/net_errors.h"
10 #include "net/disk_cache/backend_impl.h"
11 #include "net/disk_cache/cache_util.h"
12 #include "net/disk_cache/disk_cache.h"
13 #include "net/disk_cache/mem_backend_impl.h"
14 #include "net/disk_cache/simple/simple_backend_impl.h"
16 #ifdef USE_TRACING_CACHE_BACKEND
17 #include "net/disk_cache/tracing_cache_backend.h"
22 // Builds an instance of the backend depending on platform, type, experiments
23 // etc. Takes care of the retry state. This object will self-destroy when
27 CacheCreator(const base::FilePath
& path
, bool force
, int max_bytes
,
28 net::CacheType type
, net::BackendType backend_type
, uint32 flags
,
29 base::MessageLoopProxy
* thread
, net::NetLog
* net_log
,
30 scoped_ptr
<disk_cache::Backend
>* backend
,
31 const net::CompletionCallback
& callback
);
33 // Creates the backend.
39 void DoCallback(int result
);
41 void OnIOComplete(int result
);
43 const base::FilePath path_
;
48 net::BackendType backend_type_
;
50 scoped_refptr
<base::MessageLoopProxy
> thread_
;
51 scoped_ptr
<disk_cache::Backend
>* backend_
;
52 net::CompletionCallback callback_
;
53 scoped_ptr
<disk_cache::Backend
> created_cache_
;
54 net::NetLog
* net_log_
;
56 DISALLOW_COPY_AND_ASSIGN(CacheCreator
);
59 CacheCreator::CacheCreator(
60 const base::FilePath
& path
, bool force
, int max_bytes
,
61 net::CacheType type
, net::BackendType backend_type
, uint32 flags
,
62 base::MessageLoopProxy
* thread
, net::NetLog
* net_log
,
63 scoped_ptr
<disk_cache::Backend
>* backend
,
64 const net::CompletionCallback
& callback
)
68 max_bytes_(max_bytes
),
70 backend_type_(backend_type
),
78 CacheCreator::~CacheCreator() {
81 int CacheCreator::Run() {
82 // TODO(gavinp,pasko): While simple backend development proceeds, we're only
83 // testing it against net::DISK_CACHE. Turn it on for more cache types as
85 if (backend_type_
== net::CACHE_BACKEND_SIMPLE
&& type_
== net::DISK_CACHE
) {
86 disk_cache::SimpleBackendImpl
* simple_cache
=
87 new disk_cache::SimpleBackendImpl(path_
, max_bytes_
, type_
,
88 thread_
.get(), net_log_
);
89 created_cache_
.reset(simple_cache
);
90 return simple_cache
->Init(
91 base::Bind(&CacheCreator::OnIOComplete
, base::Unretained(this)));
93 disk_cache::BackendImpl
* new_cache
=
94 new disk_cache::BackendImpl(path_
, thread_
.get(), net_log_
);
95 created_cache_
.reset(new_cache
);
96 new_cache
->SetMaxSize(max_bytes_
);
97 new_cache
->SetType(type_
);
98 new_cache
->SetFlags(flags_
);
99 int rv
= new_cache
->Init(
100 base::Bind(&CacheCreator::OnIOComplete
, base::Unretained(this)));
101 DCHECK_EQ(net::ERR_IO_PENDING
, rv
);
105 void CacheCreator::DoCallback(int result
) {
106 DCHECK_NE(net::ERR_IO_PENDING
, result
);
107 if (result
== net::OK
) {
108 #ifndef USE_TRACING_CACHE_BACKEND
109 *backend_
= created_cache_
.Pass();
112 new disk_cache::TracingCacheBackend(created_cache_
.Pass()));
115 LOG(ERROR
) << "Unable to create cache";
117 callback_
.Run(result
);
121 // If the initialization of the cache fails, and |force| is true, we will
122 // discard the whole cache and create a new one.
123 void CacheCreator::OnIOComplete(int result
) {
124 if (result
== net::OK
|| !force_
|| retry_
)
125 return DoCallback(result
);
127 // This is a failure and we are supposed to try again, so delete the object,
128 // delete all the files, and try again.
130 created_cache_
.reset();
131 if (!disk_cache::DelayedCacheCleanup(path_
))
132 return DoCallback(result
);
134 // The worker thread will start deleting files soon, but the original folder
135 // is not there anymore... let's create a new set of files.
137 DCHECK_EQ(net::ERR_IO_PENDING
, rv
);
142 namespace disk_cache
{
144 int CreateCacheBackend(net::CacheType type
,
145 net::BackendType backend_type
,
146 const base::FilePath
& path
,
148 bool force
, base::MessageLoopProxy
* thread
,
149 net::NetLog
* net_log
, scoped_ptr
<Backend
>* backend
,
150 const net::CompletionCallback
& callback
) {
151 DCHECK(!callback
.is_null());
152 if (type
== net::MEMORY_CACHE
) {
153 *backend
= disk_cache::MemBackendImpl::CreateBackend(max_bytes
, net_log
);
154 return *backend
? net::OK
: net::ERR_FAILED
;
157 CacheCreator
* creator
= new CacheCreator(path
, force
, max_bytes
, type
,
159 thread
, net_log
, backend
, callback
);
160 return creator
->Run();
163 } // namespace disk_cache