Run BlobURLRequestJobTest tests with BlobURLRequestJob and BlobURLLoader.

content/browser/blob_storage/blob_url_unittest.cc

 // Copyright 2013 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 <stdint.h>
 
 #include <limits>
 #include <memory>
 
 #include "base/bind.h"
-#include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "content/browser/blob_storage/blob_url_loader_factory.h"
 #include "content/browser/loader/test_url_loader_client.h"
 #include "content/browser/url_loader_factory_getter.h"
-#include "content/public/common/content_switches.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "mojo/common/data_pipe_utils.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/base/test_completion_callback.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
@@ skipping 88 matching lines @@
       new net::StringIOBuffer(side_data);
   net::TestCompletionCallback callback;
   int rv = entry->WriteData(kTestDiskCacheSideStreamIndex, 0, iobuffer.get(),
                             iobuffer->size(), callback.callback(), false);
   EXPECT_EQ(static_cast<int>(side_data.size()), callback.GetResult(rv));
   return entry;
 }
 
 }  // namespace
 
-class BlobURLRequestJobTest : public testing::Test {
+class BlobURLRequestJobTest : public testing::TestWithParam<bool> {

[mmenke, 2017/06/13 19:57:09]

Should add a comment on what the param means.  I'd suggest both one here and
where you check it in TestRequest.  Alternatively, could use an enum class
instead of a bool.

[jam, 2017/06/13 23:17:20]

Added one here. I didn't want to add one where it's used because it's
documenting what the code is doing, and would be redundant from here.

  public:
   // A simple ProtocolHandler implementation to create BlobURLRequestJob.
   class MockProtocolHandler
       : public net::URLRequestJobFactory::ProtocolHandler {
    public:
     MockProtocolHandler(BlobURLRequestJobTest* test) : test_(test) {}
 
     // net::URLRequestJobFactory::ProtocolHandler override.
     net::URLRequestJob* MaybeCreateJob(
         net::URLRequest* request,
@@ skipping 120 matching lines @@
     expected_status_code_ = expected_status_code;
     expected_response_ = "";
     TestRequest("GET", net::HttpRequestHeaders());
     EXPECT_TRUE(response_metadata_.empty());
   }
 
   void TestRequest(const std::string& method,
                    const net::HttpRequestHeaders& extra_headers) {
     GURL url("blob:blah");
 
-    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-            switches::kEnableNetworkService)) {
+    if (GetParam()) {
       GetHandleFromBuilder();  // To add to StorageContext.
       const_cast<storage::BlobStorageRegistry&>(blob_context_.registry())
           .CreateUrlMapping(url, blob_data_->uuid());
       ResourceRequest request;
       request.url = url;
       request.method = method;
       if (!extra_headers.IsEmpty())
         request.headers = extra_headers.ToString();
 
       mojom::URLLoaderAssociatedPtr url_loader;
@@ skipping 125 matching lines @@
   net::TestDelegate url_request_delegate_;
   std::string response_;
   int response_error_code_;
   scoped_refptr<net::HttpResponseHeaders> response_headers_;
   std::string response_metadata_;
 
   int expected_status_code_;
   std::string expected_response_;
 };
 
-TEST_F(BlobURLRequestJobTest, TestGetSimpleDataRequest) {
+TEST_P(BlobURLRequestJobTest, TestGetSimpleDataRequest) {
   blob_data_->AppendData(kTestData1);
   TestSuccessNonrangeRequest(kTestData1, arraysize(kTestData1) - 1);
 }
 
-TEST_F(BlobURLRequestJobTest, TestGetSimpleFileRequest) {
+TEST_P(BlobURLRequestJobTest, TestGetSimpleFileRequest) {
   blob_data_->AppendFile(temp_file1_, 0, std::numeric_limits<uint64_t>::max(),
                          base::Time());
   TestSuccessNonrangeRequest(kTestFileData1, arraysize(kTestFileData1) - 1);
 }
 
-TEST_F(BlobURLRequestJobTest, TestGetLargeFileRequest) {
+TEST_P(BlobURLRequestJobTest, TestGetLargeFileRequest) {
   base::FilePath large_temp_file =
       temp_dir_.GetPath().AppendASCII("LargeBlob.dat");
   std::string large_data;
   large_data.reserve(kBufferSize * 5);
   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()),
       base::WriteFile(large_temp_file, large_data.data(), large_data.size()));
   blob_data_->AppendFile(large_temp_file, 0,
                          std::numeric_limits<uint64_t>::max(), base::Time());
   TestSuccessNonrangeRequest(large_data, large_data.size());
 }
 
-TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileRequest) {
+TEST_P(BlobURLRequestJobTest, TestGetNonExistentFileRequest) {
   base::FilePath non_existent_file =
       temp_file1_.InsertBeforeExtension(FILE_PATH_LITERAL("-na"));
   blob_data_->AppendFile(non_existent_file, 0,
                          std::numeric_limits<uint64_t>::max(), base::Time());
   TestErrorRequest(404);
 }
 
-TEST_F(BlobURLRequestJobTest, TestGetChangedFileRequest) {
+TEST_P(BlobURLRequestJobTest, TestGetChangedFileRequest) {
   base::Time old_time =
       temp_file_modification_time1_ - base::TimeDelta::FromSeconds(10);
   blob_data_->AppendFile(temp_file1_, 0, 3, old_time);
   TestErrorRequest(404);
 }
 
-TEST_F(BlobURLRequestJobTest, TestGetSlicedFileRequest) {
+TEST_P(BlobURLRequestJobTest, TestGetSlicedFileRequest) {
   blob_data_->AppendFile(temp_file1_, 2, 4, temp_file_modification_time1_);
   std::string result(kTestFileData1 + 2, 4);
   TestSuccessNonrangeRequest(result, 4);
 }
 
-TEST_F(BlobURLRequestJobTest, TestGetSimpleFileSystemFileRequest) {
+TEST_P(BlobURLRequestJobTest, TestGetSimpleFileSystemFileRequest) {
   SetUpFileSystem();
   blob_data_->AppendFileSystemFile(temp_file_system_file1_, 0,
                                    std::numeric_limits<uint64_t>::max(),
                                    base::Time());
   TestSuccessNonrangeRequest(kTestFileSystemFileData1,
                              arraysize(kTestFileSystemFileData1) - 1);
 }
 
-TEST_F(BlobURLRequestJobTest, TestGetLargeFileSystemFileRequest) {
+TEST_P(BlobURLRequestJobTest, TestGetLargeFileSystemFileRequest) {
   SetUpFileSystem();
   std::string large_data;
   large_data.reserve(kBufferSize * 5);
   for (int i = 0; i < kBufferSize * 5; ++i)
     large_data.append(1, static_cast<char>(i % 256));
 
   const char kFilename[] = "LargeBlob.dat";
   WriteFileSystemFile(kFilename, large_data.data(), large_data.size(), NULL);
 
   blob_data_->AppendFileSystemFile(GetFileSystemURL(kFilename), 0,
                                    std::numeric_limits<uint64_t>::max(),
                                    base::Time());
   TestSuccessNonrangeRequest(large_data, large_data.size());
 }
 
-TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileSystemFileRequest) {
+TEST_P(BlobURLRequestJobTest, TestGetNonExistentFileSystemFileRequest) {
   SetUpFileSystem();
   GURL non_existent_file = GetFileSystemURL("non-existent.dat");
   blob_data_->AppendFileSystemFile(
       non_existent_file, 0, std::numeric_limits<uint64_t>::max(), base::Time());
   TestErrorRequest(404);
 }
 
-TEST_F(BlobURLRequestJobTest, TestGetInvalidFileSystemFileRequest) {
+TEST_P(BlobURLRequestJobTest, TestGetInvalidFileSystemFileRequest) {
   SetUpFileSystem();
   GURL invalid_file;
   blob_data_->AppendFileSystemFile(
       invalid_file, 0, std::numeric_limits<uint64_t>::max(), base::Time());
   TestErrorRequest(500);
 }
 
-TEST_F(BlobURLRequestJobTest, TestGetChangedFileSystemFileRequest) {
+TEST_P(BlobURLRequestJobTest, TestGetChangedFileSystemFileRequest) {
   SetUpFileSystem();
   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(404);
 }
 
-TEST_F(BlobURLRequestJobTest, TestGetSlicedFileSystemFileRequest) {
+TEST_P(BlobURLRequestJobTest, TestGetSlicedFileSystemFileRequest) {
   SetUpFileSystem();
   blob_data_->AppendFileSystemFile(temp_file_system_file1_, 2, 4,
                                    temp_file_system_file_modification_time1_);
   std::string result(kTestFileSystemFileData1 + 2, 4);
   TestSuccessNonrangeRequest(result, 4);
 }
 
-TEST_F(BlobURLRequestJobTest, TestGetSimpleDiskCacheRequest) {
+TEST_P(BlobURLRequestJobTest, TestGetSimpleDiskCacheRequest) {
   blob_data_->AppendDiskCacheEntry(new EmptyDataHandle(),
                                    disk_cache_entry_.get(),
                                    kTestDiskCacheStreamIndex);
   TestSuccessNonrangeRequest(kTestDiskCacheData1,
                              arraysize(kTestDiskCacheData1) - 1);
 }
 
-TEST_F(BlobURLRequestJobTest, TestGetComplicatedDataFileAndDiskCacheRequest) {
+TEST_P(BlobURLRequestJobTest, TestGetComplicatedDataFileAndDiskCacheRequest) {
   SetUpFileSystem();
   std::string result;
   BuildComplicatedData(&result);
   TestSuccessNonrangeRequest(result, GetTotalBlobLength());
 }
 
-TEST_F(BlobURLRequestJobTest, TestGetRangeRequest1) {
+TEST_P(BlobURLRequestJobTest, TestGetRangeRequest1) {
   SetUpFileSystem();
   std::string result;
   BuildComplicatedData(&result);
   net::HttpRequestHeaders extra_headers;
   extra_headers.SetHeader(net::HttpRequestHeaders::kRange,
                           net::HttpByteRange::Bounded(5, 10).GetHeaderValue());
   expected_status_code_ = 206;
   expected_response_ = result.substr(5, 10 - 5 + 1);
   TestRequest("GET", extra_headers);
 
   EXPECT_EQ(6, response_headers_->GetContentLength());
   EXPECT_TRUE(response_metadata_.empty());
 
   int64_t first = 0, last = 0, length = 0;
   EXPECT_TRUE(response_headers_->GetContentRangeFor206(&first, &last, &length));
   EXPECT_EQ(5, first);
   EXPECT_EQ(10, last);
   EXPECT_EQ(GetTotalBlobLength(), length);
 }
 
-TEST_F(BlobURLRequestJobTest, TestGetRangeRequest2) {
+TEST_P(BlobURLRequestJobTest, TestGetRangeRequest2) {
   SetUpFileSystem();
   std::string result;
   BuildComplicatedData(&result);
   net::HttpRequestHeaders extra_headers;
   extra_headers.SetHeader(net::HttpRequestHeaders::kRange,
                           net::HttpByteRange::Suffix(10).GetHeaderValue());
   expected_status_code_ = 206;
   expected_response_ = result.substr(result.length() - 10);
   TestRequest("GET", extra_headers);
 
   EXPECT_EQ(10, response_headers_->GetContentLength());
   EXPECT_TRUE(response_metadata_.empty());
 
   int64_t total = GetTotalBlobLength();
   int64_t first = 0, last = 0, length = 0;
   EXPECT_TRUE(response_headers_->GetContentRangeFor206(&first, &last, &length));
   EXPECT_EQ(total - 10, first);
   EXPECT_EQ(total - 1, last);
   EXPECT_EQ(total, length);
 }
 
-TEST_F(BlobURLRequestJobTest, TestGetRangeRequest3) {
+TEST_P(BlobURLRequestJobTest, TestGetRangeRequest3) {
   SetUpFileSystem();
   std::string result;
   BuildComplicatedData(&result);
   net::HttpRequestHeaders extra_headers;
   extra_headers.SetHeader(net::HttpRequestHeaders::kRange,
                           net::HttpByteRange::Bounded(0, 2).GetHeaderValue());
   expected_status_code_ = 206;
   expected_response_ = result.substr(0, 3);
   TestRequest("GET", extra_headers);
 
   EXPECT_EQ(3, response_headers_->GetContentLength());
   EXPECT_TRUE(response_metadata_.empty());
 
   int64_t first = 0, last = 0, length = 0;
   EXPECT_TRUE(response_headers_->GetContentRangeFor206(&first, &last, &length));
   EXPECT_EQ(0, first);
   EXPECT_EQ(2, last);
   EXPECT_EQ(GetTotalBlobLength(), length);
 }
 
-TEST_F(BlobURLRequestJobTest, TestExtraHeaders) {
+TEST_P(BlobURLRequestJobTest, TestExtraHeaders) {
   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());
 
   std::string content_type;
   EXPECT_TRUE(response_headers_->GetMimeType(&content_type));
   EXPECT_EQ(kTestContentType, content_type);
   EXPECT_TRUE(response_metadata_.empty());
   size_t iter = 0;
   std::string content_disposition;
   EXPECT_TRUE(response_headers_->EnumerateHeader(&iter, "Content-Disposition",
                                                  &content_disposition));
   EXPECT_EQ(kTestContentDisposition, content_disposition);
 }
 
-TEST_F(BlobURLRequestJobTest, TestSideData) {
+TEST_P(BlobURLRequestJobTest, TestSideData) {
   disk_cache::ScopedEntryPtr disk_cache_entry_with_side_data =
       CreateDiskCacheEntryWithSideData(disk_cache_backend_.get(),
                                        kTestDiskCacheKey2, kTestDiskCacheData2,
                                        kTestDiskCacheSideData);
   blob_data_->AppendDiskCacheEntryWithSideData(
       new EmptyDataHandle(), disk_cache_entry_with_side_data.get(),
       kTestDiskCacheStreamIndex, kTestDiskCacheSideStreamIndex);
   expected_status_code_ = 200;
   expected_response_ = kTestDiskCacheData2;
   TestRequest("GET", net::HttpRequestHeaders());
   EXPECT_EQ(static_cast<int>(arraysize(kTestDiskCacheData2) - 1),
             response_headers_->GetContentLength());
 
   EXPECT_EQ(std::string(kTestDiskCacheSideData), response_metadata_);
 }
 
-TEST_F(BlobURLRequestJobTest, TestZeroSizeSideData) {
+TEST_P(BlobURLRequestJobTest, TestZeroSizeSideData) {
   disk_cache::ScopedEntryPtr disk_cache_entry_with_side_data =
       CreateDiskCacheEntryWithSideData(disk_cache_backend_.get(),
                                        kTestDiskCacheKey2, kTestDiskCacheData2,
                                        "");
   blob_data_->AppendDiskCacheEntryWithSideData(
       new EmptyDataHandle(), disk_cache_entry_with_side_data.get(),
       kTestDiskCacheStreamIndex, kTestDiskCacheSideStreamIndex);
   expected_status_code_ = 200;
   expected_response_ = kTestDiskCacheData2;
   TestRequest("GET", net::HttpRequestHeaders());
   EXPECT_EQ(static_cast<int>(arraysize(kTestDiskCacheData2) - 1),
             response_headers_->GetContentLength());
 
   EXPECT_TRUE(response_metadata_.empty());
 }
 
-TEST_F(BlobURLRequestJobTest, BrokenBlob) {
+TEST_P(BlobURLRequestJobTest, BrokenBlob) {
   blob_handle_ = blob_context_.AddBrokenBlob(
       "uuid", "", "", storage::BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS);
   TestErrorRequest(500);
 }
 
+INSTANTIATE_TEST_CASE_P(BlobURLRequestJobTest,
+                        BlobURLRequestJobTest,
+                        ::testing::Bool());
+
 }  // namespace content