In BlobURLRequestJob, open files asynchronously to avoid blocking the IO thread

webkit/blob/blob_url_request_job_unittest.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stack>
 #include <utility>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
+#include "base/message_loop_proxy.h"
 #include "base/scoped_temp_dir.h"
 #include "base/task.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/synchronization/waitable_event.h"
 #include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 222 matching lines @@
     return TestRequest("GET", net::HttpRequestHeaders(), blob_data);
   }
 
   void TestRequest(const std::string& method,
                    const net::HttpRequestHeaders& extra_headers,
                    BlobData* blob_data) {
     // This test has async steps.
     request_.reset(new net::URLRequest(GURL("blob:blah"),
                                        url_request_delegate_.get()));
     request_->set_method(method);
-    blob_url_request_job_ = new BlobURLRequestJob(request_.get(),
-                                                  blob_data, NULL);
+    blob_url_request_job_ = new BlobURLRequestJob(
+        request_.get(),
+        blob_data,
+        base::MessageLoopProxy::CreateForCurrentThread());
 
     // Start the request.
     if (!extra_headers.IsEmpty())
       request_->SetExtraRequestHeaders(extra_headers);
     request_->Start();
 
     // Completion is async.
   }
 
   void VerifyResponse() {
@@ skipping 12 matching lines @@
     blob_data->AppendData(kTestData1);
     TestSuccessRequest(blob_data, kTestData1);
   }
 
   void TestGetSimpleFileRequest() {
     scoped_refptr<BlobData> blob_data(new BlobData());
     blob_data->AppendFile(temp_file1_, 0, -1, base::Time());
     TestSuccessRequest(blob_data, kTestFileData1);
   }
 
+  void TestGetLargeFileRequest() {
+    scoped_refptr<BlobData> blob_data(new BlobData());
+    FilePath large_temp_file = temp_dir_.path().AppendASCII("LargeBlob.dat");
+    std::string large_data;

[jianli, 2011/03/10 22:50:42]

Might be more efficient to call reserve to preallocate for kBufferSize * 5
capacity.

[adamk, 2011/03/10 23:06:12]

Seems slightly like overkill for a unittest, but I've added it, as it will save
a few allocations/copies. 

+    for (int i = 0; i < kBufferSize * 5; ++i)
+      large_data.append(1, static_cast<char>(i % 256));
+    ASSERT_EQ(static_cast<int>(large_data.size()),
+              file_util::WriteFile(large_temp_file, large_data.data(),
+                                   large_data.size()));
+    blob_data->AppendFile(large_temp_file, 0, -1, base::Time());
+    TestSuccessRequest(blob_data, large_data);
+  }
+
   void TestGetNonExistentFileRequest() {
     FilePath non_existent_file =
         temp_file1_.InsertBeforeExtension(FILE_PATH_LITERAL("-na"));
     scoped_refptr<BlobData> blob_data(new BlobData());
     blob_data->AppendFile(non_existent_file, 0, -1, base::Time());
     TestErrorRequest(blob_data, 404);
   }
 
   void TestGetChangedFileRequest() {
     scoped_refptr<BlobData> blob_data(new BlobData());
@@ skipping 106 matching lines @@
 BlobURLRequestJob* BlobURLRequestJobTest::blob_url_request_job_ = NULL;
 
 TEST_F(BlobURLRequestJobTest, TestGetSimpleDataRequest) {
   RunTestOnIOThread(&BlobURLRequestJobTest::TestGetSimpleDataRequest);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetSimpleFileRequest) {
   RunTestOnIOThread(&BlobURLRequestJobTest::TestGetSimpleFileRequest);
 }
 
+TEST_F(BlobURLRequestJobTest, TestGetLargeFileRequest) {
+  RunTestOnIOThread(&BlobURLRequestJobTest::TestGetLargeFileRequest);
+}
+
 TEST_F(BlobURLRequestJobTest, TestGetSlicedDataRequest) {
   RunTestOnIOThread(&BlobURLRequestJobTest::TestGetSlicedDataRequest);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetSlicedFileRequest) {
   RunTestOnIOThread(&BlobURLRequestJobTest::TestGetSlicedFileRequest);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileRequest) {
   RunTestOnIOThread(&BlobURLRequestJobTest::TestGetNonExistentFileRequest);
@@ skipping 18 matching lines @@
 
 TEST_F(BlobURLRequestJobTest, TestExtraHeaders) {
   RunTestOnIOThread(&BlobURLRequestJobTest::TestExtraHeaders);
 }
 
 }  // namespace webkit_blob
 
 // BlobURLRequestJobTest is expected to always live longer than the
 // runnable methods.  This lets us call NewRunnableMethod on its instances.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(webkit_blob::BlobURLRequestJobTest);