Remove inline small resource transfer experiment

content/browser/loader/resource_dispatcher_host_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/pickle.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
-#include "base/test/scoped_feature_list.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/download/download_manager_impl.h"
 #include "content/browser/download/download_resource_handler.h"
 #include "content/browser/frame_host/navigation_request_info.h"
 #include "content/browser/loader/detachable_resource_handler.h"
 #include "content/browser/loader/downloaded_temp_file_impl.h"
 #include "content/browser/loader/navigation_resource_throttle.h"
 #include "content/browser/loader/navigation_url_loader.h"
@@ skipping 12 matching lines @@
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/resource_throttle.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/public/common/child_process_host.h"
-#include "content/public/common/content_features.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/resource_response.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_renderer_host.h"
 #include "content/test/test_content_browser_client.h"
 #include "content/test/test_navigation_url_loader_delegate.h"
 #include "net/base/chunked_upload_data_stream.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/load_flags.h"
@@ skipping 69 matching lines @@
 }  // namespace
 
 static int RequestIDForMessage(const IPC::Message& msg) {
   int request_id = -1;
   switch (msg.type()) {
     case ResourceMsg_UploadProgress::ID:
     case ResourceMsg_ReceivedResponse::ID:
     case ResourceMsg_ReceivedRedirect::ID:
     case ResourceMsg_SetDataBuffer::ID:
     case ResourceMsg_DataReceived::ID:
-    case ResourceMsg_InlinedDataChunkReceived::ID:
     case ResourceMsg_DataDownloaded::ID:
     case ResourceMsg_RequestComplete::ID: {
       bool result = base::PickleIterator(msg).ReadInt(&request_id);
       DCHECK(result);
       break;
     }
   }
   return request_id;
 }
 
@@ skipping 665 matching lines @@
 
   int resource_request_redirect_count() {
     return resource_request_redirect_count_;
   }
 
  private:
   int resource_request_redirect_count_;
   int resource_response_start_count_;
 };
 
-enum class TestConfig {
-  kDefault,
-  kOptimizeIPCForSmallResourceEnabled,
-};
-
 void CheckRequestCompleteErrorCode(const IPC::Message& message,
                                    int expected_error_code) {
   // Verify the expected error code was received.
   int request_id;
   int error_code;
 
   ASSERT_EQ(ResourceMsg_RequestComplete::ID, message.type());
 
   base::PickleIterator iter(message);
   ASSERT_TRUE(IPC::ReadParam(&message, &iter, &request_id));
   ASSERT_TRUE(IPC::ReadParam(&message, &iter, &error_code));
   ASSERT_EQ(expected_error_code, error_code);
 }
 
-class ResourceDispatcherHostTest : public testing::TestWithParam<TestConfig>,
-                                   public IPC::Sender {
+class ResourceDispatcherHostTest : public testing::Test, public IPC::Sender {
  public:
   typedef ResourceDispatcherHostImpl::LoadInfo LoadInfo;
   typedef ResourceDispatcherHostImpl::LoadInfoList LoadInfoList;
   typedef ResourceDispatcherHostImpl::LoadInfoMap LoadInfoMap;
 
   ResourceDispatcherHostTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
         host_(base::Bind(&DownloadResourceHandler::Create)),
         use_test_ssl_certificate_(false),
         send_data_received_acks_(false),
@@ skipping 44 matching lines @@
     scoped_refptr<SiteInstance> site_instance =
         SiteInstance::Create(browser_context_.get());
     web_contents_.reset(
         WebContents::Create(WebContents::CreateParams(browser_context_.get())));
     web_contents_observer_.reset(
         new TestWebContentsObserver(web_contents_.get()));
     web_contents_filter_ = new TestFilterSpecifyingChild(
         browser_context_->GetResourceContext(),
         web_contents_->GetRenderProcessHost()->GetID());
     child_ids_.insert(web_contents_->GetRenderProcessHost()->GetID());
-
-    switch (GetParam()) {
-      case TestConfig::kDefault:
-        break;
-      case TestConfig::kOptimizeIPCForSmallResourceEnabled: {
-        scoped_feature_list_.InitAndEnableFeature(
-            features::kOptimizeLoadingIPCForSmallResources);
-        ASSERT_TRUE(base::FeatureList::IsEnabled(
-            features::kOptimizeLoadingIPCForSmallResources));
-        break;
-      }
-    }
   }
 
   void TearDown() override {
     web_contents_filter_->OnChannelClosing();
     web_contents_observer_.reset();
     web_contents_.reset();
 
     EXPECT_TRUE(URLRequestTestDelayedStartJob::DelayedStartQueueEmpty());
     URLRequestTestDelayedStartJob::ClearQueue();
 
@@ skipping 209 matching lines @@
   ResourceIPCAccumulator accum_;
   std::string response_headers_;
   std::string response_data_;
   bool use_test_ssl_certificate_;
   std::string scheme_;
   bool send_data_received_acks_;
   std::set<int> child_ids_;
   std::unique_ptr<base::RunLoop> wait_for_request_complete_loop_;
   RenderViewHostTestEnabler render_view_host_test_enabler_;
   bool auto_advance_;
-  base::test::ScopedFeatureList scoped_feature_list_;
 };
 
 void ResourceDispatcherHostTest::MakeTestRequest(int render_view_id,
                                                  int request_id,
                                                  const GURL& url) {
   MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
                                   url, RESOURCE_TYPE_SUB_RESOURCE);
 }
 
 void ResourceDispatcherHostTest::MakeTestRequestWithRenderFrame(
@@ skipping 88 matching lines @@
 void ResourceDispatcherHostTest::CompleteStartRequest(
     ResourceMessageFilter* filter,
     int request_id) {
   GlobalRequestID gid(filter->child_id(), request_id);
   net::URLRequest* req = host_.GetURLRequest(gid);
   EXPECT_TRUE(req);
   if (req)
     URLRequestTestDelayedStartJob::CompleteStart(req);
 }
 
-testing::AssertionResult ExtractInlinedChunkData(
-    const IPC::Message& message,
-    std::string* leading_chunk_data) {
-  base::PickleIterator iter(message);
-  int request_id;
-  if (!IPC::ReadParam(&message, &iter, &request_id))
-    return testing::AssertionFailure() << "Could not read request_id";
-
-  std::vector<char> data;
-  if (!IPC::ReadParam(&message, &iter, &data))
-    return testing::AssertionFailure() << "Could not read data";
-  leading_chunk_data->assign(data.begin(), data.end());
-
-  return testing::AssertionSuccess();
-}
-
 testing::AssertionResult ExtractDataOffsetAndLength(const IPC::Message& message,
                                                     int* data_offset,
                                                     int* data_length) {
   base::PickleIterator iter(message);
   int request_id;
   if (!IPC::ReadParam(&message, &iter, &request_id))
     return testing::AssertionFailure() << "Could not read request_id";
   if (!IPC::ReadParam(&message, &iter, data_offset))
     return testing::AssertionFailure() << "Could not read data_offset";
   if (!IPC::ReadParam(&message, &iter, data_length))
     return testing::AssertionFailure() << "Could not read data_length";
   return testing::AssertionSuccess();
 }
 
-void CheckSuccessfulRequestWithErrorCodeForInlinedCase(
-    const std::vector<IPC::Message>& messages,
-    const std::string& reference_data,
-    int expected_error) {
-  // A successful request on the inlined case will have received 3 messages:
-  //     ReceivedResponse         (indicates headers received)
-  //     InlinedDataChunkReceived (contains the content)
-  //     RequestComplete          (request is done)
-
-  ASSERT_EQ(3U, messages.size());
-
-  // The first messages should be received response
-  ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, messages[0].type());
-  ASSERT_EQ(ResourceMsg_InlinedDataChunkReceived::ID, messages[1].type());
-
-  std::string leading_chunk_data;
-  ASSERT_TRUE(ExtractInlinedChunkData(messages[1], &leading_chunk_data));
-  ASSERT_EQ(reference_data, leading_chunk_data);
-  CheckRequestCompleteErrorCode(messages[2], expected_error);
-}
-
 void CheckSuccessfulRequestWithErrorCode(
     const std::vector<IPC::Message>& messages,
     const std::string& reference_data,
     int expected_error) {
   ASSERT_LT(2U, messages.size());
-  if (base::FeatureList::IsEnabled(
-          features::kOptimizeLoadingIPCForSmallResources) &&
-      messages[1].type() == ResourceMsg_InlinedDataChunkReceived::ID) {
-    CheckSuccessfulRequestWithErrorCodeForInlinedCase(
-        messages, reference_data, expected_error);
-    return;
-  }
 
   // A successful request will have received 4 messages:
   //     ReceivedResponse    (indicates headers received)
   //     SetDataBuffer       (contains shared memory handle)
   //     DataReceived        (data offset and length into shared memory)
   //     RequestComplete     (request is done)
   //
   // This function verifies that we received 4 messages and that they are
   // appropriate. It allows for an error code other than net::OK if the request
   // should successfully receive data and then abort, e.g., on cancel.
@@ skipping 56 matching lines @@
   size_t failure_index = messages.size() - 1;
 
   if (messages.size() == 2) {
     EXPECT_EQ(ResourceMsg_ReceivedResponse::ID, messages[0].type());
   }
 
   CheckRequestCompleteErrorCode(messages[failure_index], expected_error);
 }
 
 // Tests whether many messages get dispatched properly.
