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 "net/disk_cache/file.h" 6 7 #include "base/bind.h" 8 #include "base/lazy_instance.h" 9 #include "base/location.h" 10 #include "base/logging.h" 11 #include "base/run_loop.h" 12 #include "base/task_runner_util.h" 13 #include "base/threading/sequenced_worker_pool.h" 14 #include "net/base/net_errors.h" 15 #include "net/disk_cache/disk_cache.h" 16 17 namespace { 18 19 // The maximum number of threads for this pool. 20 const int kMaxThreads = 20; 21 22 class FileWorkerPool : public base::SequencedWorkerPool { 23 public: 24 FileWorkerPool() : base::SequencedWorkerPool(kMaxThreads, "CachePool") {} 25 26 protected: 27 virtual ~FileWorkerPool() {} 28 }; 29 30 base::LazyInstance<FileWorkerPool>::Leaky s_worker_pool = 31 LAZY_INSTANCE_INITIALIZER; 32 33 } // namespace 34 35 namespace disk_cache { 36 37 File::File(base::PlatformFile file) 38 : init_(true), 39 mixed_(true), 40 platform_file_(file), 41 sync_platform_file_(base::kInvalidPlatformFileValue) { 42 } 43 44 bool File::Init(const base::FilePath& name) { 45 if (init_) 46 return false; 47 48 int flags = base::PLATFORM_FILE_OPEN | 49 base::PLATFORM_FILE_READ | 50 base::PLATFORM_FILE_WRITE; 51 platform_file_ = base::CreatePlatformFile(name, flags, NULL, NULL); 52 if (platform_file_ < 0) { 53 platform_file_ = 0; 54 return false; 55 } 56 57 init_ = true; 58 return true; 59 } 60 61 base::PlatformFile File::platform_file() const { 62 return platform_file_; 63 } 64 65 bool File::IsValid() const { 66 if (!init_) 67 return false; 68 return (base::kInvalidPlatformFileValue != platform_file_); 69 } 70 71 bool File::Read(void* buffer, size_t buffer_len, size_t offset) { 72 DCHECK(init_); 73 if (buffer_len > static_cast<size_t>(kint32max) || 74 offset > static_cast<size_t>(kint32max)) { 75 return false; 76 } 77 78 int ret = base::ReadPlatformFile(platform_file_, offset, 79 static_cast<char*>(buffer), buffer_len); 80 return (static_cast<size_t>(ret) == buffer_len); 81 } 82 83 bool File::Write(const void* buffer, size_t buffer_len, size_t offset) { 84 DCHECK(init_); 85 if (buffer_len > static_cast<size_t>(kint32max) || 86 offset > static_cast<size_t>(kint32max)) { 87 return false; 88 } 89 90 int ret = base::WritePlatformFile(platform_file_, offset, 91 static_cast<const char*>(buffer), 92 buffer_len); 93 return (static_cast<size_t>(ret) == buffer_len); 94 } 95 96 bool File::Read(void* buffer, size_t buffer_len, size_t offset, 97 FileIOCallback* callback, bool* completed) { 98 DCHECK(init_); 99 if (!callback) { 100 if (completed) 101 *completed = true; 102 return Read(buffer, buffer_len, offset); 103 } 104 105 if (buffer_len > static_cast<size_t>(kint32max) || 106 offset > static_cast<size_t>(kint32max)) { 107 return false; 108 } 109 110 base::PostTaskAndReplyWithResult( 111 s_worker_pool.Pointer(), FROM_HERE, 112 base::Bind(&File::DoRead, this, buffer, buffer_len, offset), 113 base::Bind(&File::OnOperationComplete, this, callback)); 114 115 *completed = false; 116 return true; 117 } 118 119 bool File::Write(const void* buffer, size_t buffer_len, size_t offset, 120 FileIOCallback* callback, bool* completed) { 121 DCHECK(init_); 122 if (!callback) { 123 if (completed) 124 *completed = true; 125 return Write(buffer, buffer_len, offset); 126 } 127 128 if (buffer_len > static_cast<size_t>(kint32max) || 129 offset > static_cast<size_t>(kint32max)) { 130 return false; 131 } 132 133 base::PostTaskAndReplyWithResult( 134 s_worker_pool.Pointer(), FROM_HERE, 135 base::Bind(&File::DoWrite, this, buffer, buffer_len, offset), 136 base::Bind(&File::OnOperationComplete, this, callback)); 137 138 *completed = false; 139 return true; 140 } 141 142 bool File::SetLength(size_t length) { 143 DCHECK(init_); 144 if (length > kuint32max) 145 return false; 146 147 return base::TruncatePlatformFile(platform_file_, length); 148 } 149 150 size_t File::GetLength() { 151 DCHECK(init_); 152 int64 len = base::SeekPlatformFile(platform_file_, 153 base::PLATFORM_FILE_FROM_END, 0); 154 155 if (len > static_cast<int64>(kuint32max)) 156 return kuint32max; 157 158 return static_cast<size_t>(len); 159 } 160 161 // Static. 162 void File::WaitForPendingIO(int* num_pending_io) { 163 // We are running unit tests so we should wait for all callbacks. Sadly, the 164 // worker pool only waits for tasks on the worker pool, not the "Reply" tasks 165 // so we have to let the current message loop to run. 166 s_worker_pool.Get().FlushForTesting(); 167 base::RunLoop().RunUntilIdle(); 168 } 169 170 // Static. 171 void File::DropPendingIO() { 172 } 173 174 175 File::~File() { 176 if (IsValid()) 177 base::ClosePlatformFile(platform_file_); 178 } 179 180 // Runs on a worker thread. 181 int File::DoRead(void* buffer, size_t buffer_len, size_t offset) { 182 if (Read(const_cast<void*>(buffer), buffer_len, offset)) 183 return static_cast<int>(buffer_len); 184 185 return net::ERR_CACHE_READ_FAILURE; 186 } 187 188 // Runs on a worker thread. 189 int File::DoWrite(const void* buffer, size_t buffer_len, size_t offset) { 190 if (Write(const_cast<void*>(buffer), buffer_len, offset)) 191 return static_cast<int>(buffer_len); 192 193 return net::ERR_CACHE_WRITE_FAILURE; 194 } 195 196 // This method actually makes sure that the last reference to the file doesn't 197 // go away on the worker pool. 198 void File::OnOperationComplete(FileIOCallback* callback, int result) { 199 callback->OnFileIOComplete(result); 200 } 201 202 } // namespace disk_cache 203
