webkit_blob: Clean up BlobURLRequestJobTest

Introduce MockProtocolHandler to stop using static variable to create jobs.
Reorder variables to destruct them in the right order.
Stop using c_str().

BUG=162728
TEST=content_unittests --gtest_filter="BlobURLRequestJobTest.*"


Review URL: https://chromiumcodereview.appspot.com/11414224

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@170187 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 87 insertions, 102 deletions

diff --git a/webkit/blob/blob_url_request_job_unittest.cc b/webkit/blob/blob_url_request_job_unittest.cc
index a9b2241..f5a6024 100644
--- a/webkit/blob/blob_url_request_job_unittest.cc
+++ b/webkit/blob/blob_url_request_job_unittest.cc
@@ -15,6 +15,7 @@
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_job_factory_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/blob/blob_data.h"
 #include "webkit/blob/blob_url_request_job.h"
@@ -110,8 +111,30 @@ class BlobURLRequestJobTest : public testing::Test {
     std::string response_data_;
   };
 
+  // A simple ProtocolHandler implementation to create BlobURLRequestJob.
+  class MockProtocolHandler :
+      public net::URLRequestJobFactory::ProtocolHandler {
+   public:
+    MockProtocolHandler(BlobURLRequestJobTest* test) : test_(test) {}
+
+    // net::URLRequestJobFactory::ProtocolHandler override.
+    virtual net::URLRequestJob* MaybeCreateJob(
+        net::URLRequest* request,
+        net::NetworkDelegate* network_delegate) const OVERRIDE {
+      return new BlobURLRequestJob(request,
+                                   network_delegate,
+                                   test_->blob_data_,
+                                   test_->file_system_context_,
+                                   base::MessageLoopProxy::current());
+    }
+
+   private:
+    BlobURLRequestJobTest* test_;
+  };
+
   BlobURLRequestJobTest()
       : message_loop_(MessageLoop::TYPE_IO),
+        blob_data_(new BlobData()),
         expected_status_code_(0) {
   }
 