-TEST_P(ResourceDispatcherHostTest, TestMany) {
+TEST_F(ResourceDispatcherHostTest, TestMany) {
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1());
   MakeTestRequest(0, 2, net::URLRequestTestJob::test_url_2());
   MakeTestRequest(0, 3, net::URLRequestTestJob::test_url_3());
   MakeTestRequestWithResourceType(filter_.get(), 0, 4,
                                   net::URLRequestTestJob::test_url_4(),
                                   RESOURCE_TYPE_PREFETCH);  // detachable type
   MakeTestRequest(0, 5, net::URLRequestTestJob::test_url_redirect_to_url_2());
 
   // Finish the redirection
   ResourceHostMsg_FollowRedirect redirect_msg(5);
@@ skipping 12 matching lines @@
 
   CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_1());
   CheckSuccessfulRequest(msgs[1], net::URLRequestTestJob::test_data_2());
   CheckSuccessfulRequest(msgs[2], net::URLRequestTestJob::test_data_3());
   CheckSuccessfulRequest(msgs[3], net::URLRequestTestJob::test_data_4());
   CheckSuccessfulRedirect(msgs[4], net::URLRequestTestJob::test_data_2());
 }
 
 // Tests whether messages get canceled properly. We issue four requests,
 // cancel two of them, and make sure that each sent the proper notifications.
-TEST_P(ResourceDispatcherHostTest, Cancel) {
+TEST_F(ResourceDispatcherHostTest, Cancel) {
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1());
   MakeTestRequest(0, 2, net::URLRequestTestJob::test_url_2());
   MakeTestRequest(0, 3, net::URLRequestTestJob::test_url_3());
 
   MakeTestRequestWithResourceType(filter_.get(), 0, 4,
                                   net::URLRequestTestJob::test_url_4(),
                                   RESOURCE_TYPE_PREFETCH);  // detachable type
 
   CancelRequest(2);
 
@@ skipping 32 matching lines @@
   ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[3][0].type());
   CheckRequestCompleteErrorCode(msgs[3][1], net::ERR_ABORTED);
 
   // However, request 4 should have actually gone to completion. (Only request 2
   // was canceled.)
   EXPECT_EQ(4, network_delegate()->completed_requests());
   EXPECT_EQ(1, network_delegate()->canceled_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
 }
 
-TEST_P(ResourceDispatcherHostTest, DownloadToNetworkCache) {
+TEST_F(ResourceDispatcherHostTest, DownloadToNetworkCache) {
   // Normal request.
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_2());
 
   // Cache-only request.
   ResourceRequest request_to_cache = CreateResourceRequest(
       "GET", RESOURCE_TYPE_IMAGE, net::URLRequestTestJob::test_url_3());
   request_to_cache.download_to_network_cache_only = true;
   ResourceHostMsg_RequestResource msg_to_cache(0, 2, request_to_cache);
   OnMessageReceived(msg_to_cache, filter_.get());
 
@@ skipping 27 matching lines @@
   CheckRequestCompleteErrorCode(msgs[1][0], net::ERR_ABORTED);
 
   // However, all requests should have actually gone to completion.
   EXPECT_EQ(2, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->canceled_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
 }
 
 // Shows that detachable requests will timeout if the request takes too long to
 // complete.
-TEST_P(ResourceDispatcherHostTest, DetachedResourceTimesOut) {
+TEST_F(ResourceDispatcherHostTest, DetachedResourceTimesOut) {
   MakeTestRequestWithResourceType(filter_.get(), 0, 1,
                                   net::URLRequestTestJob::test_url_2(),
                                   RESOURCE_TYPE_PREFETCH);  // detachable type
   GlobalRequestID global_request_id(filter_->child_id(), 1);
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(
       host_.GetURLRequest(global_request_id));
   ASSERT_TRUE(info->detachable_handler());
   info->detachable_handler()->set_cancel_delay(
       base::TimeDelta::FromMilliseconds(200));
   base::RunLoop().RunUntilIdle();
@@ skipping 19 matching lines @@
               base::MessageLoop::current(), &base::MessageLoop::QuitWhenIdle);
   base::RunLoop().Run();
 
   // The prefetch should be cancelled by now.
   EXPECT_EQ(0, host_.pending_requests());
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(1, network_delegate()->canceled_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
 }
 
-TEST_P(ResourceDispatcherHostTest, SyncLoadSuccess) {
+TEST_F(ResourceDispatcherHostTest, SyncLoadSuccess) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_XHR, net::URLRequestTestJob::test_url_1());
   request.priority = net::MAXIMUM_PRIORITY;
 
   // Successful sync load.
   std::tuple<SyncLoadResult> result;
   ResourceHostMsg_SyncLoad sync_load_msg(0, 1, request, &std::get<0>(result));
   OnMessageReceived(sync_load_msg, filter_.get());
   base::RunLoop().RunUntilIdle();
 
   const IPC::Message* reply = accum_.GetReply(sync_load_msg);
   ASSERT_TRUE(reply);
 
   ASSERT_TRUE(ResourceHostMsg_SyncLoad::ReadReplyParam(reply, &result));
   EXPECT_EQ(net::OK, std::get<0>(result).error_code);
 }
 
-TEST_P(ResourceDispatcherHostTest, SyncLoadError) {
+TEST_F(ResourceDispatcherHostTest, SyncLoadError) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_XHR, net::URLRequestTestJob::test_url_error());
   request.priority = net::MAXIMUM_PRIORITY;
 
   // Failued sync load.
   std::tuple<SyncLoadResult> result;
   ResourceHostMsg_SyncLoad sync_load_msg(0, 1, request, &std::get<0>(result));
   OnMessageReceived(sync_load_msg, filter_.get());
   base::RunLoop().RunUntilIdle();
 
   const IPC::Message* reply = accum_.GetReply(sync_load_msg);
   ASSERT_TRUE(reply);
 
   ASSERT_TRUE(ResourceHostMsg_SyncLoad::ReadReplyParam(reply, &result));
   EXPECT_EQ(net::ERR_INVALID_URL, std::get<0>(result).error_code);
 }
 
-TEST_P(ResourceDispatcherHostTest, SyncLoadCancel) {
+TEST_F(ResourceDispatcherHostTest, SyncLoadCancel) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_XHR, net::URLRequestTestJob::test_url_1());
   request.priority = net::MAXIMUM_PRIORITY;
 
   // Cancelled sync load.
   SyncLoadResult result;
   ResourceHostMsg_SyncLoad sync_load_msg(0, 1, request, &result);
 
   OnMessageReceived(sync_load_msg, filter_.get());
   host_.CancelRequestsForProcess(filter_->child_id());
   base::RunLoop().RunUntilIdle();
 
   const IPC::Message* reply = accum_.GetReply(sync_load_msg);
   ASSERT_TRUE(reply);
   ASSERT_TRUE(reply->is_reply_error());
 }
 
 // If the filter has disappeared then detachable resources should continue to
 // load.
