OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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 "base/basictypes.h" | 5 #include "base/basictypes.h" |
6 #include "base/bind.h" | 6 #include "base/bind.h" |
7 #include "base/files/file_path.h" | 7 #include "base/files/file_path.h" |
8 #include "base/files/file_util.h" | 8 #include "base/files/file_util.h" |
9 #include "base/files/scoped_temp_dir.h" | 9 #include "base/files/scoped_temp_dir.h" |
10 #include "base/memory/ref_counted.h" | 10 #include "base/memory/ref_counted.h" |
(...skipping 11 matching lines...) Expand all Loading... |
22 #include "net/url_request/url_request.h" | 22 #include "net/url_request/url_request.h" |
23 #include "net/url_request/url_request_context.h" | 23 #include "net/url_request/url_request_context.h" |
24 #include "net/url_request/url_request_job_factory_impl.h" | 24 #include "net/url_request/url_request_job_factory_impl.h" |
25 #include "storage/browser/blob/blob_url_request_job.h" | 25 #include "storage/browser/blob/blob_url_request_job.h" |
26 #include "storage/browser/fileapi/file_system_context.h" | 26 #include "storage/browser/fileapi/file_system_context.h" |
27 #include "storage/browser/fileapi/file_system_operation_context.h" | 27 #include "storage/browser/fileapi/file_system_operation_context.h" |
28 #include "storage/browser/fileapi/file_system_url.h" | 28 #include "storage/browser/fileapi/file_system_url.h" |
29 #include "storage/common/blob/blob_data.h" | 29 #include "storage/common/blob/blob_data.h" |
30 #include "testing/gtest/include/gtest/gtest.h" | 30 #include "testing/gtest/include/gtest/gtest.h" |
31 | 31 |
32 using storage::BlobData; | 32 using storage::BlobDataSnapshot; |
| 33 using storage::BlobDataBuilder; |
33 using storage::BlobURLRequestJob; | 34 using storage::BlobURLRequestJob; |
34 | 35 |
35 namespace content { | 36 namespace content { |
36 | 37 |
37 namespace { | 38 namespace { |
38 | 39 |
39 const int kBufferSize = 1024; | 40 const int kBufferSize = 1024; |
40 const char kTestData1[] = "Hello"; | 41 const char kTestData1[] = "Hello"; |
41 const char kTestData2[] = "Here it is data."; | 42 const char kTestData2[] = "Here it is data."; |
42 const char kTestFileData1[] = "0123456789"; | 43 const char kTestFileData1[] = "0123456789"; |
(...skipping 14 matching lines...) Expand all Loading... |
57 // A simple ProtocolHandler implementation to create BlobURLRequestJob. | 58 // A simple ProtocolHandler implementation to create BlobURLRequestJob. |
58 class MockProtocolHandler : | 59 class MockProtocolHandler : |
59 public net::URLRequestJobFactory::ProtocolHandler { | 60 public net::URLRequestJobFactory::ProtocolHandler { |
60 public: | 61 public: |
61 MockProtocolHandler(BlobURLRequestJobTest* test) : test_(test) {} | 62 MockProtocolHandler(BlobURLRequestJobTest* test) : test_(test) {} |
62 | 63 |
63 // net::URLRequestJobFactory::ProtocolHandler override. | 64 // net::URLRequestJobFactory::ProtocolHandler override. |
64 net::URLRequestJob* MaybeCreateJob( | 65 net::URLRequestJob* MaybeCreateJob( |
65 net::URLRequest* request, | 66 net::URLRequest* request, |
66 net::NetworkDelegate* network_delegate) const override { | 67 net::NetworkDelegate* network_delegate) const override { |
67 return new BlobURLRequestJob(request, | 68 return new BlobURLRequestJob(request, network_delegate, |
68 network_delegate, | 69 test_->blob_data_snapshot_.get(), |
69 test_->blob_data_.get(), | |
70 test_->file_system_context_.get(), | 70 test_->file_system_context_.get(), |
71 base::MessageLoopProxy::current().get()); | 71 base::MessageLoopProxy::current().get()); |
72 } | 72 } |
73 | 73 |
74 private: | 74 private: |
75 BlobURLRequestJobTest* test_; | 75 BlobURLRequestJobTest* test_; |
76 }; | 76 }; |
77 | 77 |
78 BlobURLRequestJobTest() | 78 BlobURLRequestJobTest() |
79 : blob_data_(new BlobData()), | 79 : blob_data_(new BlobDataBuilder("uuid")), expected_status_code_(0) {} |
80 expected_status_code_(0) {} | |
81 | 80 |
82 void SetUp() override { | 81 void SetUp() override { |
83 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); | 82 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); |
84 | 83 |
85 temp_file1_ = temp_dir_.path().AppendASCII("BlobFile1.dat"); | 84 temp_file1_ = temp_dir_.path().AppendASCII("BlobFile1.dat"); |
86 ASSERT_EQ(static_cast<int>(arraysize(kTestFileData1) - 1), | 85 ASSERT_EQ(static_cast<int>(arraysize(kTestFileData1) - 1), |
87 base::WriteFile(temp_file1_, kTestFileData1, | 86 base::WriteFile(temp_file1_, kTestFileData1, |
88 arraysize(kTestFileData1) - 1)); | 87 arraysize(kTestFileData1) - 1)); |
89 base::File::Info file_info1; | 88 base::File::Info file_info1; |
90 base::GetFileInfo(temp_file1_, &file_info1); | 89 base::GetFileInfo(temp_file1_, &file_info1); |
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
212 *expected_result += std::string(kTestFileSystemFileData1 + 3, 4); | 211 *expected_result += std::string(kTestFileSystemFileData1 + 3, 4); |
213 *expected_result += std::string(kTestData2 + 4, 5); | 212 *expected_result += std::string(kTestData2 + 4, 5); |
214 *expected_result += std::string(kTestFileData2 + 5, 6); | 213 *expected_result += std::string(kTestFileData2 + 5, 6); |
215 *expected_result += std::string(kTestFileSystemFileData2 + 6, 7); | 214 *expected_result += std::string(kTestFileSystemFileData2 + 6, 7); |
216 } | 215 } |
217 | 216 |
218 // This only works if all the Blob items have a definite pre-computed length. | 217 // This only works if all the Blob items have a definite pre-computed length. |
219 // Otherwise, this will fail a CHECK. | 218 // Otherwise, this will fail a CHECK. |
220 int64 GetTotalBlobLength() const { | 219 int64 GetTotalBlobLength() const { |
221 int64 total = 0; | 220 int64 total = 0; |
222 const std::vector<BlobData::Item>& items = blob_data_->items(); | 221 scoped_ptr<BlobDataSnapshot> data = blob_data_->Build(); |
223 for (std::vector<BlobData::Item>::const_iterator it = items.begin(); | 222 const auto& items = data->items(); |
224 it != items.end(); ++it) { | 223 for (const auto& item : items) { |
225 int64 length = base::checked_cast<int64>(it->length()); | 224 int64 length = base::checked_cast<int64>(item->length()); |
226 CHECK(length <= kint64max - total); | 225 CHECK(length <= kint64max - total); |
227 total += length; | 226 total += length; |
228 } | 227 } |
229 return total; | 228 return total; |
230 } | 229 } |
231 | 230 |
| 231 // Must be called before testing the request. |
| 232 void CreateSnapshotFromBlobData() { |
| 233 blob_data_snapshot_ = blob_data_->Build().Pass(); |
| 234 } |
| 235 |
232 protected: | 236 protected: |
233 base::ScopedTempDir temp_dir_; | 237 base::ScopedTempDir temp_dir_; |
234 base::FilePath temp_file1_; | 238 base::FilePath temp_file1_; |
235 base::FilePath temp_file2_; | 239 base::FilePath temp_file2_; |
236 base::Time temp_file_modification_time1_; | 240 base::Time temp_file_modification_time1_; |
237 base::Time temp_file_modification_time2_; | 241 base::Time temp_file_modification_time2_; |
238 GURL file_system_root_url_; | 242 GURL file_system_root_url_; |
239 GURL temp_file_system_file1_; | 243 GURL temp_file_system_file1_; |
240 GURL temp_file_system_file2_; | 244 GURL temp_file_system_file2_; |
241 base::Time temp_file_system_file_modification_time1_; | 245 base::Time temp_file_system_file_modification_time1_; |
242 base::Time temp_file_system_file_modification_time2_; | 246 base::Time temp_file_system_file_modification_time2_; |
243 | 247 |
244 base::MessageLoopForIO message_loop_; | 248 base::MessageLoopForIO message_loop_; |
245 scoped_refptr<storage::FileSystemContext> file_system_context_; | 249 scoped_refptr<storage::FileSystemContext> file_system_context_; |
246 scoped_refptr<BlobData> blob_data_; | 250 scoped_ptr<BlobDataBuilder> blob_data_; |
| 251 scoped_ptr<BlobDataSnapshot> blob_data_snapshot_; |
247 net::URLRequestJobFactoryImpl url_request_job_factory_; | 252 net::URLRequestJobFactoryImpl url_request_job_factory_; |
248 net::URLRequestContext url_request_context_; | 253 net::URLRequestContext url_request_context_; |
249 MockURLRequestDelegate url_request_delegate_; | 254 MockURLRequestDelegate url_request_delegate_; |
250 scoped_ptr<net::URLRequest> request_; | 255 scoped_ptr<net::URLRequest> request_; |
251 | 256 |
252 int expected_status_code_; | 257 int expected_status_code_; |
253 std::string expected_response_; | 258 std::string expected_response_; |
254 }; | 259 }; |
255 | 260 |
256 TEST_F(BlobURLRequestJobTest, TestGetSimpleDataRequest) { | 261 TEST_F(BlobURLRequestJobTest, TestGetSimpleDataRequest) { |
257 blob_data_->AppendData(kTestData1); | 262 blob_data_->AppendData(kTestData1); |
| 263 CreateSnapshotFromBlobData(); |
258 TestSuccessNonrangeRequest(kTestData1, arraysize(kTestData1) - 1); | 264 TestSuccessNonrangeRequest(kTestData1, arraysize(kTestData1) - 1); |
259 } | 265 } |
260 | 266 |
261 TEST_F(BlobURLRequestJobTest, TestGetSimpleFileRequest) { | 267 TEST_F(BlobURLRequestJobTest, TestGetSimpleFileRequest) { |
262 blob_data_->AppendFile(temp_file1_, 0, kuint64max, base::Time()); | 268 blob_data_->AppendFile(temp_file1_, 0, kuint64max, base::Time()); |
| 269 CreateSnapshotFromBlobData(); |
263 TestSuccessNonrangeRequest(kTestFileData1, arraysize(kTestFileData1) - 1); | 270 TestSuccessNonrangeRequest(kTestFileData1, arraysize(kTestFileData1) - 1); |
264 } | 271 } |
265 | 272 |
266 TEST_F(BlobURLRequestJobTest, TestGetLargeFileRequest) { | 273 TEST_F(BlobURLRequestJobTest, TestGetLargeFileRequest) { |
267 base::FilePath large_temp_file = | 274 base::FilePath large_temp_file = |
268 temp_dir_.path().AppendASCII("LargeBlob.dat"); | 275 temp_dir_.path().AppendASCII("LargeBlob.dat"); |
269 std::string large_data; | 276 std::string large_data; |
270 large_data.reserve(kBufferSize * 5); | 277 large_data.reserve(kBufferSize * 5); |
271 for (int i = 0; i < kBufferSize * 5; ++i) | 278 for (int i = 0; i < kBufferSize * 5; ++i) |
272 large_data.append(1, static_cast<char>(i % 256)); | 279 large_data.append(1, static_cast<char>(i % 256)); |
273 ASSERT_EQ(static_cast<int>(large_data.size()), | 280 ASSERT_EQ(static_cast<int>(large_data.size()), |
274 base::WriteFile(large_temp_file, large_data.data(), | 281 base::WriteFile(large_temp_file, large_data.data(), |
275 large_data.size())); | 282 large_data.size())); |
276 blob_data_->AppendFile(large_temp_file, 0, kuint64max, base::Time()); | 283 blob_data_->AppendFile(large_temp_file, 0, kuint64max, base::Time()); |
| 284 CreateSnapshotFromBlobData(); |
277 TestSuccessNonrangeRequest(large_data, large_data.size()); | 285 TestSuccessNonrangeRequest(large_data, large_data.size()); |
278 } | 286 } |
279 | 287 |
280 TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileRequest) { | 288 TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileRequest) { |
281 base::FilePath non_existent_file = | 289 base::FilePath non_existent_file = |
282 temp_file1_.InsertBeforeExtension(FILE_PATH_LITERAL("-na")); | 290 temp_file1_.InsertBeforeExtension(FILE_PATH_LITERAL("-na")); |
283 blob_data_->AppendFile(non_existent_file, 0, kuint64max, base::Time()); | 291 blob_data_->AppendFile(non_existent_file, 0, kuint64max, base::Time()); |
| 292 CreateSnapshotFromBlobData(); |
284 TestErrorRequest(404); | 293 TestErrorRequest(404); |
285 } | 294 } |
286 | 295 |
287 TEST_F(BlobURLRequestJobTest, TestGetChangedFileRequest) { | 296 TEST_F(BlobURLRequestJobTest, TestGetChangedFileRequest) { |
288 base::Time old_time = | 297 base::Time old_time = |
289 temp_file_modification_time1_ - base::TimeDelta::FromSeconds(10); | 298 temp_file_modification_time1_ - base::TimeDelta::FromSeconds(10); |
290 blob_data_->AppendFile(temp_file1_, 0, 3, old_time); | 299 blob_data_->AppendFile(temp_file1_, 0, 3, old_time); |
| 300 CreateSnapshotFromBlobData(); |
291 TestErrorRequest(404); | 301 TestErrorRequest(404); |
292 } | 302 } |
293 | 303 |
294 TEST_F(BlobURLRequestJobTest, TestGetSlicedFileRequest) { | 304 TEST_F(BlobURLRequestJobTest, TestGetSlicedFileRequest) { |
295 blob_data_->AppendFile(temp_file1_, 2, 4, temp_file_modification_time1_); | 305 blob_data_->AppendFile(temp_file1_, 2, 4, temp_file_modification_time1_); |
| 306 CreateSnapshotFromBlobData(); |
296 std::string result(kTestFileData1 + 2, 4); | 307 std::string result(kTestFileData1 + 2, 4); |
297 TestSuccessNonrangeRequest(result, 4); | 308 TestSuccessNonrangeRequest(result, 4); |
298 } | 309 } |
299 | 310 |
300 TEST_F(BlobURLRequestJobTest, TestGetSimpleFileSystemFileRequest) { | 311 TEST_F(BlobURLRequestJobTest, TestGetSimpleFileSystemFileRequest) { |
301 SetUpFileSystem(); | 312 SetUpFileSystem(); |
302 blob_data_->AppendFileSystemFile(temp_file_system_file1_, 0, kuint64max, | 313 blob_data_->AppendFileSystemFile(temp_file_system_file1_, 0, kuint64max, |
303 base::Time()); | 314 base::Time()); |
| 315 CreateSnapshotFromBlobData(); |
304 TestSuccessNonrangeRequest(kTestFileSystemFileData1, | 316 TestSuccessNonrangeRequest(kTestFileSystemFileData1, |
305 arraysize(kTestFileSystemFileData1) - 1); | 317 arraysize(kTestFileSystemFileData1) - 1); |
306 } | 318 } |
307 | 319 |
308 TEST_F(BlobURLRequestJobTest, TestGetLargeFileSystemFileRequest) { | 320 TEST_F(BlobURLRequestJobTest, TestGetLargeFileSystemFileRequest) { |
309 SetUpFileSystem(); | 321 SetUpFileSystem(); |
310 std::string large_data; | 322 std::string large_data; |
311 large_data.reserve(kBufferSize * 5); | 323 large_data.reserve(kBufferSize * 5); |
312 for (int i = 0; i < kBufferSize * 5; ++i) | 324 for (int i = 0; i < kBufferSize * 5; ++i) |
313 large_data.append(1, static_cast<char>(i % 256)); | 325 large_data.append(1, static_cast<char>(i % 256)); |
314 | 326 |
315 const char kFilename[] = "LargeBlob.dat"; | 327 const char kFilename[] = "LargeBlob.dat"; |
316 WriteFileSystemFile(kFilename, large_data.data(), large_data.size(), NULL); | 328 WriteFileSystemFile(kFilename, large_data.data(), large_data.size(), NULL); |
317 | 329 |
318 blob_data_->AppendFileSystemFile(GetFileSystemURL(kFilename), 0, kuint64max, | 330 blob_data_->AppendFileSystemFile(GetFileSystemURL(kFilename), 0, kuint64max, |
319 base::Time()); | 331 base::Time()); |
| 332 CreateSnapshotFromBlobData(); |
320 TestSuccessNonrangeRequest(large_data, large_data.size()); | 333 TestSuccessNonrangeRequest(large_data, large_data.size()); |
321 } | 334 } |
322 | 335 |
323 TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileSystemFileRequest) { | 336 TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileSystemFileRequest) { |
324 SetUpFileSystem(); | 337 SetUpFileSystem(); |
325 GURL non_existent_file = GetFileSystemURL("non-existent.dat"); | 338 GURL non_existent_file = GetFileSystemURL("non-existent.dat"); |
326 blob_data_->AppendFileSystemFile(non_existent_file, 0, kuint64max, | 339 blob_data_->AppendFileSystemFile(non_existent_file, 0, kuint64max, |
327 base::Time()); | 340 base::Time()); |
| 341 CreateSnapshotFromBlobData(); |
328 TestErrorRequest(404); | 342 TestErrorRequest(404); |
329 } | 343 } |
330 | 344 |
331 TEST_F(BlobURLRequestJobTest, TestGetChangedFileSystemFileRequest) { | 345 TEST_F(BlobURLRequestJobTest, TestGetChangedFileSystemFileRequest) { |
332 SetUpFileSystem(); | 346 SetUpFileSystem(); |
333 base::Time old_time = | 347 base::Time old_time = |
334 temp_file_system_file_modification_time1_ - | 348 temp_file_system_file_modification_time1_ - |
335 base::TimeDelta::FromSeconds(10); | 349 base::TimeDelta::FromSeconds(10); |
336 blob_data_->AppendFileSystemFile(temp_file_system_file1_, 0, 3, old_time); | 350 blob_data_->AppendFileSystemFile(temp_file_system_file1_, 0, 3, old_time); |
| 351 CreateSnapshotFromBlobData(); |
337 TestErrorRequest(404); | 352 TestErrorRequest(404); |
338 } | 353 } |
339 | 354 |
340 TEST_F(BlobURLRequestJobTest, TestGetSlicedFileSystemFileRequest) { | 355 TEST_F(BlobURLRequestJobTest, TestGetSlicedFileSystemFileRequest) { |
341 SetUpFileSystem(); | 356 SetUpFileSystem(); |
342 blob_data_->AppendFileSystemFile(temp_file_system_file1_, 2, 4, | 357 blob_data_->AppendFileSystemFile(temp_file_system_file1_, 2, 4, |
343 temp_file_system_file_modification_time1_); | 358 temp_file_system_file_modification_time1_); |
| 359 CreateSnapshotFromBlobData(); |
344 std::string result(kTestFileSystemFileData1 + 2, 4); | 360 std::string result(kTestFileSystemFileData1 + 2, 4); |
345 TestSuccessNonrangeRequest(result, 4); | 361 TestSuccessNonrangeRequest(result, 4); |
346 } | 362 } |
347 | 363 |
348 TEST_F(BlobURLRequestJobTest, TestGetComplicatedDataAndFileRequest) { | 364 TEST_F(BlobURLRequestJobTest, TestGetComplicatedDataAndFileRequest) { |
349 SetUpFileSystem(); | 365 SetUpFileSystem(); |
350 std::string result; | 366 std::string result; |
351 BuildComplicatedData(&result); | 367 BuildComplicatedData(&result); |
| 368 CreateSnapshotFromBlobData(); |
352 TestSuccessNonrangeRequest(result, GetTotalBlobLength()); | 369 TestSuccessNonrangeRequest(result, GetTotalBlobLength()); |
353 } | 370 } |
354 | 371 |
355 TEST_F(BlobURLRequestJobTest, TestGetRangeRequest1) { | 372 TEST_F(BlobURLRequestJobTest, TestGetRangeRequest1) { |
356 SetUpFileSystem(); | 373 SetUpFileSystem(); |
357 std::string result; | 374 std::string result; |
358 BuildComplicatedData(&result); | 375 BuildComplicatedData(&result); |
| 376 CreateSnapshotFromBlobData(); |
359 net::HttpRequestHeaders extra_headers; | 377 net::HttpRequestHeaders extra_headers; |
360 extra_headers.SetHeader(net::HttpRequestHeaders::kRange, | 378 extra_headers.SetHeader(net::HttpRequestHeaders::kRange, |
361 net::HttpByteRange::Bounded(5, 10).GetHeaderValue()); | 379 net::HttpByteRange::Bounded(5, 10).GetHeaderValue()); |
362 expected_status_code_ = 206; | 380 expected_status_code_ = 206; |
363 expected_response_ = result.substr(5, 10 - 5 + 1); | 381 expected_response_ = result.substr(5, 10 - 5 + 1); |
364 TestRequest("GET", extra_headers); | 382 TestRequest("GET", extra_headers); |
365 | 383 |
366 EXPECT_EQ(6, request_->response_headers()->GetContentLength()); | 384 EXPECT_EQ(6, request_->response_headers()->GetContentLength()); |
367 | 385 |
368 int64 first = 0, last = 0, length = 0; | 386 int64 first = 0, last = 0, length = 0; |
369 EXPECT_TRUE( | 387 EXPECT_TRUE( |
370 request_->response_headers()->GetContentRange(&first, &last, &length)); | 388 request_->response_headers()->GetContentRange(&first, &last, &length)); |
371 EXPECT_EQ(5, first); | 389 EXPECT_EQ(5, first); |
372 EXPECT_EQ(10, last); | 390 EXPECT_EQ(10, last); |
373 EXPECT_EQ(GetTotalBlobLength(), length); | 391 EXPECT_EQ(GetTotalBlobLength(), length); |
374 } | 392 } |
375 | 393 |
376 TEST_F(BlobURLRequestJobTest, TestGetRangeRequest2) { | 394 TEST_F(BlobURLRequestJobTest, TestGetRangeRequest2) { |
377 SetUpFileSystem(); | 395 SetUpFileSystem(); |
378 std::string result; | 396 std::string result; |
379 BuildComplicatedData(&result); | 397 BuildComplicatedData(&result); |
| 398 CreateSnapshotFromBlobData(); |
380 net::HttpRequestHeaders extra_headers; | 399 net::HttpRequestHeaders extra_headers; |
381 extra_headers.SetHeader(net::HttpRequestHeaders::kRange, | 400 extra_headers.SetHeader(net::HttpRequestHeaders::kRange, |
382 net::HttpByteRange::Suffix(10).GetHeaderValue()); | 401 net::HttpByteRange::Suffix(10).GetHeaderValue()); |
383 expected_status_code_ = 206; | 402 expected_status_code_ = 206; |
384 expected_response_ = result.substr(result.length() - 10); | 403 expected_response_ = result.substr(result.length() - 10); |
385 TestRequest("GET", extra_headers); | 404 TestRequest("GET", extra_headers); |
386 | 405 |
387 EXPECT_EQ(10, request_->response_headers()->GetContentLength()); | 406 EXPECT_EQ(10, request_->response_headers()->GetContentLength()); |
388 | 407 |
389 int64 total = GetTotalBlobLength(); | 408 int64 total = GetTotalBlobLength(); |
390 int64 first = 0, last = 0, length = 0; | 409 int64 first = 0, last = 0, length = 0; |
391 EXPECT_TRUE( | 410 EXPECT_TRUE( |
392 request_->response_headers()->GetContentRange(&first, &last, &length)); | 411 request_->response_headers()->GetContentRange(&first, &last, &length)); |
393 EXPECT_EQ(total - 10, first); | 412 EXPECT_EQ(total - 10, first); |
394 EXPECT_EQ(total - 1, last); | 413 EXPECT_EQ(total - 1, last); |
395 EXPECT_EQ(total, length); | 414 EXPECT_EQ(total, length); |
396 } | 415 } |
397 | 416 |
398 TEST_F(BlobURLRequestJobTest, TestExtraHeaders) { | 417 TEST_F(BlobURLRequestJobTest, TestExtraHeaders) { |
399 blob_data_->set_content_type(kTestContentType); | 418 blob_data_->set_content_type(kTestContentType); |
400 blob_data_->set_content_disposition(kTestContentDisposition); | 419 blob_data_->set_content_disposition(kTestContentDisposition); |
401 blob_data_->AppendData(kTestData1); | 420 blob_data_->AppendData(kTestData1); |
| 421 CreateSnapshotFromBlobData(); |
402 expected_status_code_ = 200; | 422 expected_status_code_ = 200; |
403 expected_response_ = kTestData1; | 423 expected_response_ = kTestData1; |
404 TestRequest("GET", net::HttpRequestHeaders()); | 424 TestRequest("GET", net::HttpRequestHeaders()); |
405 | 425 |
406 std::string content_type; | 426 std::string content_type; |
407 EXPECT_TRUE(request_->response_headers()->GetMimeType(&content_type)); | 427 EXPECT_TRUE(request_->response_headers()->GetMimeType(&content_type)); |
408 EXPECT_EQ(kTestContentType, content_type); | 428 EXPECT_EQ(kTestContentType, content_type); |
409 void* iter = NULL; | 429 void* iter = NULL; |
410 std::string content_disposition; | 430 std::string content_disposition; |
411 EXPECT_TRUE(request_->response_headers()->EnumerateHeader( | 431 EXPECT_TRUE(request_->response_headers()->EnumerateHeader( |
412 &iter, "Content-Disposition", &content_disposition)); | 432 &iter, "Content-Disposition", &content_disposition)); |
413 EXPECT_EQ(kTestContentDisposition, content_disposition); | 433 EXPECT_EQ(kTestContentDisposition, content_disposition); |
414 } | 434 } |
415 | 435 |
416 } // namespace content | 436 } // namespace content |
OLD | NEW |