Provide route ID via URLLoaderFactory

content/browser/loader/url_loader_factory_impl_unittest.cc

 // Copyright 2016 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/browser/loader/url_loader_factory_impl.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "content/browser/loader/mojo_async_resource_handler.h"
 #include "content/browser/loader/navigation_resource_throttle.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_message_filter.h"
+#include "content/browser/loader/resource_request_info_impl.h"
 #include "content/browser/loader/test_url_loader_client.h"
 #include "content/browser/loader_delegate_impl.h"
 #include "content/common/resource_request.h"
 #include "content/common/resource_request_completion_status.h"
 #include "content/common/url_loader.mojom.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/common/process_type.h"
 #include "content/public/test/test_browser_context.h"
@@ skipping 11 matching lines @@
 #include "net/test/url_request/url_request_failed_job.h"
 #include "net/test/url_request/url_request_mock_http_job.h"
 #include "net/url_request/url_request_filter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace content {
 
 namespace {
 
+constexpr int kChildId = 99;
+
 class RejectingResourceDispatcherHostDelegate final
     : public ResourceDispatcherHostDelegate {
  public:
   RejectingResourceDispatcherHostDelegate() {}
   bool ShouldBeginRequest(const std::string& method,
                           const GURL& url,
                           ResourceType resource_type,
                           ResourceContext* resource_context) override {
     return false;
   }
 
   DISALLOW_COPY_AND_ASSIGN(RejectingResourceDispatcherHostDelegate);
 };
 
 // The test parameter is the number of bytes allocated for the buffer in the
 // data pipe, for testing the case where the allocated size is smaller than the
 // size the mime sniffer *implicitly* requires.
 class URLLoaderFactoryImplTest : public ::testing::TestWithParam<size_t> {
  public:
   URLLoaderFactoryImplTest()
       : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
         browser_context_(new TestBrowserContext()),
         resource_message_filter_(new ResourceMessageFilter(
-            0,
+            kChildId,
             // If browser side navigation is enabled then
             // ResourceDispatcherHostImpl prevents main frame URL requests from
             // the renderer. Ensure that these checks don't trip us up by
             // setting the process type in ResourceMessageFilter as
             // PROCESS_TYPE_UNKNOWN.
             PROCESS_TYPE_UNKNOWN,
             nullptr,
             nullptr,
             nullptr,
             nullptr,
@@ skipping 33 matching lines @@
   LoaderDelegateImpl loader_deleate_;
   ResourceDispatcherHostImpl rdh_;
   std::unique_ptr<TestBrowserContext> browser_context_;
   scoped_refptr<ResourceMessageFilter> resource_message_filter_;
   mojom::URLLoaderFactoryPtr factory_;
 
   DISALLOW_COPY_AND_ASSIGN(URLLoaderFactoryImplTest);
 };
 
 TEST_P(URLLoaderFactoryImplTest, GetResponse) {
+  constexpr int32_t kRoutingId = 81;
+  constexpr int32_t kRequestId = 28;
   NavigationResourceThrottle::set_ui_checks_always_succeed_for_testing(true);
   mojom::URLLoaderPtr loader;
   base::FilePath root;
   PathService::Get(DIR_TEST_DATA, &root);
   net::URLRequestMockHTTPJob::AddUrlHandlers(root,
                                              BrowserThread::GetBlockingPool());
   ResourceRequest request;
   TestURLLoaderClient client;
   // Assume the file contents is small enough to be stored in the data pipe.
   request.url = net::URLRequestMockHTTPJob::GetMockUrl("hello.html");
   request.method = "GET";
   request.is_main_frame = true;
-  factory_->CreateLoaderAndStart(mojo::GetProxy(&loader), 1, request,
+  factory_->CreateLoaderAndStart(mojo::GetProxy(&loader), kRoutingId,
+                                 kRequestId, request,
                                  client.CreateInterfacePtrAndBind());
 
   ASSERT_FALSE(client.has_received_response());
   ASSERT_FALSE(client.response_body().is_valid());
   ASSERT_FALSE(client.has_received_completion());
 
   client.RunUntilResponseReceived();
+
+  net::URLRequest* url_request =
+      rdh_.GetURLRequest(GlobalRequestID(kChildId, kRequestId));
+  ASSERT_TRUE(url_request);
+  ResourceRequestInfoImpl* request_info =
+      ResourceRequestInfoImpl::ForRequest(url_request);
+  ASSERT_TRUE(request_info);
+  EXPECT_EQ(kChildId, request_info->GetChildID());
+  EXPECT_EQ(kRoutingId, request_info->GetRouteID());
+  EXPECT_EQ(kRequestId, request_info->GetRequestID());
+
   ASSERT_FALSE(client.has_received_completion());
   ASSERT_FALSE(client.has_received_completion());
 
   client.RunUntilResponseBodyArrived();
   ASSERT_TRUE(client.response_body().is_valid());
   ASSERT_FALSE(client.has_received_completion());
 
   client.RunUntilComplete();
 
   EXPECT_EQ(200, client.response_head().headers->response_code());
@@ skipping 24 matching lines @@
 
 TEST_P(URLLoaderFactoryImplTest, GetFailedResponse) {
   NavigationResourceThrottle::set_ui_checks_always_succeed_for_testing(true);
   mojom::URLLoaderPtr loader;
   ResourceRequest request;
   TestURLLoaderClient client;
   net::URLRequestFailedJob::AddUrlHandler();
   request.url = net::URLRequestFailedJob::GetMockHttpUrlWithFailurePhase(
       net::URLRequestFailedJob::START, net::ERR_TIMED_OUT);
   request.method = "GET";
-  factory_->CreateLoaderAndStart(mojo::GetProxy(&loader), 1, request,
+  factory_->CreateLoaderAndStart(mojo::GetProxy(&loader), 2, 1, request,
                                  client.CreateInterfacePtrAndBind());
 
   client.RunUntilComplete();
   ASSERT_FALSE(client.has_received_response());
   ASSERT_FALSE(client.response_body().is_valid());
 
   EXPECT_EQ(net::ERR_TIMED_OUT, client.completion_status().error_code);
 }
 
 // This test tests a case where resource loading is cancelled before started.
 TEST_P(URLLoaderFactoryImplTest, InvalidURL) {
   mojom::URLLoaderPtr loader;
   ResourceRequest request;
   TestURLLoaderClient client;
   request.url = GURL();
   request.method = "GET";
   ASSERT_FALSE(request.url.is_valid());
-  factory_->CreateLoaderAndStart(mojo::GetProxy(&loader), 1, request,
+  factory_->CreateLoaderAndStart(mojo::GetProxy(&loader), 2, 1, request,
                                  client.CreateInterfacePtrAndBind());
 
   client.RunUntilComplete();
   ASSERT_FALSE(client.has_received_response());
   ASSERT_FALSE(client.response_body().is_valid());
 
   EXPECT_EQ(net::ERR_ABORTED, client.completion_status().error_code);
 }
 
 // This test tests a case where resource loading is cancelled before started.
 TEST_P(URLLoaderFactoryImplTest, ShouldNotRequestURL) {
   mojom::URLLoaderPtr loader;
   RejectingResourceDispatcherHostDelegate rdh_delegate;
   rdh_.SetDelegate(&rdh_delegate);
   ResourceRequest request;
   TestURLLoaderClient client;
   request.url = GURL("http://localhost/");
   request.method = "GET";
-  factory_->CreateLoaderAndStart(mojo::GetProxy(&loader), 1, request,
+  factory_->CreateLoaderAndStart(mojo::GetProxy(&loader), 2, 1, request,
                                  client.CreateInterfacePtrAndBind());
 
   client.RunUntilComplete();
   rdh_.SetDelegate(nullptr);
 
   ASSERT_FALSE(client.has_received_response());
   ASSERT_FALSE(client.response_body().is_valid());
 
   EXPECT_EQ(net::ERR_ABORTED, client.completion_status().error_code);
 }
 
 INSTANTIATE_TEST_CASE_P(URLLoaderFactoryImplTest,
                         URLLoaderFactoryImplTest,
                         ::testing::Values(128, 32 * 1024));
 
 }  // namespace
 
 }  // namespace content