Remove content::RequestInfo

content/child/web_url_loader_impl_unittest.cc

 // Copyright 2014 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 "content/child/web_url_loader_impl.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/default_tick_clock.h"
 #include "base/time/time.h"
 #include "content/child/request_extra_data.h"
-#include "content/child/request_info.h"
 #include "content/child/resource_dispatcher.h"
 #include "content/child/sync_load_response.h"
 #include "content/public/child/fixed_received_data.h"
 #include "content/public/child/request_peer.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/resource_response_info.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
@@ skipping 26 matching lines @@
   TestResourceDispatcher() :
       ResourceDispatcher(nullptr, nullptr),
       canceled_(false),
       defers_loading_(false) {
   }
 
   ~TestResourceDispatcher() override {}
 
   // TestDispatcher implementation:
 
-  void StartSync(const RequestInfo& request_info,
-                 ResourceRequestBodyImpl* request_body,
+  void StartSync(std::unique_ptr<ResourceRequest> request,
+                 int routing_id,
                  SyncLoadResponse* response,
                  blink::WebURLRequest::LoadingIPCType ipc_type,
                  mojom::URLLoaderFactory* url_loader_factory) override {
     *response = sync_load_response_;
   }
 
-  int StartAsync(const RequestInfo& request_info,
-                 ResourceRequestBodyImpl* request_body,
-                 std::unique_ptr<RequestPeer> peer,
-                 blink::WebURLRequest::LoadingIPCType ipc_type,
-                 mojom::URLLoaderFactory* url_loader_factory) override {
+  int StartAsync(
+      std::unique_ptr<ResourceRequest> request,
+      int routing_id,
+      scoped_refptr<base::SingleThreadTaskRunner> loading_task_runner,
+      const GURL& frame_origin,
+      std::unique_ptr<RequestPeer> peer,
+      blink::WebURLRequest::LoadingIPCType ipc_type,
+      mojom::URLLoaderFactory* url_loader_factory) override {
     EXPECT_FALSE(peer_);
     EXPECT_EQ(blink::WebURLRequest::LoadingIPCType::ChromeIPC, ipc_type);
     peer_ = std::move(peer);
-    url_ = request_info.url;
-    stream_url_ = request_info.resource_body_stream_url;
+    url_ = request->url;
+    stream_url_ = request->resource_body_stream_url;
     return 1;
   }
 
   void Cancel(int request_id) override {
     EXPECT_FALSE(canceled_);
     canceled_ = true;
   }
 
   RequestPeer* peer() { return peer_.get(); }
 
@@ skipping 534 matching lines @@
   stream_override->stream_url = kStreamURL;
   stream_override->response.mime_type = kMimeType;
   RequestExtraData* extra_data = new RequestExtraData();
   extra_data->set_stream_override(std::move(stream_override));
   request.setExtraData(extra_data);
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableBrowserSideNavigation);
 
   client()->loader()->loadAsynchronously(request, client());
 
-  // The stream url should have been added to the RequestInfo.
+  // The stream url should have been added to the ResourceRequest.
   ASSERT_TRUE(peer());
   EXPECT_EQ(kNavigationURL, dispatcher()->url());
   EXPECT_EQ(kStreamURL, dispatcher()->stream_url());
 
   EXPECT_FALSE(client()->did_receive_response());
   peer()->OnReceivedResponse(content::ResourceResponseInfo());
   EXPECT_TRUE(client()->did_receive_response());
 
   // The response info should have been overriden.
   ASSERT_FALSE(client()->response().isNull());
@@ skipping 58 matching lines @@
                                         encoded_data_length);
 
   EXPECT_EQ(kEncodedBodyLength, response.encodedBodyLength());
   EXPECT_EQ(kEncodedDataLength, encoded_data_length);
   int expected_decoded_body_length = strlen(kBodyData);
   EXPECT_EQ(expected_decoded_body_length, response.decodedBodyLength());
 }
 
 }  // namespace
 }  // namespace content