[on hold] Remove dependency on RenderViewHost from LoadState notifications

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>
 
@@ skipping 817 matching lines @@
   }
 
  private:
   int resource_request_redirect_count_;
   int resource_response_start_count_;
 };
 
 // Information used to create resource requests that use URLRequestLoadInfoJobs.
 // The child_id is just that of ResourceDispatcherHostTest::filter_.
 struct LoadInfoTestRequestInfo {
-  int route_id;
+  GlobalFrameRoutingId route_id;
   GURL url;
   net::LoadState load_state;
   net::UploadProgress upload_progress;
 };
 
 enum class TestConfig {
   kDefault,
   kOptimizeIPCForSmallResourceEnabled,
 };
 
@@ skipping 80 matching lines @@
     return true;
   }
 
   std::unique_ptr<LoadInfoMap> RunLoadInfoTest(
       LoadInfoTestRequestInfo* request_info,
       size_t num_requests) {
     for (size_t i = 0; i < num_requests; ++i) {
       loader_test_request_info_.reset(
           new LoadInfoTestRequestInfo(request_info[i]));
       wait_for_request_create_loop_.reset(new base::RunLoop());
-      MakeTestRequest(request_info[i].route_id, i + 1, request_info[i].url);
+      MakeTestRequestWithRenderFrame(
+          0, request_info[i].route_id.frame_routing_id, i + 1,
+          request_info[i].url, RESOURCE_TYPE_SUB_RESOURCE);
       wait_for_request_create_loop_->Run();
       wait_for_request_create_loop_.reset();
     }
     return ResourceDispatcherHostImpl::Get()->GetLoadInfoForAllRoutes();
   }
 
  protected:
   friend class TestURLRequestJobFactory;
 
   // testing::Test