-TEST_P(ResourceDispatcherHostTest, DeletedFilterDetached) {
+TEST_F(ResourceDispatcherHostTest, DeletedFilterDetached) {
   // test_url_1's data is available synchronously, so use 2 and 3.
   ResourceRequest request_prefetch = CreateResourceRequest(
       "GET", RESOURCE_TYPE_PREFETCH, net::URLRequestTestJob::test_url_2());
   ResourceRequest request_ping = CreateResourceRequest(
       "GET", RESOURCE_TYPE_PING, net::URLRequestTestJob::test_url_3());
 
   ResourceHostMsg_RequestResource msg_prefetch(0, 1, request_prefetch);
   OnMessageReceived(msg_prefetch, filter_.get());
   ResourceHostMsg_RequestResource msg_ping(0, 2, request_ping);
   OnMessageReceived(msg_ping, filter_.get());
@@ skipping 29 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, host_.pending_requests());
   EXPECT_EQ(2, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->canceled_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
 }
 
 // If the filter has disappeared (original process dies) then detachable
 // resources should continue to load, even when redirected.
-TEST_P(ResourceDispatcherHostTest, DeletedFilterDetachedRedirect) {
+TEST_F(ResourceDispatcherHostTest, DeletedFilterDetachedRedirect) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_PREFETCH,
       net::URLRequestTestJob::test_url_redirect_to_url_2());
 
   ResourceHostMsg_RequestResource msg(0, 1, request);
   OnMessageReceived(msg, filter_.get());
 
   // Remove the filter before processing the request by simulating channel
   // closure.
   GlobalRequestID global_request_id(filter_->child_id(), 1);
@@ skipping 25 matching lines @@
   // Finish up the request.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, host_.pending_requests());
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->canceled_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
 }
 
-TEST_P(ResourceDispatcherHostTest, CancelWhileStartIsDeferred) {
+TEST_F(ResourceDispatcherHostTest, CancelWhileStartIsDeferred) {
   bool was_deleted = false;
 
   // Arrange to have requests deferred before starting.
   TestResourceDispatcherHostDelegate delegate;
   delegate.set_flags(DEFER_STARTING_REQUEST);
   delegate.set_url_request_user_data(new TestUserData(&was_deleted));
   host_.SetDelegate(&delegate);
 
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1());
   // We cancel from the renderer because all non-renderer cancels delete
   // the request synchronously.
   RendererCancelRequest(1);
 
   // Our TestResourceThrottle should not have been deleted yet.  This is to
   // ensure that destruction of the URLRequest happens asynchronously to
   // calling CancelRequest.
   EXPECT_FALSE(was_deleted);
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(was_deleted);
 }
 
-TEST_P(ResourceDispatcherHostTest, DetachWhileStartIsDeferred) {
+TEST_F(ResourceDispatcherHostTest, DetachWhileStartIsDeferred) {
   bool was_deleted = false;
 
   // Arrange to have requests deferred before starting.
   TestResourceDispatcherHostDelegate delegate;
   delegate.set_flags(DEFER_STARTING_REQUEST);
   delegate.set_url_request_user_data(new TestUserData(&was_deleted));
   host_.SetDelegate(&delegate);
 
   MakeTestRequestWithResourceType(filter_.get(), 0, 1,
                                   net::URLRequestTestJob::test_url_1(),
@@ skipping 21 matching lines @@
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(was_deleted);
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->canceled_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
 }
 
 // Tests if cancel is called in ResourceThrottle::WillStartRequest, then the
 // URLRequest will not be started.
-TEST_P(ResourceDispatcherHostTest, CancelInResourceThrottleWillStartRequest) {
+TEST_F(ResourceDispatcherHostTest, CancelInResourceThrottleWillStartRequest) {
   TestResourceDispatcherHostDelegate delegate;
   delegate.set_flags(CANCEL_BEFORE_START);
   host_.SetDelegate(&delegate);
 
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1());
 
   // flush all the pending requests
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
   base::RunLoop().RunUntilIdle();
 
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // Check that request got canceled.
   ASSERT_EQ(1U, msgs[0].size());
   CheckRequestCompleteErrorCode(msgs[0][0], net::ERR_ABORTED);
 
   // Make sure URLRequest is never started.
   EXPECT_EQ(0, job_factory_->url_request_jobs_created_count());
 }
 
-TEST_P(ResourceDispatcherHostTest, PausedStartError) {
+TEST_F(ResourceDispatcherHostTest, PausedStartError) {
   // Arrange to have requests deferred before processing response headers.
   TestResourceDispatcherHostDelegate delegate;
   delegate.set_flags(DEFER_PROCESSING_RESPONSE);
   host_.SetDelegate(&delegate);
 
   job_factory_->SetDelayedStartJobGeneration(true);
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_error());
   CompleteStartRequest(1);
 
   // flush all the pending requests
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, host_.pending_requests());
 }
 
-TEST_P(ResourceDispatcherHostTest, ThrottleAndResumeTwice) {
+TEST_F(ResourceDispatcherHostTest, ThrottleAndResumeTwice) {
   // Arrange to have requests deferred before starting.
   TestResourceDispatcherHostDelegate delegate;
   delegate.set_flags(DEFER_STARTING_REQUEST);
   delegate.set_create_two_throttles(true);
   host_.SetDelegate(&delegate);
 
   // Make sure the first throttle blocked the request, and then resume.
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1());
   GenericResourceThrottle* first_throttle =
       GenericResourceThrottle::active_throttle();
@@ skipping 17 matching lines @@
 
   // Make sure the request completed successfully.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1U, msgs.size());
   CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_1());
 }
 
 
 // Tests that the delegate can cancel a request and provide a error code.
-TEST_P(ResourceDispatcherHostTest, CancelInDelegate) {
+TEST_F(ResourceDispatcherHostTest, CancelInDelegate) {
   TestResourceDispatcherHostDelegate delegate;
   delegate.set_flags(CANCEL_BEFORE_START);
   delegate.set_error_code_for_cancellation(net::ERR_ACCESS_DENIED);
   host_.SetDelegate(&delegate);
 
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1());
   // The request will get cancelled by the throttle.
 
   // flush all the pending requests
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
   base::RunLoop().RunUntilIdle();
 
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // Check the cancellation
   ASSERT_EQ(1U, msgs.size());
   ASSERT_EQ(1U, msgs[0].size());
 
   CheckRequestCompleteErrorCode(msgs[0][0], net::ERR_ACCESS_DENIED);
 }
 
 // Tests CancelRequestsForProcess
