OLD | NEW |
(Empty) | |
| 1 // Copyright 2015 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/base/upload_disk_cache_entry_element_reader.h" |
| 6 |
| 7 #include <stdint.h> |
| 8 |
| 9 #include <algorithm> |
| 10 #include <string> |
| 11 #include <vector> |
| 12 |
| 13 #include "base/basictypes.h" |
| 14 #include "base/bind.h" |
| 15 #include "base/callback.h" |
| 16 #include "base/logging.h" |
| 17 #include "base/macros.h" |
| 18 #include "base/memory/ref_counted.h" |
| 19 #include "base/memory/scoped_ptr.h" |
| 20 #include "base/time/time.h" |
| 21 #include "net/base/io_buffer.h" |
| 22 #include "net/base/net_errors.h" |
| 23 #include "net/base/test_completion_callback.h" |
| 24 #include "net/disk_cache/disk_cache.h" |
| 25 #include "testing/gtest/include/gtest/gtest.h" |
| 26 #include "testing/platform_test.h" |
| 27 |
| 28 namespace net { |
| 29 namespace { |
| 30 |
| 31 const int kTestDiskCacheStreamIndex = 0; |
| 32 |
| 33 const char kDataKey[] = "a key"; |
| 34 |
| 35 const char kData[] = "this is data in a disk cache entry"; |
| 36 const size_t kDataSize = arraysize(kData) - 1; |
| 37 |
| 38 // A disk_cache::Entry that arbitrarily delays the completion of a read |
| 39 // operation to allow testing some races without flake. This is particularly |
| 40 // relevant in this unit test, which uses the always-synchronous MEMORY_CACHE. |
| 41 class DelayedReadEntry : public disk_cache::Entry { |
| 42 public: |
| 43 explicit DelayedReadEntry(disk_cache::ScopedEntryPtr entry) |
| 44 : entry_(entry.Pass()) {} |
| 45 ~DelayedReadEntry() override { EXPECT_FALSE(HasPendingReadCallbacks()); } |
| 46 |
| 47 bool HasPendingReadCallbacks() { return !pending_read_callbacks_.empty(); } |
| 48 |
| 49 void RunPendingReadCallbacks() { |
| 50 std::vector<base::Callback<void(void)>> callbacks; |
| 51 pending_read_callbacks_.swap(callbacks); |
| 52 for (const auto& callback : callbacks) |
| 53 callback.Run(); |
| 54 } |
| 55 |
| 56 // From disk_cache::Entry: |
| 57 void Doom() override { entry_->Doom(); } |
| 58 |
| 59 void Close() override { delete this; } // Note this is required by the API. |
| 60 |
| 61 std::string GetKey() const override { return entry_->GetKey(); } |
| 62 |
| 63 base::Time GetLastUsed() const override { return entry_->GetLastUsed(); } |
| 64 |
| 65 base::Time GetLastModified() const override { |
| 66 return entry_->GetLastModified(); |
| 67 } |
| 68 |
| 69 int32 GetDataSize(int index) const override { |
| 70 return entry_->GetDataSize(index); |
| 71 } |
| 72 |
| 73 int ReadData(int index, |
| 74 int offset, |
| 75 IOBuffer* buf, |
| 76 int buf_len, |
| 77 const CompletionCallback& original_callback) override { |
| 78 TestCompletionCallback callback; |
| 79 int rv = entry_->ReadData(index, offset, buf, buf_len, callback.callback()); |
| 80 DCHECK_NE(rv, ERR_IO_PENDING) |
| 81 << "Test expects to use a MEMORY_CACHE instance, which is synchronous."; |
| 82 pending_read_callbacks_.push_back(base::Bind(original_callback, rv)); |
| 83 return ERR_IO_PENDING; |
| 84 } |
| 85 |
| 86 int WriteData(int index, |
| 87 int offset, |
| 88 IOBuffer* buf, |
| 89 int buf_len, |
| 90 const CompletionCallback& callback, |
| 91 bool truncate) override { |
| 92 return entry_->WriteData(index, offset, buf, buf_len, callback, truncate); |
| 93 } |
| 94 |
| 95 int ReadSparseData(int64 offset, |
| 96 IOBuffer* buf, |
| 97 int buf_len, |
| 98 const CompletionCallback& callback) override { |
| 99 return entry_->ReadSparseData(offset, buf, buf_len, callback); |
| 100 } |
| 101 |
| 102 int WriteSparseData(int64 offset, |
| 103 IOBuffer* buf, |
| 104 int buf_len, |
| 105 const CompletionCallback& callback) override { |
| 106 return entry_->WriteSparseData(offset, buf, buf_len, callback); |
| 107 } |
| 108 |
| 109 int GetAvailableRange(int64 offset, |
| 110 int len, |
| 111 int64* start, |
| 112 const CompletionCallback& callback) override { |
| 113 return entry_->GetAvailableRange(offset, len, start, callback); |
| 114 } |
| 115 |
| 116 bool CouldBeSparse() const override { return entry_->CouldBeSparse(); } |
| 117 |
| 118 void CancelSparseIO() override { entry_->CancelSparseIO(); } |
| 119 |
| 120 int ReadyForSparseIO(const CompletionCallback& callback) override { |
| 121 return entry_->ReadyForSparseIO(callback); |
| 122 } |
| 123 |
| 124 private: |
| 125 disk_cache::ScopedEntryPtr entry_; |
| 126 std::vector<base::Callback<void(void)>> pending_read_callbacks_; |
| 127 }; |
| 128 |
| 129 class UploadDiskCacheEntryElementReaderTest : public PlatformTest { |
| 130 public: |
| 131 UploadDiskCacheEntryElementReaderTest() {} |
| 132 |
| 133 ~UploadDiskCacheEntryElementReaderTest() override {} |
| 134 |
| 135 void SetUp() override { |
| 136 TestCompletionCallback callback; |
| 137 int rv = disk_cache::CreateCacheBackend( |
| 138 MEMORY_CACHE, CACHE_BACKEND_DEFAULT, base::FilePath(), 0, false, |
| 139 nullptr, nullptr, &cache_, callback.callback()); |
| 140 ASSERT_EQ(OK, callback.GetResult(rv)); |
| 141 |
| 142 disk_cache::Entry* tmp_entry = nullptr; |
| 143 rv = cache_->CreateEntry(kDataKey, &tmp_entry, callback.callback()); |
| 144 ASSERT_EQ(OK, callback.GetResult(rv)); |
| 145 entry_.reset(tmp_entry); |
| 146 |
| 147 scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(kData); |
| 148 rv = entry_->WriteData(kTestDiskCacheStreamIndex, 0, io_buffer.get(), |
| 149 kDataSize, callback.callback(), false); |
| 150 EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv)); |
| 151 } |
| 152 |
| 153 void set_entry(disk_cache::ScopedEntryPtr entry) { entry_.swap(entry); } |
| 154 disk_cache::Entry* entry() { return entry_.get(); } |
| 155 disk_cache::ScopedEntryPtr release_entry() { return entry_.Pass(); } |
| 156 |
| 157 private: |
| 158 scoped_ptr<disk_cache::Backend> cache_; |
| 159 disk_cache::ScopedEntryPtr entry_; |
| 160 }; |
| 161 |
| 162 TEST_F(UploadDiskCacheEntryElementReaderTest, ReadAll) { |
| 163 UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex, |
| 164 0, kDataSize); |
| 165 EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining()); |
| 166 |
| 167 char read_buffer[kDataSize]; |
| 168 std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0'); |
| 169 |
| 170 scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer); |
| 171 TestCompletionCallback callback; |
| 172 int rv = reader.Read(io_buffer.get(), kDataSize, callback.callback()); |
| 173 EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv)); |
| 174 EXPECT_EQ(0U, reader.BytesRemaining()) |
| 175 << "Expected a single read of |kDataSize| to retrieve entire entry."; |
| 176 EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize)); |
| 177 } |
| 178 |
| 179 TEST_F(UploadDiskCacheEntryElementReaderTest, ReadPartially) { |
| 180 UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex, |
| 181 0, kDataSize); |
| 182 EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining()); |
| 183 |
| 184 const size_t kReadBuffer1Size = kDataSize / 3; |
| 185 char read_buffer1[kReadBuffer1Size]; |
| 186 std::fill(read_buffer1, read_buffer1 + arraysize(read_buffer1), '\0'); |
| 187 |
| 188 scoped_refptr<IOBuffer> io_buffer1 = new WrappedIOBuffer(read_buffer1); |
| 189 |
| 190 const size_t kReadBuffer2Size = kDataSize - kReadBuffer1Size; |
| 191 char read_buffer2[kReadBuffer2Size]; |
| 192 scoped_refptr<IOBuffer> io_buffer2 = new WrappedIOBuffer(read_buffer2); |
| 193 |
| 194 TestCompletionCallback callback; |
| 195 int rv = reader.Read(io_buffer1.get(), kReadBuffer1Size, callback.callback()); |
| 196 EXPECT_EQ(static_cast<int>(kReadBuffer1Size), callback.GetResult(rv)); |
| 197 EXPECT_EQ(static_cast<uint64_t>(kReadBuffer2Size), reader.BytesRemaining()); |
| 198 |
| 199 rv = reader.Read(io_buffer2.get(), kReadBuffer2Size, callback.callback()); |
| 200 EXPECT_EQ(static_cast<int>(kReadBuffer2Size), callback.GetResult(rv)); |
| 201 EXPECT_EQ(0U, reader.BytesRemaining()); |
| 202 |
| 203 EXPECT_EQ(std::string(kData, kDataSize), |
| 204 std::string(read_buffer1, kReadBuffer1Size) + |
| 205 std::string(read_buffer2, kReadBuffer2Size)); |
| 206 } |
| 207 |
| 208 TEST_F(UploadDiskCacheEntryElementReaderTest, ReadTooMuch) { |
| 209 UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex, |
| 210 0, kDataSize); |
| 211 EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining()); |
| 212 |
| 213 const size_t kTooLargeSize = kDataSize + kDataSize / 2; |
| 214 |
| 215 char read_buffer[kTooLargeSize]; |
| 216 std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0'); |
| 217 |
| 218 scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer); |
| 219 TestCompletionCallback callback; |
| 220 int rv = reader.Read(io_buffer.get(), kTooLargeSize, callback.callback()); |
| 221 EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv)); |
| 222 EXPECT_EQ(0U, reader.BytesRemaining()); |
| 223 EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize)); |
| 224 } |
| 225 |
| 226 TEST_F(UploadDiskCacheEntryElementReaderTest, ReadAsync) { |
| 227 DelayedReadEntry* delayed_read_entry = new DelayedReadEntry(release_entry()); |
| 228 set_entry(disk_cache::ScopedEntryPtr(delayed_read_entry)); |
| 229 |
| 230 UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex, |
| 231 0, kDataSize); |
| 232 |
| 233 char read_buffer[kDataSize]; |
| 234 std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0'); |
| 235 |
| 236 scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer); |
| 237 TestCompletionCallback callback; |
| 238 int rv = reader.Read(io_buffer.get(), kDataSize, callback.callback()); |
| 239 EXPECT_EQ(ERR_IO_PENDING, rv); |
| 240 EXPECT_TRUE(delayed_read_entry->HasPendingReadCallbacks()); |
| 241 EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining()); |
| 242 |
| 243 delayed_read_entry->RunPendingReadCallbacks(); |
| 244 EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv)); |
| 245 EXPECT_EQ(0U, reader.BytesRemaining()) |
| 246 << "Expected a single read of |kDataSize| to retrieve entire entry."; |
| 247 EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize)); |
| 248 } |
| 249 |
| 250 TEST_F(UploadDiskCacheEntryElementReaderTest, MultipleInit) { |
| 251 UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex, |
| 252 0, kDataSize); |
| 253 char read_buffer[kDataSize]; |
| 254 std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0'); |
| 255 |
| 256 scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer); |
| 257 TestCompletionCallback callback; |
| 258 int rv = reader.Read(io_buffer.get(), kDataSize, callback.callback()); |
| 259 EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv)); |
| 260 EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize)); |
| 261 |
| 262 rv = reader.Init(callback.callback()); |
| 263 EXPECT_EQ(OK, callback.GetResult(rv)); |
| 264 EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining()); |
| 265 rv = reader.Read(io_buffer.get(), kDataSize, callback.callback()); |
| 266 EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv)); |
| 267 EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize)); |
| 268 } |
| 269 |
| 270 TEST_F(UploadDiskCacheEntryElementReaderTest, InitDuringAsyncOperation) { |
| 271 DelayedReadEntry* delayed_read_entry = new DelayedReadEntry(release_entry()); |
| 272 set_entry(disk_cache::ScopedEntryPtr(delayed_read_entry)); |
| 273 |
| 274 UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex, |
| 275 0, kDataSize); |
| 276 char read_buffer[kDataSize]; |
| 277 std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0'); |
| 278 |
| 279 scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer); |
| 280 TestCompletionCallback read_callback; |
| 281 int rv = reader.Read(io_buffer.get(), kDataSize, read_callback.callback()); |
| 282 EXPECT_EQ(ERR_IO_PENDING, rv); |
| 283 EXPECT_TRUE(delayed_read_entry->HasPendingReadCallbacks()); |
| 284 EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining()); |
| 285 |
| 286 TestCompletionCallback init_callback; |
| 287 rv = reader.Init(init_callback.callback()); |
| 288 EXPECT_EQ(OK, init_callback.GetResult(rv)); |
| 289 |
| 290 delayed_read_entry->RunPendingReadCallbacks(); |
| 291 EXPECT_FALSE(delayed_read_entry->HasPendingReadCallbacks()); |
| 292 EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining()); |
| 293 |
| 294 char read_buffer2[kDataSize]; |
| 295 std::fill(read_buffer2, read_buffer2 + arraysize(read_buffer2), '\0'); |
| 296 scoped_refptr<IOBuffer> io_buffer2 = new WrappedIOBuffer(read_buffer2); |
| 297 TestCompletionCallback read_callback2; |
| 298 rv = reader.Read(io_buffer2.get(), kDataSize, read_callback2.callback()); |
| 299 EXPECT_EQ(ERR_IO_PENDING, rv); |
| 300 EXPECT_TRUE(delayed_read_entry->HasPendingReadCallbacks()); |
| 301 EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining()); |
| 302 |
| 303 delayed_read_entry->RunPendingReadCallbacks(); |
| 304 EXPECT_FALSE(delayed_read_entry->HasPendingReadCallbacks()); |
| 305 read_callback2.WaitForResult(); // Succeeds if this does not deadlock. |
| 306 EXPECT_EQ(std::string(kData, kDataSize), |
| 307 std::string(read_buffer2, kDataSize)); |
| 308 } |
| 309 |
| 310 TEST_F(UploadDiskCacheEntryElementReaderTest, Range) { |
| 311 const size_t kOffset = kDataSize / 4; |
| 312 const size_t kLength = kDataSize / 3; |
| 313 |
| 314 UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex, |
| 315 kOffset, kLength); |
| 316 EXPECT_EQ(static_cast<uint64_t>(kLength), reader.BytesRemaining()); |
| 317 |
| 318 char read_buffer[kLength]; |
| 319 std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0'); |
| 320 |
| 321 scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer); |
| 322 TestCompletionCallback callback; |
| 323 int rv = reader.Read(io_buffer.get(), kLength, callback.callback()); |
| 324 EXPECT_EQ(static_cast<int>(kLength), callback.GetResult(rv)); |
| 325 EXPECT_EQ(0U, reader.BytesRemaining()); |
| 326 EXPECT_EQ(std::string(kData + kOffset, kLength), |
| 327 std::string(read_buffer, kLength)); |
| 328 } |
| 329 |
| 330 } // namespace |
| 331 } // namespace net |
OLD | NEW |