@@ skipping 2643 matching lines @@
 
 // Tests GetLoadInfoForAllRoutes when there are no pending requests.
 TEST_P(ResourceDispatcherHostTest, LoadInfoNoRequests) {
   std::unique_ptr<LoadInfoMap> load_info_map = RunLoadInfoTest(nullptr, 0);
   EXPECT_EQ(0u, load_info_map->size());
 }
 
 // Tests GetLoadInfoForAllRoutes when there are 3 requests from the same
 // RenderView.  The second one is farthest along.
 TEST_P(ResourceDispatcherHostTest, LoadInfo) {
-  const GlobalRoutingID kId(filter_->child_id(), 0);
+  const GlobalFrameRoutingId kId(filter_->child_id(), 0);
   LoadInfoTestRequestInfo request_info[] = {
-      {kId.route_id,
-       GURL("test://1/"),
-       net::LOAD_STATE_SENDING_REQUEST,
+      {kId, GURL("test://1/"), net::LOAD_STATE_SENDING_REQUEST,
        net::UploadProgress(0, 0)},
-      {kId.route_id,
-       GURL("test://2/"),
-       net::LOAD_STATE_READING_RESPONSE,
+      {kId, GURL("test://2/"), net::LOAD_STATE_READING_RESPONSE,
        net::UploadProgress(0, 0)},
-      {kId.route_id,
-       GURL("test://3/"),
-       net::LOAD_STATE_SENDING_REQUEST,
+      {kId, GURL("test://3/"), net::LOAD_STATE_SENDING_REQUEST,
        net::UploadProgress(0, 0)},
   };
   std::unique_ptr<LoadInfoMap> load_info_map =
       RunLoadInfoTest(request_info, arraysize(request_info));
   ASSERT_EQ(1u, load_info_map->size());
   ASSERT_TRUE(load_info_map->find(kId) != load_info_map->end());
   EXPECT_EQ(GURL("test://2/"), (*load_info_map)[kId].url);
   EXPECT_EQ(net::LOAD_STATE_READING_RESPONSE,
             (*load_info_map)[kId].load_state.state);
   EXPECT_EQ(0u, (*load_info_map)[kId].upload_position);
   EXPECT_EQ(0u, (*load_info_map)[kId].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) {
-  const GlobalRoutingID kId(filter_->child_id(), 0);
+  const GlobalFrameRoutingId kId(filter_->child_id(), 0);
   LoadInfoTestRequestInfo request_info[] = {
-      {kId.route_id,
-       GURL("test://1/"),
-       net::LOAD_STATE_IDLE,
-       net::UploadProgress(0, 0)},
-      {kId.route_id,
-       GURL("test://2/"),
-       net::LOAD_STATE_IDLE,
-       net::UploadProgress(0, 0)},
+      {kId, GURL("test://1/"), net::LOAD_STATE_IDLE, net::UploadProgress(0, 0)},
+      {kId, GURL("test://2/"), net::LOAD_STATE_IDLE, net::UploadProgress(0, 0)},
   };
   std::unique_ptr<LoadInfoMap> load_info_map =
       RunLoadInfoTest(request_info, arraysize(request_info));
   ASSERT_EQ(1u, load_info_map->size());
   ASSERT_TRUE(load_info_map->find(kId) != load_info_map->end());
   EXPECT_EQ(GURL("test://1/"), (*load_info_map)[kId].url);
   EXPECT_EQ(net::LOAD_STATE_IDLE, (*load_info_map)[kId].load_state.state);
   EXPECT_EQ(0u, (*load_info_map)[kId].upload_position);
   EXPECT_EQ(0u, (*load_info_map)[kId].upload_size);
 }
 
 // Tests GetLoadInfoForAllRoutes when a request is uploading a body.
 TEST_P(ResourceDispatcherHostTest, LoadInfoUploadProgress) {
-  const GlobalRoutingID kId(filter_->child_id(), 0);
+  const GlobalFrameRoutingId kId(filter_->child_id(), 0);
   LoadInfoTestRequestInfo request_info[] = {
-      {kId.route_id,
-       GURL("test://1/"),
-       net::LOAD_STATE_READING_RESPONSE,
+      {kId, GURL("test://1/"), net::LOAD_STATE_READING_RESPONSE,
        net::UploadProgress(0, 0)},
-      {kId.route_id,
-       GURL("test://1/"),
-       net::LOAD_STATE_READING_RESPONSE,
+      {kId, GURL("test://1/"), net::LOAD_STATE_READING_RESPONSE,
        net::UploadProgress(1000, 1000)},
-      {kId.route_id,
-       GURL("test://2/"),
-       net::LOAD_STATE_SENDING_REQUEST,
+      {kId, GURL("test://2/"), net::LOAD_STATE_SENDING_REQUEST,
        net::UploadProgress(50, 100)},
-      {kId.route_id,
-       GURL("test://1/"),
-       net::LOAD_STATE_READING_RESPONSE,
+      {kId, GURL("test://1/"), net::LOAD_STATE_READING_RESPONSE,
        net::UploadProgress(1000, 1000)},
-      {kId.route_id,
-       GURL("test://3/"),
-       net::LOAD_STATE_READING_RESPONSE,
+      {kId, GURL("test://3/"), net::LOAD_STATE_READING_RESPONSE,
        net::UploadProgress(0, 0)},
   };
   std::unique_ptr<LoadInfoMap> load_info_map =
       RunLoadInfoTest(request_info, arraysize(request_info));
   ASSERT_EQ(1u, load_info_map->size());
   ASSERT_TRUE(load_info_map->find(kId) != load_info_map->end());
   EXPECT_EQ(GURL("test://2/"), (*load_info_map)[kId].url);
   EXPECT_EQ(net::LOAD_STATE_SENDING_REQUEST,
             (*load_info_map)[kId].load_state.state);
   EXPECT_EQ(50u, (*load_info_map)[kId].upload_position);
   EXPECT_EQ(100u, (*load_info_map)[kId].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) {
-  const GlobalRoutingID kId1(filter_->child_id(), 0);
-  const GlobalRoutingID kId2(filter_->child_id(), 1);
+  const GlobalFrameRoutingId kId1(filter_->child_id(), 0);
+  const GlobalFrameRoutingId kId2(filter_->child_id(), 1);
   LoadInfoTestRequestInfo request_info[] = {
-      {kId1.route_id,
-       GURL("test://1/"),
-       net::LOAD_STATE_CONNECTING,
+      {kId1, GURL("test://1/"), net::LOAD_STATE_CONNECTING,
        net::UploadProgress(0, 0)},
-      {kId2.route_id,
-       GURL("test://2/"),
-       net::LOAD_STATE_IDLE,
+      {kId2, GURL("test://2/"), net::LOAD_STATE_IDLE,
        net::UploadProgress(0, 0)},
-      {kId1.route_id,
-       GURL("test://3/"),
-       net::LOAD_STATE_IDLE,
+      {kId1, GURL("test://3/"), net::LOAD_STATE_IDLE,
        net::UploadProgress(0, 0)},
-      {kId2.route_id,
-       GURL("test://4/"),
-       net::LOAD_STATE_CONNECTING,
+      {kId2, GURL("test://4/"), net::LOAD_STATE_CONNECTING,
        net::UploadProgress(0, 0)},
   };
   std::unique_ptr<LoadInfoMap> load_info_map =
       RunLoadInfoTest(request_info, arraysize(request_info));
   ASSERT_EQ(2u, load_info_map->size());
 
   ASSERT_TRUE(load_info_map->find(kId1) != load_info_map->end());
   EXPECT_EQ(GURL("test://1/"), (*load_info_map)[kId1].url);
   EXPECT_EQ(net::LOAD_STATE_CONNECTING,
             (*load_info_map)[kId1].load_state.state);
@@ skipping 183 matching lines @@
   return nullptr;
 }
 
 INSTANTIATE_TEST_CASE_P(
     ResourceDispatcherHostTests,
     ResourceDispatcherHostTest,
     testing::Values(TestConfig::kDefault,
                     TestConfig::kOptimizeIPCForSmallResourceEnabled));
 
 }  // namespace content