@@ -134,22 +157,12 @@ class BlobURLRequestJobTest : public testing::Test {
     file_util::GetFileInfo(temp_file2_, &file_info2);
     temp_file_modification_time2_ = file_info2.last_modified;
 
-    net::URLRequest::Deprecated::RegisterProtocolFactory(
-        "blob", &BlobURLRequestJobFactory);
+    url_request_job_factory_.SetProtocolHandler("blob",
+                                                new MockProtocolHandler(this));
+    url_request_context_.set_job_factory(&url_request_job_factory_);
   }
 
   void TearDown() {
-    DCHECK(!blob_url_request_job_);
-    net::URLRequest::Deprecated::RegisterProtocolFactory("blob", NULL);
-  }
-
-  static net::URLRequestJob* BlobURLRequestJobFactory(
-      net::URLRequest* request,
-      net::NetworkDelegate* network_delegate,
-      const std::string& scheme) {
-    BlobURLRequestJob* temp = blob_url_request_job_;
-    blob_url_request_job_ = NULL;
-    return temp;
   }
 
   void SetUpFileSystem() {
@@ -174,12 +187,12 @@ class BlobURLRequestJobTest : public testing::Test {
     const char kFilename1[] = "FileSystemFile1.dat";
     temp_file_system_file1_ = GetFileSystemURL(kFilename1);
     WriteFileSystemFile(kFilename1, kTestFileSystemFileData1,
-                        arraysize(kTestFileSystemFileData1),
+                        arraysize(kTestFileSystemFileData1) - 1,
                         &temp_file_system_file_modification_time1_);
     const char kFilename2[] = "FileSystemFile2.dat";
     temp_file_system_file2_ = GetFileSystemURL(kFilename2);
     WriteFileSystemFile(kFilename2, kTestFileSystemFileData2,
-                        arraysize(kTestFileSystemFileData2),
+                        arraysize(kTestFileSystemFileData2) - 1,
                         &temp_file_system_file_modification_time2_);
   }
 
@@ -231,36 +244,23 @@ class BlobURLRequestJobTest : public testing::Test {
     file_system_root_url_ = root;
   }
 
-  void TestSuccessRequest(BlobData* blob_data,
-                          const std::string& expected_response) {
+  void TestSuccessRequest(const std::string& expected_response) {
     expected_status_code_ = 200;
     expected_response_ = expected_response;
-    TestRequest("GET", net::HttpRequestHeaders(), blob_data);
+    TestRequest("GET", net::HttpRequestHeaders());
   }
 
-  void TestErrorRequest(BlobData* blob_data,
-                        int expected_status_code) {
+  void TestErrorRequest(int expected_status_code) {
     expected_status_code_ = expected_status_code;
     expected_response_ = "";
-    TestRequest("GET", net::HttpRequestHeaders(), blob_data);
+    TestRequest("GET", net::HttpRequestHeaders());
   }
 
   void TestRequest(const std::string& method,
-                   const net::HttpRequestHeaders& extra_headers,
-                   BlobData* blob_data) {
-    MockURLRequestDelegate url_request_delegate;
-
-    request_.reset(empty_context_.CreateRequest(
-        GURL("blob:blah"), &url_request_delegate));
+                   const net::HttpRequestHeaders& extra_headers) {
+    request_.reset(url_request_context_.CreateRequest(
+        GURL("blob:blah"), &url_request_delegate_));
     request_->set_method(method);
-    blob_url_request_job_ = new BlobURLRequestJob(
-        request_.get(),
-        empty_context_.network_delegate(),
-        blob_data,
-        file_system_context_,
-        base::MessageLoopProxy::current());
-
-    // Start the request.
     if (!extra_headers.IsEmpty())
       request_->SetExtraRequestHeaders(extra_headers);
     request_->Start();
@@ -271,27 +271,24 @@ class BlobURLRequestJobTest : public testing::Test {
     EXPECT_TRUE(request_->status().is_success());
     EXPECT_EQ(expected_status_code_,
               request_->response_headers()->response_code());
-    EXPECT_STREQ(expected_response_.c_str(),
-                 url_request_delegate.response_data().c_str());
+    EXPECT_EQ(expected_response_, url_request_delegate_.response_data());
   }
 
-  scoped_refptr<BlobData> BuildComplicatedData(std::string* expected_result) {
-    scoped_refptr<BlobData> blob_data(new BlobData());
-    blob_data->AppendData(kTestData1 + 1, 2);
-    blob_data->AppendFile(temp_file1_, 2, 3, temp_file_modification_time1_);
-    blob_data->AppendFileSystemFile(temp_file_system_file1_, 3, 4,
-                                    temp_file_system_file_modification_time1_);
-    blob_data->AppendData(kTestData2 + 4, 5);
-    blob_data->AppendFile(temp_file2_, 5, 6, temp_file_modification_time2_);
-    blob_data->AppendFileSystemFile(temp_file_system_file2_, 6, 7,
-                                    temp_file_system_file_modification_time2_);
+  void BuildComplicatedData(std::string* expected_result) {
+    blob_data_->AppendData(kTestData1 + 1, 2);
+    blob_data_->AppendFile(temp_file1_, 2, 3, temp_file_modification_time1_);
+    blob_data_->AppendFileSystemFile(temp_file_system_file1_, 3, 4,
+                                     temp_file_system_file_modification_time1_);
+    blob_data_->AppendData(kTestData2 + 4, 5);
+    blob_data_->AppendFile(temp_file2_, 5, 6, temp_file_modification_time2_);
+    blob_data_->AppendFileSystemFile(temp_file_system_file2_, 6, 7,
+                                     temp_file_system_file_modification_time2_);
     *expected_result = std::string(kTestData1 + 1, 2);
     *expected_result += std::string(kTestFileData1 + 2, 3);
     *expected_result += std::string(kTestFileSystemFileData1 + 3, 4);
     *expected_result += std::string(kTestData2 + 4, 5);
     *expected_result += std::string(kTestFileData2 + 5, 6);
     *expected_result += std::string(kTestFileSystemFileData2 + 6, 7);
-    return blob_data;
   }
 
  protected:
@@ -305,33 +302,30 @@ class BlobURLRequestJobTest : public testing::Test {
   GURL temp_file_system_file2_;
   base::Time temp_file_system_file_modification_time1_;
   base::Time temp_file_system_file_modification_time2_;
-  MessageLoop message_loop_;
-  static BlobURLRequestJob* blob_url_request_job_;
 
-  net::URLRequestContext empty_context_;
-  scoped_ptr<net::URLRequest> request_;
+  MessageLoop message_loop_;
   scoped_refptr<fileapi::FileSystemContext> file_system_context_;
+  scoped_refptr<BlobData> blob_data_;
+  net::URLRequestJobFactoryImpl url_request_job_factory_;
+  net::URLRequestContext url_request_context_;
+  MockURLRequestDelegate url_request_delegate_;
+  scoped_ptr<net::URLRequest> request_;
+
   int expected_status_code_;
   std::string expected_response_;
 };
 
-// static
-BlobURLRequestJob* BlobURLRequestJobTest::blob_url_request_job_ = NULL;
-
 TEST_F(BlobURLRequestJobTest, TestGetSimpleDataRequest) {
-  scoped_refptr<BlobData> blob_data(new BlobData());
-  blob_data->AppendData(kTestData1);
-  TestSuccessRequest(blob_data, kTestData1);
+  blob_data_->AppendData(kTestData1);
+  TestSuccessRequest(kTestData1);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetSimpleFileRequest) {
-  scoped_refptr<BlobData> blob_data(new BlobData());
-  blob_data->AppendFile(temp_file1_, 0, -1, base::Time());
-  TestSuccessRequest(blob_data, kTestFileData1);
+  blob_data_->AppendFile(temp_file1_, 0, -1, base::Time());
+  TestSuccessRequest(kTestFileData1);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetLargeFileRequest) {
-  scoped_refptr<BlobData> blob_data(new BlobData());
   FilePath large_temp_file = temp_dir_.path().AppendASCII("LargeBlob.dat");
   std::string large_data;
   large_data.reserve(kBufferSize * 5);
@@ -340,39 +334,35 @@ TEST_F(BlobURLRequestJobTest, TestGetLargeFileRequest) {
   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);
+  blob_data_->AppendFile(large_temp_file, 0, -1, base::Time());
+  TestSuccessRequest(large_data);
 }
 
 TEST_F(BlobURLRequestJobTest, 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);
+  blob_data_->AppendFile(non_existent_file, 0, -1, base::Time());
+  TestErrorRequest(404);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetChangedFileRequest) {
-  scoped_refptr<BlobData> blob_data(new BlobData());
   base::Time old_time =
       temp_file_modification_time1_ - base::TimeDelta::FromSeconds(10);
-  blob_data->AppendFile(temp_file1_, 0, 3, old_time);
-  TestErrorRequest(blob_data, 404);
+  blob_data_->AppendFile(temp_file1_, 0, 3, old_time);
+  TestErrorRequest(404);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetSlicedFileRequest) {
-  scoped_refptr<BlobData> blob_data(new BlobData());
-  blob_data->AppendFile(temp_file1_, 2, 4, temp_file_modification_time1_);
+  blob_data_->AppendFile(temp_file1_, 2, 4, temp_file_modification_time1_);
   std::string result(kTestFileData1 + 2, 4);
-  TestSuccessRequest(blob_data, result);
+  TestSuccessRequest(result);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetSimpleFileSystemFileRequest) {
   SetUpFileSystem();
-  scoped_refptr<BlobData> blob_data(new BlobData());
-  blob_data->AppendFileSystemFile(temp_file_system_file1_, 0, -1,
+  blob_data_->AppendFileSystemFile(temp_file_system_file1_, 0, -1,
                                   base::Time());
-  TestSuccessRequest(blob_data, kTestFileSystemFileData1);
+  TestSuccessRequest(kTestFileSystemFileData1);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetLargeFileSystemFileRequest) {
@@ -385,85 +375,80 @@ TEST_F(BlobURLRequestJobTest, TestGetLargeFileSystemFileRequest) {
   const char kFilename[] = "LargeBlob.dat";
   WriteFileSystemFile(kFilename, large_data.data(), large_data.size(), NULL);
 
-  scoped_refptr<BlobData> blob_data(new BlobData());
-  blob_data->AppendFileSystemFile(GetFileSystemURL(kFilename),
-                                  0, -1, base::Time());
-  TestSuccessRequest(blob_data, large_data);
+  blob_data_->AppendFileSystemFile(GetFileSystemURL(kFilename),
+                                   0, -1, base::Time());
+  TestSuccessRequest(large_data);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileSystemFileRequest) {
   SetUpFileSystem();
   GURL non_existent_file = GetFileSystemURL("non-existent.dat");
-  scoped_refptr<BlobData> blob_data(new BlobData());
-  blob_data->AppendFileSystemFile(non_existent_file, 0, -1, base::Time());
-  TestErrorRequest(blob_data, 404);
+  blob_data_->AppendFileSystemFile(non_existent_file, 0, -1, base::Time());
+  TestErrorRequest(404);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetChangedFileSystemFileRequest) {
   SetUpFileSystem();
-  scoped_refptr<BlobData> blob_data(new BlobData());
   base::Time old_time =
       temp_file_system_file_modification_time1_ -
       base::TimeDelta::FromSeconds(10);
-  blob_data->AppendFileSystemFile(temp_file_system_file1_, 0, 3, old_time);
-  TestErrorRequest(blob_data, 404);
+  blob_data_->AppendFileSystemFile(temp_file_system_file1_, 0, 3, old_time);
+  TestErrorRequest(404);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetSlicedFileSystemFileRequest) {
   SetUpFileSystem();
-  scoped_refptr<BlobData> blob_data(new BlobData());
-  blob_data->AppendFileSystemFile(temp_file_system_file1_, 2, 4,
+  blob_data_->AppendFileSystemFile(temp_file_system_file1_, 2, 4,
                                   temp_file_system_file_modification_time1_);
   std::string result(kTestFileSystemFileData1 + 2, 4);
-  TestSuccessRequest(blob_data, result);
+  TestSuccessRequest(result);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetComplicatedDataAndFileRequest) {
   SetUpFileSystem();
   std::string result;
-  scoped_refptr<BlobData> blob_data = BuildComplicatedData(&result);
-  TestSuccessRequest(blob_data, result);
+  BuildComplicatedData(&result);
+  TestSuccessRequest(result);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetRangeRequest1) {
   SetUpFileSystem();
   std::string result;
-  scoped_refptr<BlobData> blob_data = BuildComplicatedData(&result);
+  BuildComplicatedData(&result);
   net::HttpRequestHeaders extra_headers;
   extra_headers.SetHeader(net::HttpRequestHeaders::kRange, "bytes=5-10");
   expected_status_code_ = 206;
   expected_response_ = result.substr(5, 10 - 5 + 1);
-  TestRequest("GET", extra_headers, blob_data);
+  TestRequest("GET", extra_headers);
 }
 
 TEST_F(BlobURLRequestJobTest, TestGetRangeRequest2) {
   SetUpFileSystem();
   std::string result;
-  scoped_refptr<BlobData> blob_data = BuildComplicatedData(&result);
+  BuildComplicatedData(&result);
   net::HttpRequestHeaders extra_headers;
   extra_headers.SetHeader(net::HttpRequestHeaders::kRange, "bytes=-10");
   expected_status_code_ = 206;
   expected_response_ = result.substr(result.length() - 10);
-  TestRequest("GET", extra_headers, blob_data);
+  TestRequest("GET", extra_headers);
 }
 
 TEST_F(BlobURLRequestJobTest, TestExtraHeaders) {
-  scoped_refptr<BlobData> blob_data(new BlobData());
-  blob_data->set_content_type(kTestContentType);
-  blob_data->set_content_disposition(kTestContentDisposition);
-  blob_data->AppendData(kTestData1);
+  blob_data_->set_content_type(kTestContentType);
+  blob_data_->set_content_disposition(kTestContentDisposition);
+  blob_data_->AppendData(kTestData1);
   expected_status_code_ = 200;
   expected_response_ = kTestData1;
-  TestRequest("GET", net::HttpRequestHeaders(), blob_data);
+  TestRequest("GET", net::HttpRequestHeaders());
 
   std::string content_type;
   EXPECT_TRUE(request_->response_headers()->GetMimeType(&content_type));
-  EXPECT_STREQ(content_type.c_str(), kTestContentType);
+  EXPECT_EQ(kTestContentType, content_type);
   void* iter = NULL;
   std::string content_disposition;
   EXPECT_TRUE(request_->response_headers()->EnumerateHeader(
       &iter, "Content-Disposition", &content_disposition));
-  EXPECT_STREQ(content_disposition.c_str(), kTestContentDisposition);
+  EXPECT_EQ(kTestContentDisposition, content_disposition);
 }
 
 }  // namespace webkit_blob