Remove code for max connection throttling; the experiment's complete.

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/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
-#include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
-#include "base/test/mock_entropy_provider.h"
 #include "base/timer/mock_timer.h"
 #include "base/timer/timer.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_throttle.h"
-#include "content/public/common/content_switches.h"
 #include "content/public/test/mock_render_process_host.h"
 #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"
@@ skipping 88 matching lines @@
 class FakeResourceContext : public ResourceContext {
  private:
   net::HostResolver* GetHostResolver() override { return NULL; }
   net::URLRequestContext* GetRequestContext() override { return NULL; }
 };
 
 class ResourceSchedulerTest : public testing::Test {
  protected:
   ResourceSchedulerTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
-        io_thread_(BrowserThread::IO, &message_loop_),
-        field_trial_list_(base::MakeUnique<base::MockEntropyProvider>()) {
+        io_thread_(BrowserThread::IO, &message_loop_) {
     InitializeScheduler();
     context_.set_http_server_properties(&http_server_properties_);
   }
 
   ~ResourceSchedulerTest() override {
     CleanupScheduler();
   }
 
   // Done separately from construction to allow for modification of command
   // line flags in tests.
   void InitializeScheduler() {
     CleanupScheduler();
 
     // Destroys previous scheduler, also destroys any previously created
     // mock_timer_.
     scheduler_.reset(new ResourceScheduler());
 
     scheduler_->OnClientCreated(kChildId, kRouteId);
     scheduler_->OnClientCreated(
         kBackgroundChildId, kBackgroundRouteId);
   }
 
   void CleanupScheduler() {
     if (scheduler_) {
       scheduler_->OnClientDeleted(kChildId, kRouteId);
       scheduler_->OnClientDeleted(kBackgroundChildId, kBackgroundRouteId);
     }
   }
 
-  // Create field trials based on the argument, which has the same format
-  // as the argument to kForceFieldTrials.
-  bool InitializeFieldTrials(const std::string& force_field_trial_argument) {
-    return base::FieldTrialList::CreateTrialsFromString(
-        force_field_trial_argument, std::set<std::string>());
-  }
-
   std::unique_ptr<net::URLRequest> NewURLRequestWithChildAndRoute(
       const char* url,
       net::RequestPriority priority,
       int child_id,
       int route_id) {
     std::unique_ptr<net::URLRequest> url_request(
         context_.CreateRequest(GURL(url), priority, NULL));
     return url_request;
   }
 
@@ skipping 71 matching lines @@
 
   ResourceScheduler* scheduler() {
     return scheduler_.get();
   }
 
   base::MessageLoopForIO message_loop_;
   BrowserThreadImpl ui_thread_;
   BrowserThreadImpl io_thread_;
   ResourceDispatcherHostImpl rdh_;
   std::unique_ptr<ResourceScheduler> scheduler_;
-  base::FieldTrialList field_trial_list_;
   base::MockTimer* mock_timer_;
   net::HttpServerPropertiesImpl http_server_properties_;
   net::TestURLRequestContext context_;
 };
 
 TEST_F(ResourceSchedulerTest, OneIsolatedLowRequest) {
   std::unique_ptr<TestRequest> request(
       NewRequest("http://host/1", net::LOWEST));
   EXPECT_TRUE(request->started());
 }
@@ skipping 415 matching lines @@
   // Reprioritize a request after we learn the server supports SPDY.
   EXPECT_TRUE(low2_spdy->started());
   http_server_properties_.SetSupportsSpdy(
       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/",
-                           kRequestLimit)));
-    InitializeScheduler();
-
-    // 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://host/medium";
-      requests.push_back(NewRequest(url.c_str(), net::MEDIUM));
-      EXPECT_TRUE(requests[i]->started());
-    }
-
-    // Confirm that another request will indeed fail.
-    string url = "http://host/medium";
-    requests.push_back(NewRequest(url.c_str(), net::MEDIUM));
-    EXPECT_FALSE(requests[kRequestLimit]->started());
-  }
-
-  // Confirm that outstanding requests limits apply to requests to hosts
-  // 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(
-        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.
-    string url = "http://spdyhost/medium";
-    requests.push_back(NewRequest(url.c_str(), net::MEDIUM));
-    EXPECT_FALSE(requests[kRequestLimit]->started());
-  }
-
-  TEST_F(ResourceSchedulerTest, OutstandingRequestLimitDelays) {
-    const int kRequestLimit = 3;
-    ASSERT_TRUE(InitializeFieldTrials(
-        base::StringPrintf("OutstandingRequestLimiting/Limit=%d/",
-                           kRequestLimit)));
-
-    InitializeScheduler();
-    std::unique_ptr<TestRequest> high(
-        NewRequest("http://host/high", net::HIGHEST));
-    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_FALSE(low->started());
-    EXPECT_FALSE(low2->started());
-
-    high.reset();
-    base::RunLoop().RunUntilIdle();
-    EXPECT_TRUE(low->started());
-    EXPECT_FALSE(low2->started());
-  }
-
-  // Async revalidations which are not started when the tab is closed must be
+// Async revalidations which are not started when the tab is closed must be
 // started at some point, or they will hang around forever and prevent other
 // async revalidations to the same URL from being issued.
 TEST_F(ResourceSchedulerTest, RequestStartedAfterClientDeleted) {
   scheduler_->OnClientCreated(kChildId2, kRouteId2);
   std::unique_ptr<TestRequest> high(NewRequestWithChildAndRoute(
       "http://host/high", net::HIGHEST, kChildId2, kRouteId2));
   std::unique_ptr<TestRequest> lowest1(NewRequestWithChildAndRoute(
       "http://host/lowest", net::LOWEST, kChildId2, kRouteId2));
   std::unique_ptr<TestRequest> lowest2(NewRequestWithChildAndRoute(
       "http://host/lowest", net::LOWEST, kChildId2, kRouteId2));
@@ skipping 27 matching lines @@
   scheduler_->OnClientDeleted(kChildId2, kRouteId2);
   high.reset();
   delayable_requests.clear();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(lowest->started());
 }
 
 }  // unnamed namespace
 
 }  // namespace content