-TEST_P(ResourceDispatcherHostTest, TestProcessCancel) {
+TEST_F(ResourceDispatcherHostTest, TestProcessCancel) {
   scoped_refptr<TestFilter> test_filter = new TestFilter(
       browser_context_->GetResourceContext());
   child_ids_.insert(test_filter->child_id());
 
   // request 1 goes to the test delegate
   MakeTestRequestWithResourceType(test_filter.get(), 0, 1,
                                   net::URLRequestTestJob::test_url_1(),
                                   RESOURCE_TYPE_SUB_RESOURCE);
 
   // request 2 goes to us
@@ skipping 58 matching lines @@
   // But it completed anyway. For the network stack, no requests were canceled.
   EXPECT_EQ(4, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->canceled_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
 
   test_filter->OnChannelClosing();
 }
 
 // Tests whether the correct requests get canceled when a RenderViewHost is
 // deleted.
-TEST_P(ResourceDispatcherHostTest, CancelRequestsOnRenderFrameDeleted) {
+TEST_F(ResourceDispatcherHostTest, CancelRequestsOnRenderFrameDeleted) {
   // Requests all hang once started.  This prevents requests from being
   // destroyed due to completion.
   job_factory_->SetHangAfterStartJobGeneration(true);
   HandleScheme("http");
 
   TestResourceDispatcherHostDelegate delegate;
   host_.SetDelegate(&delegate);
   host_.OnRenderViewHostCreated(filter_->child_id(), 0);
 
   // One RenderView issues a high priority request and a low priority one. Both
@@ skipping 29 matching lines @@
   EXPECT_EQ(3, network_delegate_.created_requests());
   EXPECT_EQ(4, network_delegate_.canceled_requests());
 
   // No messages should have been sent, since none of the jobs made any
   // progress.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   EXPECT_EQ(0U, msgs.size());
 }
 
-TEST_P(ResourceDispatcherHostTest, TestProcessCancelDetachedTimesOut) {
+TEST_F(ResourceDispatcherHostTest, TestProcessCancelDetachedTimesOut) {
   MakeTestRequestWithResourceType(filter_.get(), 0, 1,
                                   net::URLRequestTestJob::test_url_4(),
                                   RESOURCE_TYPE_PREFETCH);  // detachable type
   GlobalRequestID global_request_id(filter_->child_id(), 1);
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(
       host_.GetURLRequest(global_request_id));
   ASSERT_TRUE(info->detachable_handler());
   info->detachable_handler()->set_cancel_delay(
       base::TimeDelta::FromMilliseconds(200));
   base::RunLoop().RunUntilIdle();
@@ skipping 25 matching lines @@
   ASSERT_EQ(2U, msgs[0].size());
   ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type());
   CheckRequestCompleteErrorCode(msgs[0][1], net::ERR_ABORTED);
   // And not run to completion.
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(1, network_delegate()->canceled_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
 }
 
 // Tests blocking and resuming requests.
-TEST_P(ResourceDispatcherHostTest, TestBlockingResumingRequests) {
+TEST_F(ResourceDispatcherHostTest, TestBlockingResumingRequests) {
   host_.BlockRequestsForRoute(GlobalFrameRoutingId(filter_->child_id(), 11));
   host_.BlockRequestsForRoute(GlobalFrameRoutingId(filter_->child_id(), 12));
   host_.BlockRequestsForRoute(GlobalFrameRoutingId(filter_->child_id(), 13));
 
   MakeTestRequestWithRenderFrame(0, 10, 1, net::URLRequestTestJob::test_url_1(),
                                  RESOURCE_TYPE_SUB_RESOURCE);
   MakeTestRequestWithRenderFrame(1, 11, 2, net::URLRequestTestJob::test_url_2(),
                                  RESOURCE_TYPE_SUB_RESOURCE);
   MakeTestRequestWithRenderFrame(0, 10, 3, net::URLRequestTestJob::test_url_3(),
                                  RESOURCE_TYPE_SUB_RESOURCE);
@@ skipping 47 matching lines @@
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   msgs.clear();
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(2U, msgs.size());
   CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_2());
   CheckSuccessfulRequest(msgs[1], net::URLRequestTestJob::test_data_3());
 }
 
 // Tests blocking and canceling requests.
-TEST_P(ResourceDispatcherHostTest, TestBlockingCancelingRequests) {
+TEST_F(ResourceDispatcherHostTest, TestBlockingCancelingRequests) {
   host_.BlockRequestsForRoute(GlobalFrameRoutingId(filter_->child_id(), 11));
 
   MakeTestRequestWithRenderFrame(0, 10, 1, net::URLRequestTestJob::test_url_1(),
                                  RESOURCE_TYPE_SUB_RESOURCE);
   MakeTestRequestWithRenderFrame(1, 11, 2, net::URLRequestTestJob::test_url_2(),
                                  RESOURCE_TYPE_SUB_RESOURCE);
   MakeTestRequestWithRenderFrame(0, 10, 3, net::URLRequestTestJob::test_url_3(),
                                  RESOURCE_TYPE_SUB_RESOURCE);
   MakeTestRequestWithRenderFrame(1, 11, 4, net::URLRequestTestJob::test_url_1(),
                                  RESOURCE_TYPE_SUB_RESOURCE);
@@ skipping 20 matching lines @@
       GlobalFrameRoutingId(filter_->child_id(), 11));
   KickOffRequest();
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   msgs.clear();
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(0U, msgs.size());
 }
 
 // Tests that blocked requests are canceled if their associated process dies.
-TEST_P(ResourceDispatcherHostTest, TestBlockedRequestsProcessDies) {
+TEST_F(ResourceDispatcherHostTest, TestBlockedRequestsProcessDies) {
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter();
 
   host_.BlockRequestsForRoute(
       GlobalFrameRoutingId(second_filter->child_id(), 0));
 
   MakeTestRequestWithResourceType(filter_.get(), 0, 1,
                                   net::URLRequestTestJob::test_url_1(),
                                   RESOURCE_TYPE_SUB_RESOURCE);
   MakeTestRequestWithResourceType(second_filter.get(), 0, 2,
@@ skipping 27 matching lines @@
   CheckSuccessfulRequest(msgs[1], net::URLRequestTestJob::test_data_3());
 
   EXPECT_TRUE(host_.blocked_loaders_map_.empty());
   second_filter->OnChannelClosing();
 }
 
 // Tests that blocked requests don't leak when the ResourceDispatcherHost goes
 // away.  Note that we rely on Purify for finding the leaks if any.
 // If this test turns the Purify bot red, check the ResourceDispatcherHost
 // destructor to make sure the blocked requests are deleted.
-TEST_P(ResourceDispatcherHostTest, TestBlockedRequestsDontLeak) {
+TEST_F(ResourceDispatcherHostTest, TestBlockedRequestsDontLeak) {
   // This second filter is used to emulate a second process.
   scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter();
 
   host_.BlockRequestsForRoute(GlobalFrameRoutingId(filter_->child_id(), 1));
   host_.BlockRequestsForRoute(GlobalFrameRoutingId(filter_->child_id(), 2));
   host_.BlockRequestsForRoute(
       GlobalFrameRoutingId(second_filter->child_id(), 1));
 
   MakeTestRequestWithResourceType(filter_.get(), 0, 1,
                                   net::URLRequestTestJob::test_url_1(),
@@ skipping 23 matching lines @@
   host_.CancelRequestsForProcess(filter_->child_id());
   host_.CancelRequestsForProcess(second_filter->child_id());
 
   // Flush all the pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   second_filter->OnChannelClosing();
 }
 
 // Test the private helper method "CalculateApproximateMemoryCost()".
-TEST_P(ResourceDispatcherHostTest, CalculateApproximateMemoryCost) {
+TEST_F(ResourceDispatcherHostTest, CalculateApproximateMemoryCost) {
   net::URLRequestContext context;
   std::unique_ptr<net::URLRequest> req(context.CreateRequest(
       GURL("http://www.google.com"), net::DEFAULT_PRIORITY, NULL));
   EXPECT_EQ(4425, ResourceDispatcherHostImpl::CalculateApproximateMemoryCost(
                       req.get()));
 
   // Add 9 bytes of referrer.
   req->SetReferrer("123456789");
   EXPECT_EQ(4434, ResourceDispatcherHostImpl::CalculateApproximateMemoryCost(
                       req.get()));
 
   // Add 33 bytes of upload content.
   std::string upload_content;
   upload_content.resize(33);
   std::fill(upload_content.begin(), upload_content.end(), 'x');
   std::unique_ptr<net::UploadElementReader> reader(
       new net::UploadBytesElementReader(upload_content.data(),
                                         upload_content.size()));
   req->set_upload(
       net::ElementsUploadDataStream::CreateWithReader(std::move(reader), 0));
 
   // Since the upload throttling is disabled, this has no effect on the cost.
   EXPECT_EQ(4434, ResourceDispatcherHostImpl::CalculateApproximateMemoryCost(
                       req.get()));
 }
 
 // Test that too much memory for outstanding requests for a particular
 // render_process_host_id causes requests to fail.
-TEST_P(ResourceDispatcherHostTest, TooMuchOutstandingRequestsMemory) {
+TEST_F(ResourceDispatcherHostTest, TooMuchOutstandingRequestsMemory) {
   // Expected cost of each request as measured by
   // ResourceDispatcherHost::CalculateApproximateMemoryCost().
   int kMemoryCostOfTest2Req =
       ResourceDispatcherHostImpl::kAvgBytesPerOutstandingRequest +
       net::URLRequestTestJob::test_url_2().spec().size() + sizeof("GET") - 1;
 
   // Tighten the bound on the ResourceDispatcherHost, to speed things up.
   int kMaxCostPerProcess = 440000;
   host_.set_max_outstanding_requests_cost_per_process(kMaxCostPerProcess);
 
@@ skipping 57 matching lines @@
                          net::URLRequestTestJob::test_data_2());
   CheckSuccessfulRequest(msgs[kMaxRequests + 3],
                          net::URLRequestTestJob::test_data_2());
 
   second_filter->OnChannelClosing();
 }
 
 // Test that when too many requests are outstanding for a particular
 // render_process_host_id, any subsequent request from it fails. Also verify
 // that the global limit is honored.
-TEST_P(ResourceDispatcherHostTest, TooManyOutstandingRequests) {
+TEST_F(ResourceDispatcherHostTest, TooManyOutstandingRequests) {
   // Tighten the bound on the ResourceDispatcherHost, to speed things up.
   const size_t kMaxRequestsPerProcess = 2;
   host_.set_max_num_in_flight_requests_per_process(kMaxRequestsPerProcess);
   const size_t kMaxRequests = 3;
   host_.set_max_num_in_flight_requests(kMaxRequests);
 
   // Needed to emulate additional processes.
   scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter();
   scoped_refptr<ForwardingFilter> third_filter = MakeForwardingFilter();
 
@@ skipping 45 matching lines @@
                          net::URLRequestTestJob::test_data_2());
   CheckFailedRequest(msgs[kMaxRequestsPerProcess + 2],
                      net::URLRequestTestJob::test_data_2(),
                      net::ERR_INSUFFICIENT_RESOURCES);
 
   second_filter->OnChannelClosing();
   third_filter->OnChannelClosing();
 }
 
 // Tests that we sniff the mime type for a simple request.
-TEST_P(ResourceDispatcherHostTest, MimeSniffed) {
+TEST_F(ResourceDispatcherHostTest, MimeSniffed) {
   std::string raw_headers("HTTP/1.1 200 OK\n\n");
   std::string response_data("<html><title>Test One</title></html>");
   SetResponse(raw_headers, response_data);
 
   HandleScheme("http");
   MakeTestRequest(0, 1, GURL("http:bla"));
 
   // Flush all pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   // Sorts out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1U, msgs.size());
 
   ResourceResponseHead response_head;
   GetResponseHead(msgs[0], &response_head);
   ASSERT_EQ("text/html", response_head.mime_type);
 }
 
 // Tests that we don't sniff the mime type when the server provides one.
-TEST_P(ResourceDispatcherHostTest, MimeNotSniffed) {
+TEST_F(ResourceDispatcherHostTest, MimeNotSniffed) {
   std::string raw_headers("HTTP/1.1 200 OK\n"
                           "Content-type: image/jpeg\n\n");
   std::string response_data("<html><title>Test One</title></html>");
   SetResponse(raw_headers, response_data);
 
   HandleScheme("http");
   MakeTestRequest(0, 1, GURL("http:bla"));
 
   // Flush all pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   // Sorts out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1U, msgs.size());
 
   ResourceResponseHead response_head;
   GetResponseHead(msgs[0], &response_head);
   ASSERT_EQ("image/jpeg", response_head.mime_type);
 }
 
 // Tests that we don't sniff the mime type when there is no message body.
-TEST_P(ResourceDispatcherHostTest, MimeNotSniffed2) {
+TEST_F(ResourceDispatcherHostTest, MimeNotSniffed2) {
   SetResponse("HTTP/1.1 304 Not Modified\n\n");
 
   HandleScheme("http");
   MakeTestRequest(0, 1, GURL("http:bla"));
 
   // Flush all pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   // Sorts out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1U, msgs.size());
 
   ResourceResponseHead response_head;
   GetResponseHead(msgs[0], &response_head);
   ASSERT_EQ("", response_head.mime_type);
 }
 
-TEST_P(ResourceDispatcherHostTest, MimeSniff204) {
+TEST_F(ResourceDispatcherHostTest, MimeSniff204) {
   SetResponse("HTTP/1.1 204 No Content\n\n");
 
   HandleScheme("http");
   MakeTestRequest(0, 1, GURL("http:bla"));
 
   // Flush all pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   // Sorts out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1U, msgs.size());
 
   ResourceResponseHead response_head;
   GetResponseHead(msgs[0], &response_head);
   ASSERT_EQ("text/plain", response_head.mime_type);
 }
 
-TEST_P(ResourceDispatcherHostTest, MimeSniffEmpty) {
+TEST_F(ResourceDispatcherHostTest, MimeSniffEmpty) {
   SetResponse("HTTP/1.1 200 OK\n\n");
 
   HandleScheme("http");
   MakeTestRequest(0, 1, GURL("http:bla"));
 
   // Flush all pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   // Sorts out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1U, msgs.size());
 
   ResourceResponseHead response_head;
   GetResponseHead(msgs[0], &response_head);
   ASSERT_EQ("text/plain", response_head.mime_type);
 }
 
 // Tests for crbug.com/31266 (Non-2xx + application/octet-stream).
-TEST_P(ResourceDispatcherHostTest, ForbiddenDownload) {
+TEST_F(ResourceDispatcherHostTest, ForbiddenDownload) {
   NavigationResourceThrottle::set_ui_checks_always_succeed_for_testing(true);
   std::string raw_headers("HTTP/1.1 403 Forbidden\n"
                           "Content-disposition: attachment; filename=blah\n"
                           "Content-type: application/octet-stream\n\n");
   std::string response_data("<html><title>Test One</title></html>");
   SetResponse(raw_headers, response_data);
 
   HandleScheme("http");
 
   int expected_error_code = net::ERR_INVALID_RESPONSE;
   GURL forbidden_download_url = GURL("http:bla");
 
   CompleteFailingMainResourceRequest(forbidden_download_url,
                                      expected_error_code);
 }
 
 // Test for http://crbug.com/76202 .  We don't want to destroy a
 // download request prematurely when processing a cancellation from
 // the renderer.
-TEST_P(ResourceDispatcherHostTest, IgnoreCancelForDownloads) {
+TEST_F(ResourceDispatcherHostTest, IgnoreCancelForDownloads) {
   // PlzNavigate: A request that ends up being a download is a main resource
   // request. Hence, it has been initiated by the browser and is not associated
   // with a renderer. Therefore, it cannot be canceled by a renderer IPC.
   if (IsBrowserSideNavigationEnabled()) {
     SUCCEED() << "Not applicable with --enable-browser-side-navigation.";
     return;
   }
 
   NavigationResourceThrottle::set_ui_checks_always_succeed_for_testing(true);
 
@@ skipping 31 matching lines @@
 
   // Since the request had already started processing as a download,
   // the cancellation above should have been ignored and the request
   // should still be alive.
   EXPECT_EQ(1, host_.pending_requests());
 
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
   base::RunLoop().RunUntilIdle();
 }
 
-TEST_P(ResourceDispatcherHostTest, CancelRequestsForContext) {
+TEST_F(ResourceDispatcherHostTest, CancelRequestsForContext) {
   EXPECT_EQ(0, host_.pending_requests());
   NavigationResourceThrottle::set_ui_checks_always_succeed_for_testing(true);
 
   int render_view_id = 0;
   int request_id = 1;
 
   std::string raw_headers("HTTP\n"
                           "Content-disposition: attachment; filename=foo\n\n");
   std::string response_data("01234567890123456789\x01foobar");
   // Get past sniffing metrics.
@@ skipping 70 matching lines @@
     // Cancelling by context should work.
     host_.CancelRequestsForContext(filter_->resource_context());
     EXPECT_EQ(0, host_.pending_requests());
 
     while (net::URLRequestTestJob::ProcessOnePendingMessage()) {
     }
     base::RunLoop().RunUntilIdle();
   }
 }
 
-TEST_P(ResourceDispatcherHostTest, CancelRequestsForContextDetached) {
+TEST_F(ResourceDispatcherHostTest, CancelRequestsForContextDetached) {
   EXPECT_EQ(0, host_.pending_requests());
 
   int render_view_id = 0;
   int request_id = 1;
 
   MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
                                   net::URLRequestTestJob::test_url_4(),
                                   RESOURCE_TYPE_PREFETCH);  // detachable type
 
   // Simulate a cancel coming from the renderer.
   RendererCancelRequest(request_id);
 
   // Since the request had already started processing as detachable,
   // the cancellation above should have been ignored and the request
   // should have been detached.
   EXPECT_EQ(1, host_.pending_requests());
 
   // Cancelling by other methods should also leave it detached.
   host_.CancelRequestsForProcess(render_view_id);
   EXPECT_EQ(1, host_.pending_requests());
 
   // Cancelling by context should work.
   host_.CancelRequestsForContext(filter_->resource_context());
   EXPECT_EQ(0, host_.pending_requests());
 }
 
 // Test the cancelling of requests that are being transferred to a new renderer
 // due to a redirection.
-TEST_P(ResourceDispatcherHostTest, CancelRequestsForContextTransferred) {
+TEST_F(ResourceDispatcherHostTest, CancelRequestsForContextTransferred) {
   // PlzNavigate: there are no transferred requests in PlzNavigate.
   if (IsBrowserSideNavigationEnabled())
     return;
 
   NavigationResourceThrottle::set_ui_checks_always_succeed_for_testing(true);
 
   EXPECT_EQ(0, host_.pending_requests());
 
   int request_id = 1;
 
@@ skipping 25 matching lines @@
       web_contents_->GetRenderViewHost()->GetRoutingID());
   EXPECT_EQ(1, host_.pending_requests());
 
   // Cancelling by context should work.
   host_.CancelRequestsForContext(web_contents_filter_->resource_context());
   EXPECT_EQ(0, host_.pending_requests());
 }
 
 // Test transferred navigations with text/html, which doesn't trigger any
 // content sniffing.
-TEST_P(ResourceDispatcherHostTest, TransferNavigationHtml) {
+TEST_F(ResourceDispatcherHostTest, TransferNavigationHtml) {
   if (IsBrowserSideNavigationEnabled()) {
     SUCCEED() << "Test is not applicable with browser side navigation enabled";
     return;
   }
 
   EXPECT_EQ(0, host_.pending_requests());
 
   NavigationResourceThrottle::set_ui_checks_always_succeed_for_testing(true);
   NavigationResourceThrottle::set_force_transfer_for_testing(true);
 
@@ skipping 46 matching lines @@
 
   ASSERT_EQ(2U, msgs.size());
   EXPECT_EQ(ResourceMsg_ReceivedRedirect::ID, msgs[0][0].type());
   CheckSuccessfulRequest(msgs[1], kResponseBody);
 
   second_filter->OnChannelClosing();
 }
 
 // Test transferring two navigations with text/html, to ensure the resource
 // accounting works.
-TEST_P(ResourceDispatcherHostTest, TransferTwoNavigationsHtml) {
+TEST_F(ResourceDispatcherHostTest, TransferTwoNavigationsHtml) {
   if (IsBrowserSideNavigationEnabled()) {
     SUCCEED() << "Test is not applicable with browser side navigation enabled";
     return;
   }
 
   NavigationResourceThrottle::set_force_transfer_for_testing(true);
   NavigationResourceThrottle::set_ui_checks_always_succeed_for_testing(true);
 
   EXPECT_EQ(0, host_.pending_requests());
 
@@ skipping 60 matching lines @@
 
   ASSERT_EQ(2U, msgs.size());
   CheckSuccessfulRequest(msgs[0], kResponseBody);
 
   second_filter->OnChannelClosing();
 }
 
 // Test transferred navigations with text/plain, which causes
 // MimeTypeResourceHandler to buffer the response to sniff the content before
 // the transfer occurs.
-TEST_P(ResourceDispatcherHostTest, TransferNavigationText) {
+TEST_F(ResourceDispatcherHostTest, TransferNavigationText) {
   if (IsBrowserSideNavigationEnabled()) {
     SUCCEED() << "Test is not applicable with browser side navigation enabled";
     return;
   }
 
   NavigationResourceThrottle::set_force_transfer_for_testing(true);
   NavigationResourceThrottle::set_ui_checks_always_succeed_for_testing(true);
 
   EXPECT_EQ(0, host_.pending_requests());
 
@@ skipping 47 matching lines @@
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   ASSERT_EQ(2U, msgs.size());
   EXPECT_EQ(ResourceMsg_ReceivedRedirect::ID, msgs[0][0].type());
   CheckSuccessfulRequest(msgs[1], kResponseBody);
 
   second_filter->OnChannelClosing();
 }
 
-TEST_P(ResourceDispatcherHostTest, TransferNavigationWithProcessCrash) {
+TEST_F(ResourceDispatcherHostTest, TransferNavigationWithProcessCrash) {
   if (IsBrowserSideNavigationEnabled()) {
     SUCCEED() << "Test is not applicable with browser side navigation enabled";
     return;
   }
 
   NavigationResourceThrottle::set_force_transfer_for_testing(true);
   NavigationResourceThrottle::set_ui_checks_always_succeed_for_testing(true);
 
   EXPECT_EQ(0, host_.pending_requests());
 
@@ skipping 63 matching lines @@
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   ASSERT_EQ(2U, msgs.size());
   EXPECT_EQ(ResourceMsg_ReceivedRedirect::ID, msgs[0][0].type());
   CheckSuccessfulRequest(msgs[1], kResponseBody);
 
   second_filter->OnChannelClosing();
 }
 
-TEST_P(ResourceDispatcherHostTest, TransferNavigationWithTwoRedirects) {
+TEST_F(ResourceDispatcherHostTest, TransferNavigationWithTwoRedirects) {
   if (IsBrowserSideNavigationEnabled()) {
     SUCCEED() << "Test is not applicable with browser side navigation enabled";
     return;
   }
 
   NavigationResourceThrottle::set_force_transfer_for_testing(true);
   NavigationResourceThrottle::set_ui_checks_always_succeed_for_testing(true);
 
   EXPECT_EQ(0, host_.pending_requests());
 
@@ skipping 67 matching lines @@
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   ASSERT_EQ(2U, msgs.size());
   EXPECT_EQ(ResourceMsg_ReceivedRedirect::ID, msgs[0][0].type());
   CheckSuccessfulRequest(msgs[1], kResponseBody);
 
   second_filter->OnChannelClosing();
 }
 
-TEST_P(ResourceDispatcherHostTest, UnknownURLScheme) {
+TEST_F(ResourceDispatcherHostTest, UnknownURLScheme) {
   NavigationResourceThrottle::set_ui_checks_always_succeed_for_testing(true);
   EXPECT_EQ(0, host_.pending_requests());
 
   HandleScheme("http");
 
   const GURL invalid_sheme_url = GURL("foo://bar");
   const int expected_error_code = net::ERR_UNKNOWN_URL_SCHEME;
 
   CompleteFailingMainResourceRequest(invalid_sheme_url, expected_error_code);
 }
 
-TEST_P(ResourceDispatcherHostTest, DataReceivedACKs) {
+TEST_F(ResourceDispatcherHostTest, DataReceivedACKs) {
   EXPECT_EQ(0, host_.pending_requests());
 
   SendDataReceivedACKs(true);
 
   HandleScheme("big-job");
   MakeTestRequest(0, 1, GURL("big-job:0123456789,1000000"));
 
   base::RunLoop().RunUntilIdle();
 
   // Sort all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   size_t size = msgs[0].size();
 
   EXPECT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type());
   EXPECT_EQ(ResourceMsg_SetDataBuffer::ID, msgs[0][1].type());
   for (size_t i = 2; i < size - 1; ++i)
     EXPECT_EQ(ResourceMsg_DataReceived::ID, msgs[0][i].type());
   EXPECT_EQ(ResourceMsg_RequestComplete::ID, msgs[0][size - 1].type());
 }
 
 // Request a very large detachable resource and cancel part way. Some of the
 // data should have been sent to the renderer, but not all.
-TEST_P(ResourceDispatcherHostTest, DataSentBeforeDetach) {
+TEST_F(ResourceDispatcherHostTest, DataSentBeforeDetach) {
   EXPECT_EQ(0, host_.pending_requests());
 
   int render_view_id = 0;
   int request_id = 1;
 
   std::string raw_headers("HTTP\n"
                           "Content-type: image/jpeg\n\n");
   std::string response_data("01234567890123456789\x01foobar");
 
   // Create a response larger than kMaxAllocationSize (currently 32K). Note
@@ skipping 35 matching lines @@
   EXPECT_GT(kAllocSize, data_length);
 
   // Verify the data that was received before cancellation. The request should
   // have appeared to cancel, however.
   CheckSuccessfulRequestWithErrorCode(
       msgs[0],
       std::string(response_data.begin(), response_data.begin() + data_length),
       net::ERR_ABORTED);
 }
 
-TEST_P(ResourceDispatcherHostTest, DelayedDataReceivedACKs) {
+TEST_F(ResourceDispatcherHostTest, DelayedDataReceivedACKs) {
   EXPECT_EQ(0, host_.pending_requests());
 
   HandleScheme("big-job");
   MakeTestRequest(0, 1, GURL("big-job:0123456789,1000000"));
 
   base::RunLoop().RunUntilIdle();
 
   // Sort all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
@@ skipping 28 matching lines @@
 
     base::RunLoop().RunUntilIdle();
 
     msgs.clear();
     accum_.GetClassifiedMessages(&msgs);
   }
 }
 
 // Flakyness of this test might indicate memory corruption issues with
 // for example the ResourceBuffer of AsyncResourceHandler.
-TEST_P(ResourceDispatcherHostTest, DataReceivedUnexpectedACKs) {
+TEST_F(ResourceDispatcherHostTest, DataReceivedUnexpectedACKs) {
   EXPECT_EQ(0, host_.pending_requests());
 
   HandleScheme("big-job");
   MakeTestRequest(0, 1, GURL("big-job:0123456789,1000000"));
 
   base::RunLoop().RunUntilIdle();
 
   // Sort all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
@@ skipping 32 matching lines @@
     }
 
     base::RunLoop().RunUntilIdle();
 
     msgs.clear();
     accum_.GetClassifiedMessages(&msgs);
   }
 }
 
 // Tests the dispatcher host's temporary file management.
-TEST_P(ResourceDispatcherHostTest, RegisterDownloadedTempFile) {
+TEST_F(ResourceDispatcherHostTest, RegisterDownloadedTempFile) {
   const int kRequestID = 1;
 
   // Create a temporary file.
   base::FilePath file_path;
   ASSERT_TRUE(base::CreateTemporaryFile(&file_path));
   EXPECT_TRUE(base::PathExists(file_path));
   scoped_refptr<ShareableFileReference> deletable_file =
       ShareableFileReference::GetOrCreate(
           file_path, ShareableFileReference::DELETE_ON_FINAL_RELEASE,
           BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE).get());
@@ skipping 25 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   // The file is no longer readable to the child and has been deleted.
   EXPECT_FALSE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), file_path));
   EXPECT_FALSE(base::PathExists(file_path));
 }
 
 // Tests the dispatcher host's temporary file management in the mojo-enabled
 // loading.
-TEST_P(ResourceDispatcherHostTest, RegisterDownloadedTempFileWithMojo) {
+TEST_F(ResourceDispatcherHostTest, RegisterDownloadedTempFileWithMojo) {
   const int kRequestID = 1;
 
   // Create a temporary file.
   base::FilePath file_path;
   ASSERT_TRUE(base::CreateTemporaryFile(&file_path));
   EXPECT_TRUE(base::PathExists(file_path));
   scoped_refptr<ShareableFileReference> deletable_file =
       ShareableFileReference::GetOrCreate(
           file_path, ShareableFileReference::DELETE_ON_FINAL_RELEASE,
           BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE).get());
@@ skipping 29 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   // The file is no longer readable to the child and has been deleted.
   EXPECT_FALSE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), file_path));
   EXPECT_FALSE(base::PathExists(file_path));
 }
 
 // Tests that temporary files held on behalf of child processes are released
 // when the child process dies.
-TEST_P(ResourceDispatcherHostTest, ReleaseTemporiesOnProcessExit) {
+TEST_F(ResourceDispatcherHostTest, ReleaseTemporiesOnProcessExit) {
   const int kRequestID = 1;
 
   // Create a temporary file.
   base::FilePath file_path;
   ASSERT_TRUE(base::CreateTemporaryFile(&file_path));
   scoped_refptr<ShareableFileReference> deletable_file =
       ShareableFileReference::GetOrCreate(
           file_path, ShareableFileReference::DELETE_ON_FINAL_RELEASE,
           BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE).get());
 
   // Register it for a resource request.
   host_.RegisterDownloadedTempFile(filter_->child_id(), kRequestID, file_path);
   deletable_file = NULL;
 
   // Should be readable now.
   EXPECT_TRUE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), file_path));
 
   // Let the process die.
   filter_->OnChannelClosing();
   base::RunLoop().RunUntilIdle();
 
   // The file is no longer readable to the child and has been deleted.
   EXPECT_FALSE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), file_path));
   EXPECT_FALSE(base::PathExists(file_path));
 }
 
-TEST_P(ResourceDispatcherHostTest, DownloadToFile) {
+TEST_F(ResourceDispatcherHostTest, DownloadToFile) {
   // Make a request which downloads to file.
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_SUB_RESOURCE, net::URLRequestTestJob::test_url_1());
   request.download_to_file = true;
   ResourceHostMsg_RequestResource request_msg(0, 1, request);
   OnMessageReceived(request_msg, filter_.get());
 
   // Running the message loop until idle does not work because
   // RedirectToFileResourceHandler posts things to base::WorkerPool. Instead,
   // wait for the ResourceMsg_RequestComplete to go out. Then run the event loop
@@ skipping 56 matching lines @@
 
   EXPECT_FALSE(base::PathExists(response_head.download_file_path));
   EXPECT_FALSE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), response_head.download_file_path));
 }
 
 WebContents* WebContentsBinder(WebContents* rv) { return rv; }
 
 // Tests GetLoadInfoForAllRoutes when there are 3 requests from the same
 // RenderView.  The second one is farthest along.
-TEST_P(ResourceDispatcherHostTest, LoadInfo) {
+TEST_F(ResourceDispatcherHostTest, LoadInfo) {
   std::unique_ptr<LoadInfoList> infos(new LoadInfoList);
   LoadInfo info;
   WebContents* wc1 = reinterpret_cast<WebContents*>(0x1);
   info.web_contents_getter = base::Bind(WebContentsBinder, wc1);
   info.load_state = net::LoadStateWithParam(net::LOAD_STATE_SENDING_REQUEST,
                                             base::string16());
   info.url = GURL("test://1/");
   info.upload_position = 0;
   info.upload_size = 0;
   infos->push_back(info);
@@ skipping 12 matching lines @@
   ASSERT_TRUE(load_info_map->find(wc1) != load_info_map->end());
   EXPECT_EQ(GURL("test://2/"), (*load_info_map)[wc1].url);
   EXPECT_EQ(net::LOAD_STATE_READING_RESPONSE,
             (*load_info_map)[wc1].load_state.state);
   EXPECT_EQ(0u, (*load_info_map)[wc1].upload_position);
   EXPECT_EQ(0u, (*load_info_map)[wc1].upload_size);
 }
 
 // Tests GetLoadInfoForAllRoutes when there are 2 requests with the same
 // priority.  The first one (Which will have the lowest ID) should be returned.
-TEST_P(ResourceDispatcherHostTest, LoadInfoSamePriority) {
+TEST_F(ResourceDispatcherHostTest, LoadInfoSamePriority) {
   std::unique_ptr<LoadInfoList> infos(new LoadInfoList);
   LoadInfo info;
   WebContents* wc1 = reinterpret_cast<WebContents*>(0x1);
   info.web_contents_getter = base::Bind(WebContentsBinder, wc1);
   info.load_state = net::LoadStateWithParam(net::LOAD_STATE_IDLE,
                                             base::string16());
   info.url = GURL("test://1/");
   info.upload_position = 0;
   info.upload_size = 0;
   infos->push_back(info);
 
   info.url = GURL("test://2/");
   infos->push_back(info);
 
   std::unique_ptr<LoadInfoMap> load_info_map =
       ResourceDispatcherHostImpl::PickMoreInterestingLoadInfos(
           std::move(infos));
   ASSERT_EQ(1u, load_info_map->size());
   ASSERT_TRUE(load_info_map->find(wc1) != load_info_map->end());
   EXPECT_EQ(GURL("test://1/"), (*load_info_map)[wc1].url);
   EXPECT_EQ(net::LOAD_STATE_IDLE, (*load_info_map)[wc1].load_state.state);
   EXPECT_EQ(0u, (*load_info_map)[wc1].upload_position);
   EXPECT_EQ(0u, (*load_info_map)[wc1].upload_size);
 }
 
 // Tests GetLoadInfoForAllRoutes when a request is uploading a body.
-TEST_P(ResourceDispatcherHostTest, LoadInfoUploadProgress) {
+TEST_F(ResourceDispatcherHostTest, LoadInfoUploadProgress) {
   std::unique_ptr<LoadInfoList> infos(new LoadInfoList);
   LoadInfo info;
   WebContents* wc1 = reinterpret_cast<WebContents*>(0x1);
   info.web_contents_getter = base::Bind(WebContentsBinder, wc1);
   info.load_state = net::LoadStateWithParam(net::LOAD_STATE_READING_RESPONSE,
                                             base::string16());
   info.url = GURL("test://1/");
   info.upload_position = 0;
   info.upload_size = 0;
   infos->push_back(info);
@@ skipping 29 matching lines @@
   EXPECT_EQ(GURL("test://2/"), (*load_info_map)[wc1].url);
   EXPECT_EQ(net::LOAD_STATE_SENDING_REQUEST,
             (*load_info_map)[wc1].load_state.state);
   EXPECT_EQ(50u, (*load_info_map)[wc1].upload_position);
   EXPECT_EQ(100u, (*load_info_map)[wc1].upload_size);
 }
 
 // Tests GetLoadInfoForAllRoutes when there are 4 requests from 2 different
 // RenderViews.  Also tests the case where the first / last requests are the
 // most interesting ones.
-TEST_P(ResourceDispatcherHostTest, LoadInfoTwoRenderViews) {
+TEST_F(ResourceDispatcherHostTest, LoadInfoTwoRenderViews) {
   std::unique_ptr<LoadInfoList> infos(new LoadInfoList);
   LoadInfo info;
   WebContents* wc1 = reinterpret_cast<WebContents*>(0x1);
   info.web_contents_getter = base::Bind(WebContentsBinder, wc1);
   info.load_state = net::LoadStateWithParam(net::LOAD_STATE_CONNECTING,
                                             base::string16());
   info.url = GURL("test://1/");
   info.upload_position = 0;
   info.upload_size = 0;
   infos->push_back(info);
@@ skipping 30 matching lines @@
   ASSERT_TRUE(load_info_map->find(wc2) != load_info_map->end());
   EXPECT_EQ(GURL("test://4/"), (*load_info_map)[wc2].url);
   EXPECT_EQ(net::LOAD_STATE_CONNECTING,
             (*load_info_map)[wc2].load_state.state);
   EXPECT_EQ(0u, (*load_info_map)[wc2].upload_position);
   EXPECT_EQ(0u, (*load_info_map)[wc2].upload_size);
 }
 
 // Confirm that resource response started notifications are correctly
 // transmitted to the WebContents.
-TEST_P(ResourceDispatcherHostTest, TransferResponseStarted) {
+TEST_F(ResourceDispatcherHostTest, TransferResponseStarted) {
   int initial_count = web_contents_observer_->resource_response_start_count();
 
   MakeWebContentsAssociatedTestRequest(1, net::URLRequestTestJob::test_url_1());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(initial_count + 1,
             web_contents_observer_->resource_response_start_count());
 }
 
 // Confirm that request redirected notifications are correctly
 // transmitted to the WebContents.
-TEST_P(ResourceDispatcherHostTest, TransferRequestRedirected) {
+TEST_F(ResourceDispatcherHostTest, TransferRequestRedirected) {
   int initial_count = web_contents_observer_->resource_request_redirect_count();
 
   MakeWebContentsAssociatedTestRequest(
       1, net::URLRequestTestJob::test_url_redirect_to_url_2());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(initial_count + 1,
             web_contents_observer_->resource_request_redirect_count());
 }
 
 // Confirm that DidChangePriority messages are respected.
-TEST_P(ResourceDispatcherHostTest, DidChangePriority) {
+TEST_F(ResourceDispatcherHostTest, DidChangePriority) {
   // ResourceScheduler only throttles http and https requests.
   HandleScheme("http");
 
   // Needed to enable scheduling for this child.
   host_.OnRenderViewHostCreated(filter_->child_id(),  // child_id
                                 0);                   // route_id
 
   // Prevent any of these requests from completing.
   job_factory_->SetDelayedCompleteJobGeneration(true);
   SetResponse("HTTP/1.1 200 OK\n\n", "<title>Dummy body</title>");
@@ skipping 16 matching lines @@
 
   EXPECT_EQ(3, job_factory_->url_request_jobs_created_count());
 
   // Cleanup.
   host_.OnRenderViewHostDeleted(filter_->child_id(),  // child_id
                                 0);                   // route_id
 }
 
 // Confirm that resource response started notifications for downloads are not
 // transmitted to the WebContents.
-TEST_P(ResourceDispatcherHostTest, TransferResponseStartedDownload) {
+TEST_F(ResourceDispatcherHostTest, TransferResponseStartedDownload) {
   int initial_count(web_contents_observer_->resource_response_start_count());
 
   MakeWebContentsAssociatedDownloadRequest(
       1, net::URLRequestTestJob::test_url_1());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(initial_count,
             web_contents_observer_->resource_response_start_count());
 }
 
 // Confirm that request redirected notifications for downloads are not
 // transmitted to the WebContents.
-TEST_P(ResourceDispatcherHostTest, TransferRequestRedirectedDownload) {
+TEST_F(ResourceDispatcherHostTest, TransferRequestRedirectedDownload) {
   int initial_count(web_contents_observer_->resource_request_redirect_count());
 
   MakeWebContentsAssociatedDownloadRequest(
       1, net::URLRequestTestJob::test_url_redirect_to_url_2());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(initial_count,
             web_contents_observer_->resource_request_redirect_count());
 }
 
 // Tests that a ResourceThrottle that needs to process the response before any
 // part of the body is read can do so.
-TEST_P(ResourceDispatcherHostTest, ThrottleMustProcessResponseBeforeRead) {
+TEST_F(ResourceDispatcherHostTest, ThrottleMustProcessResponseBeforeRead) {
   // Ensure all jobs will check that no read operation is called.
   job_factory_->SetMustNotReadJobGeneration(true);
   HandleScheme("http");
 
   // Create a ResourceThrottle that must process the response before any part of
   // the body is read. This throttle will also cancel the request in
   // WillProcessResponse.
   TestResourceDispatcherHostDelegate delegate;
   int throttle_flags = CANCEL_PROCESSING_RESPONSE | MUST_NOT_CACHE_BODY;
   delegate.set_flags(throttle_flags);
@@ skipping 24 matching lines @@
                          const SyncLoadResult* result) {
   *called = true;
   *was_null = !result;
 
   if (result)
     *result_out = *result;
 }
 
 } // namespace
 
-TEST_P(ResourceDispatcherHostTest, SyncLoadWithMojoSuccess) {
+TEST_F(ResourceDispatcherHostTest, SyncLoadWithMojoSuccess) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_XHR, net::URLRequestTestJob::test_url_1());
   request.priority = net::MAXIMUM_PRIORITY;
 
   bool called = false;
   bool was_null = false;
   SyncLoadResult result;
   host_.OnSyncLoadWithMojo(
       GetResourceRequesterInfo(filter_.get()), 0, 1, request,
       base::Bind(&StoreSyncLoadResult, &called, &was_null, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
   EXPECT_FALSE(was_null);
   EXPECT_EQ(net::OK, result.error_code);
 }
 
-TEST_P(ResourceDispatcherHostTest, SyncLoadWithMojoError) {
+TEST_F(ResourceDispatcherHostTest, SyncLoadWithMojoError) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_XHR, net::URLRequestTestJob::test_url_error());
   request.priority = net::MAXIMUM_PRIORITY;
 
   bool called = false;
   bool was_null = false;
   SyncLoadResult result;
   host_.OnSyncLoadWithMojo(
       GetResourceRequesterInfo(filter_.get()), 0, 1, request,
       base::Bind(&StoreSyncLoadResult, &called, &was_null, &result));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
   EXPECT_FALSE(was_null);
   EXPECT_EQ(net::ERR_INVALID_URL, result.error_code);
 }
 
-TEST_P(ResourceDispatcherHostTest, SyncLoadWithMojoCancel) {
+TEST_F(ResourceDispatcherHostTest, SyncLoadWithMojoCancel) {
   ResourceRequest request = CreateResourceRequest(
       "GET", RESOURCE_TYPE_XHR, net::URLRequestTestJob::test_url_error());
   request.priority = net::MAXIMUM_PRIORITY;
 
   bool called = false;
   bool was_null = false;
   SyncLoadResult result;
   host_.OnSyncLoadWithMojo(
       GetResourceRequesterInfo(filter_.get()), 0, 1, request,
       base::Bind(&StoreSyncLoadResult, &called, &was_null, &result));
@@ skipping 79 matching lines @@
     const GURL& location) const {
   return nullptr;
 }
 
 net::URLRequestJob* TestURLRequestJobFactory::MaybeInterceptResponse(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate) const {
   return nullptr;
 }
 
-INSTANTIATE_TEST_CASE_P(
-    ResourceDispatcherHostTests,
-    ResourceDispatcherHostTest,
-    testing::Values(TestConfig::kDefault,
-                    TestConfig::kOptimizeIPCForSmallResourceEnabled));
-
 }  // namespace content