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