OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/blob_storage/chrome_blob_storage_context.h" | 5 #include "content/browser/blob_storage/chrome_blob_storage_context.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/files/file.h" | |
11 #include "base/files/file_enumerator.h" | |
12 #include "base/files/file_util.h" | |
10 #include "base/guid.h" | 13 #include "base/guid.h" |
14 #include "base/metrics/histogram_macros.h" | |
15 #include "base/single_thread_task_runner.h" | |
16 #include "base/task_runner.h" | |
17 #include "base/threading/sequenced_worker_pool.h" | |
11 #include "content/public/browser/blob_handle.h" | 18 #include "content/public/browser/blob_handle.h" |
12 #include "content/public/browser/browser_context.h" | 19 #include "content/public/browser/browser_context.h" |
13 #include "content/public/browser/browser_thread.h" | 20 #include "content/public/browser/browser_thread.h" |
14 #include "storage/browser/blob/blob_data_builder.h" | 21 #include "storage/browser/blob/blob_data_builder.h" |
15 #include "storage/browser/blob/blob_data_handle.h" | 22 #include "storage/browser/blob/blob_data_handle.h" |
16 #include "storage/browser/blob/blob_storage_context.h" | 23 #include "storage/browser/blob/blob_storage_context.h" |
17 | 24 |
25 using base::FilePath; | |
18 using base::UserDataAdapter; | 26 using base::UserDataAdapter; |
19 using storage::BlobStorageContext; | 27 using storage::BlobStorageContext; |
20 | 28 |
21 namespace content { | 29 namespace content { |
22 | 30 |
23 namespace { | 31 namespace { |
32 const char kBlobStorageParentDirectory[] = "blob_storage"; | |
33 | |
34 void CreateBlobDirectory(const FilePath& blob_storage_dir, | |
35 scoped_refptr<base::TaskRunner> io_runner, | |
36 const base::Closure& done) { | |
37 base::File::Error error; | |
38 bool success = base::CreateDirectoryAndGetError(blob_storage_dir, &error); | |
39 LOCAL_HISTOGRAM_BOOLEAN("Storage.Blob.DirectorySuccess", success); | |
40 if (!success) { | |
41 LOCAL_HISTOGRAM_ENUMERATION("Storage.Blob.DirectorySuccess.Error", -error, | |
42 -base::File::FILE_ERROR_MAX); | |
43 } else { | |
44 io_runner->PostTask(FROM_HERE, done); | |
45 } | |
46 } | |
47 | |
48 // Removes all folders in the parent directory except for the | |
49 // |current_run_dir| folder. If this path is empty, then we delete all folders. | |
50 void RemoveOldBlobStorageDirectories(const FilePath& blob_storage_parent, | |
51 const FilePath& current_run_dir) { | |
52 if (!base::DirectoryExists(blob_storage_parent)) { | |
53 return; | |
54 } | |
55 base::FileEnumerator enumerator(blob_storage_parent, false, | |
56 base::FileEnumerator::DIRECTORIES); | |
57 std::vector<std::string> components; | |
58 bool success = true; | |
59 for (base::FilePath name = enumerator.Next(); !name.empty(); | |
60 name = enumerator.Next()) { | |
61 if (current_run_dir.empty() || name != current_run_dir) | |
62 success &= base::DeleteFile(name, true); | |
63 } | |
64 LOCAL_HISTOGRAM_BOOLEAN("Storage.Blob.CleanupSuccess", success); | |
65 } | |
24 | 66 |
25 const char kBlobStorageContextKeyName[] = "content_blob_storage_context"; | 67 const char kBlobStorageContextKeyName[] = "content_blob_storage_context"; |
26 | 68 |
27 class BlobHandleImpl : public BlobHandle { | 69 class BlobHandleImpl : public BlobHandle { |
28 public: | 70 public: |
29 explicit BlobHandleImpl(std::unique_ptr<storage::BlobDataHandle> handle) | 71 explicit BlobHandleImpl(std::unique_ptr<storage::BlobDataHandle> handle) |
30 : handle_(std::move(handle)) {} | 72 : handle_(std::move(handle)) {} |
31 | 73 |
32 ~BlobHandleImpl() override {} | 74 ~BlobHandleImpl() override {} |
33 | 75 |
34 std::string GetUUID() override { return handle_->uuid(); } | 76 std::string GetUUID() override { return handle_->uuid(); } |
35 | 77 |
36 private: | 78 private: |
37 std::unique_ptr<storage::BlobDataHandle> handle_; | 79 std::unique_ptr<storage::BlobDataHandle> handle_; |
38 }; | 80 }; |
39 | 81 |
40 } // namespace | 82 } // namespace |
41 | 83 |
42 ChromeBlobStorageContext::ChromeBlobStorageContext() {} | 84 ChromeBlobStorageContext::ChromeBlobStorageContext() {} |
43 | 85 |
44 ChromeBlobStorageContext* ChromeBlobStorageContext::GetFor( | 86 ChromeBlobStorageContext* ChromeBlobStorageContext::GetFor( |
45 BrowserContext* context) { | 87 BrowserContext* context) { |
46 if (!context->GetUserData(kBlobStorageContextKeyName)) { | 88 if (!context->GetUserData(kBlobStorageContextKeyName)) { |
47 scoped_refptr<ChromeBlobStorageContext> blob = | 89 scoped_refptr<ChromeBlobStorageContext> blob = |
48 new ChromeBlobStorageContext(); | 90 new ChromeBlobStorageContext(); |
49 context->SetUserData( | 91 context->SetUserData( |
50 kBlobStorageContextKeyName, | 92 kBlobStorageContextKeyName, |
51 new UserDataAdapter<ChromeBlobStorageContext>(blob.get())); | 93 new UserDataAdapter<ChromeBlobStorageContext>(blob.get())); |
94 | |
52 // Check first to avoid memory leak in unittests. | 95 // Check first to avoid memory leak in unittests. |
53 if (BrowserThread::IsMessageLoopValid(BrowserThread::IO)) { | 96 bool io_thread_valid = BrowserThread::IsMessageLoopValid(BrowserThread::IO); |
97 if (io_thread_valid) { | |
54 BrowserThread::PostTask( | 98 BrowserThread::PostTask( |
55 BrowserThread::IO, FROM_HERE, | 99 BrowserThread::IO, FROM_HERE, |
56 base::Bind(&ChromeBlobStorageContext::InitializeOnIOThread, blob)); | 100 base::Bind(&ChromeBlobStorageContext::InitializeOnIOThread, blob)); |
57 } | 101 } |
102 | |
103 // If we're not incognito mode, schedule all of our file tasks to enable | |
104 // disk on the storage context. | |
105 if (!context->IsOffTheRecord() && io_thread_valid && | |
106 BrowserThread::IsMessageLoopValid(BrowserThread::FILE)) { | |
Marijn Kruisselbrink
2016/07/12 21:33:06
Does this check still make sense now you're not ac
dmurph
2016/07/14 01:04:30
Done.
| |
107 // Resolve our storage directories. | |
108 base::FilePath blob_storage_parent = | |
109 context->GetPath().Append(kBlobStorageParentDirectory); | |
110 base::FilePath blob_storage_dir = | |
111 blob_storage_parent.Append(base::GenerateGUID()); | |
112 | |
113 scoped_refptr<base::SingleThreadTaskRunner> io_runner = | |
114 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO); | |
115 scoped_refptr<base::SequencedWorkerPool> file_pool = | |
116 BrowserThread::GetBlockingPool(); | |
117 | |
118 // This creates our directory and calls |OnBlobDirectoryCreated| if we're | |
119 // successful. | |
120 file_pool->PostWorkerTaskWithShutdownBehavior( | |
121 FROM_HERE, | |
122 base::Bind( | |
123 &CreateBlobDirectory, blob_storage_dir, io_runner, | |
124 base::Bind(&ChromeBlobStorageContext::OnBlobDirectoryCreated, | |
125 blob, blob_storage_dir)), | |
126 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN); | |
127 | |
128 // Removes our old blob directories if they exist. | |
129 file_pool->PostWorkerTaskWithShutdownBehavior( | |
130 FROM_HERE, base::Bind(&RemoveOldBlobStorageDirectories, | |
131 blob_storage_parent, blob_storage_dir), | |
132 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN); | |
133 } | |
58 } | 134 } |
59 | 135 |
60 return UserDataAdapter<ChromeBlobStorageContext>::Get( | 136 return UserDataAdapter<ChromeBlobStorageContext>::Get( |
61 context, kBlobStorageContextKeyName); | 137 context, kBlobStorageContextKeyName); |
62 } | 138 } |
63 | 139 |
64 void ChromeBlobStorageContext::InitializeOnIOThread() { | 140 void ChromeBlobStorageContext::InitializeOnIOThread() { |
65 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 141 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
66 context_.reset(new BlobStorageContext()); | 142 context_.reset(new BlobStorageContext()); |
143 if (!blob_storage_dir_.empty()) { | |
144 // This happens if we create our blob storage folder before this method is | |
145 // called, so we enable disk here. | |
146 context_->EnableDisk(blob_storage_dir_, BrowserThread::GetBlockingPool()); | |
147 } | |
67 } | 148 } |
68 | 149 |
69 std::unique_ptr<BlobHandle> ChromeBlobStorageContext::CreateMemoryBackedBlob( | 150 std::unique_ptr<BlobHandle> ChromeBlobStorageContext::CreateMemoryBackedBlob( |
70 const char* data, | 151 const char* data, |
71 size_t length) { | 152 size_t length) { |
72 DCHECK_CURRENTLY_ON(BrowserThread::IO); | 153 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
73 | 154 |
74 std::string uuid(base::GenerateGUID()); | 155 std::string uuid(base::GenerateGUID()); |
75 storage::BlobDataBuilder blob_data_builder(uuid); | 156 storage::BlobDataBuilder blob_data_builder(uuid); |
76 blob_data_builder.AppendData(data, length); | 157 blob_data_builder.AppendData(data, length); |
(...skipping 25 matching lines...) Expand all Loading... | |
102 return std::unique_ptr<BlobHandle>(); | 183 return std::unique_ptr<BlobHandle>(); |
103 | 184 |
104 std::unique_ptr<BlobHandle> blob_handle( | 185 std::unique_ptr<BlobHandle> blob_handle( |
105 new BlobHandleImpl(std::move(blob_data_handle))); | 186 new BlobHandleImpl(std::move(blob_data_handle))); |
106 return blob_handle; | 187 return blob_handle; |
107 } | 188 } |
108 | 189 |
109 ChromeBlobStorageContext::~ChromeBlobStorageContext() {} | 190 ChromeBlobStorageContext::~ChromeBlobStorageContext() {} |
110 | 191 |
111 void ChromeBlobStorageContext::DeleteOnCorrectThread() const { | 192 void ChromeBlobStorageContext::DeleteOnCorrectThread() const { |
193 // Schedule a task to delete all blob directories. | |
194 if (!blob_storage_dir_.empty()) { | |
195 BrowserThread::PostTask( | |
196 BrowserThread::FILE, FROM_HERE, | |
Marijn Kruisselbrink
2016/07/12 21:33:06
Should this also be on the blocking pool rather th
dmurph
2016/07/14 01:04:30
Done.
| |
197 base::Bind(&RemoveOldBlobStorageDirectories, | |
198 blob_storage_dir_.DirName(), base::FilePath())); | |
199 } | |
112 if (BrowserThread::IsMessageLoopValid(BrowserThread::IO) && | 200 if (BrowserThread::IsMessageLoopValid(BrowserThread::IO) && |
113 !BrowserThread::CurrentlyOn(BrowserThread::IO)) { | 201 !BrowserThread::CurrentlyOn(BrowserThread::IO)) { |
114 BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, this); | 202 BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, this); |
115 return; | 203 return; |
116 } | 204 } |
117 delete this; | 205 delete this; |
118 } | 206 } |
119 | 207 |
208 void ChromeBlobStorageContext::OnBlobDirectoryCreated( | |
209 const base::FilePath& blob_storage_directory) { | |
210 LOG(ERROR) << "Blob directory successfully created " | |
211 << blob_storage_directory.value(); | |
212 DCHECK(blob_storage_dir_.empty()); | |
213 blob_storage_dir_ = blob_storage_directory; | |
214 if (context_) { | |
215 context_->EnableDisk(blob_storage_dir_, BrowserThread::GetBlockingPool()); | |
216 } | |
217 } | |
218 | |
120 } // namespace content | 219 } // namespace content |
OLD | NEW |