Change SupportsSpdy dict, SpdySettingsMap, ServerNetworkStatsMap, AlternativeServiceMap and disk da…

content/browser/loader/resource_scheduler_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 "content/browser/loader/resource_scheduler.h"
 
 #include <utility>
 
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 13 matching lines @@
 #include "content/public/test/test_browser_context.h"
 #include "content/test/test_render_view_host_factory.h"
 #include "content/test/test_web_contents.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/latency_info.h"
+#include "url/scheme_host_port.h"
 
 using std::string;
 
 namespace content {
 
 namespace {
 
 class TestRequestFactory;
 
 const int kChildId = 30;
@@ skipping 286 matching lines @@
   EXPECT_TRUE(lowest->started());
   EXPECT_FALSE(lowest2->started());
 
   scheduler()->OnWillInsertBody(kChildId, kRouteId);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(lowest2->started());
 }
 
 TEST_F(ResourceSchedulerTest, OneLowLoadsUntilBodyInsertedExceptSpdy) {
   http_server_properties_.SetSupportsSpdy(
-      net::HostPortPair("spdyhost", 443), true);
+      url::SchemeHostPort("https", "spdyhost", 443), true);
   std::unique_ptr<TestRequest> high(
       NewRequest("http://host/high", net::HIGHEST));
   std::unique_ptr<TestRequest> low_spdy(
       NewRequest("https://spdyhost/low", net::LOWEST));
   std::unique_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
   std::unique_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
   EXPECT_TRUE(high->started());
   EXPECT_TRUE(low_spdy->started());
   EXPECT_TRUE(low->started());
   EXPECT_FALSE(low2->started());
@@ skipping 307 matching lines @@
       NewRequest("http://spdyhost1:8080/low", net::LOWEST));
   // Cancel a request after we learn the server supports SPDY.
   ScopedVector<TestRequest> lows;
   for (int i = 0; i < kMaxNumDelayableRequestsPerClient - 1; ++i) {
     string url = "http://host" + base::IntToString(i) + "/low";
     lows.push_back(NewRequest(url.c_str(), net::LOWEST));
   }
   std::unique_ptr<TestRequest> low1(NewRequest("http://host/low", net::LOWEST));
   EXPECT_FALSE(low1->started());
   http_server_properties_.SetSupportsSpdy(
-      net::HostPortPair("spdyhost1", 8080), true);
+      url::SchemeHostPort("http", "spdyhost1", 8080), true);
   low1_spdy.reset();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(low1->started());
 
   low1.reset();
   base::RunLoop().RunUntilIdle();
   std::unique_ptr<TestRequest> low2_spdy(
       NewRequest("http://spdyhost2:8080/low", net::IDLE));
   // Reprioritize a request after we learn the server supports SPDY.
   EXPECT_TRUE(low2_spdy->started());
   http_server_properties_.SetSupportsSpdy(
-      net::HostPortPair("spdyhost2", 8080), true);
+      url::SchemeHostPort("http", "spdyhost2", 8080), true);
   ChangeRequestPriority(low2_spdy.get(), net::LOWEST);
   base::RunLoop().RunUntilIdle();
   std::unique_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
   EXPECT_TRUE(low2->started());
 }
 
 TEST_F(ResourceSchedulerTest, OustandingRequestLimitEnforced) {
   const int kRequestLimit = 3;
   ASSERT_TRUE(InitializeFieldTrials(
       base::StringPrintf("OutstandingRequestLimiting/Limit=%d/",
@@ skipping 18 matching lines @@
 // that support request priority.
 TEST_F(ResourceSchedulerTest,
        OutstandingRequestsLimitsEnforcedForRequestPriority) {
   const int kRequestLimit = 3;
   ASSERT_TRUE(InitializeFieldTrials(
       base::StringPrintf("OutstandingRequestLimiting/Limit=%d/",
                          kRequestLimit)));
   InitializeScheduler();
 
   http_server_properties_.SetSupportsSpdy(
-      net::HostPortPair("spdyhost", 443), true);
+      url::SchemeHostPort("https", "spdyhost", 443), true);
 
   // Throw in requests up to the above limit; make sure they are started.
   ScopedVector<TestRequest> requests;
   for (int i = 0; i < kRequestLimit; ++i) {
     string url = "http://spdyhost/medium";
     requests.push_back(NewRequest(url.c_str(), net::MEDIUM));
     EXPECT_TRUE(requests[i]->started());
   }
 
   // Confirm that another request will indeed fail.
@@ skipping 438 matching lines @@
   }
 
   std::unique_ptr<TestRequest> last_different_host(
       NewRequest("http://host_new/last", net::LOWEST));
   EXPECT_FALSE(last_different_host->started());
 }
 
 }  // unnamed namespace
 
 }  // namespace content