Remove HTTP pipelining support.

chrome/browser/ui/webui/net_internals/net_internals_ui_browsertest.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 "chrome/browser/ui/webui/net_internals/net_internals_ui_browsertest.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 16 matching lines @@
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui_message_handler.h"
 #include "net/base/address_list.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_log_logger.h"
 #include "net/dns/host_cache.h"
 #include "net/dns/host_resolver.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_network_session.h"
-#include "net/http/http_pipelined_host_capability.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 using content::WebUIMessageHandler;
 
 namespace {
@@ skipping 23 matching lines @@
     ASSERT_TRUE(ip_literal.empty());
   }
 
   // Add entry to the cache.
   cache->Set(net::HostCache::Key(hostname, net::ADDRESS_FAMILY_UNSPECIFIED, 0),
              net::HostCache::Entry(net_error, address_list),
              base::TimeTicks::Now(),
              ttl);
 }
 
-// Called on IO thread.  Adds an entry to the list of known HTTP pipelining
-// hosts.
-void AddDummyHttpPipelineFeedbackOnIOThread(
-    net::URLRequestContextGetter* context_getter,
-    const std::string& hostname,
-    int port,
-    net::HttpPipelinedHostCapability capability) {
-  ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  net::URLRequestContext* context = context_getter->GetURLRequestContext();
-  net::HttpNetworkSession* http_network_session =
-      context->http_transaction_factory()->GetSession();
-  base::WeakPtr<net::HttpServerProperties> http_server_properties =
-      http_network_session->http_server_properties();
-  net::HostPortPair origin(hostname, port);
-  http_server_properties->SetPipelineCapability(origin, capability);
-}
-
-// Called on IO thread.  Adds an entry to the list of known HTTP pipelining
-// hosts.
-void EnableHttpPipeliningOnIOThread(
-    net::URLRequestContextGetter* context_getter, bool enable) {
-  ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  net::URLRequestContext* context = context_getter->GetURLRequestContext();
-  net::HttpNetworkSession* http_network_session =
-      context->http_transaction_factory()->GetSession();
-  http_network_session->set_http_pipelining_enabled(enable);
-}
-
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetInternalsTest::MessageHandler
 ////////////////////////////////////////////////////////////////////////////////
 
 // Class to handle messages from the renderer needed by certain tests.
 class NetInternalsTest::MessageHandler : public content::WebUIMessageHandler {
  public:
   explicit MessageHandler(NetInternalsTest* net_internals_test);
@@ skipping 26 matching lines @@
   // there, and that the background tab exists at slot 1.
   void NavigateToPrerender(const base::ListValue* list_value);
 
   // Creates an incognito browser.  Once creation is complete, passes a
   // message to the Javascript test harness.
   void CreateIncognitoBrowser(const base::ListValue* list_value);
 
   // Closes an incognito browser created with CreateIncognitoBrowser.
   void CloseIncognitoBrowser(const base::ListValue* list_value);
 
-  // Takes in a boolean and enables/disabled HTTP pipelining accordingly.
-  void EnableHttpPipelining(const base::ListValue* list_value);
-
-  // Called on UI thread. Adds an entry to the list of known HTTP pipelining
-  // hosts.
-  void AddDummyHttpPipelineFeedback(const base::ListValue* list_value);
-
   // Creates a simple log with a NetLogLogger, and returns it to the
   // Javascript callback.
   void GetNetLogLoggerLog(const base::ListValue* list_value);
 
   Browser* browser() { return net_internals_test_->browser(); }
 
   NetInternalsTest* net_internals_test_;
   Browser* incognito_browser_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageHandler);
@@ skipping 20 matching lines @@
                   base::Unretained(this)));
   web_ui()->RegisterMessageCallback("navigateToPrerender",
       base::Bind(&NetInternalsTest::MessageHandler::NavigateToPrerender,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("createIncognitoBrowser",
       base::Bind(&NetInternalsTest::MessageHandler::CreateIncognitoBrowser,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("closeIncognitoBrowser",
       base::Bind(&NetInternalsTest::MessageHandler::CloseIncognitoBrowser,
                  base::Unretained(this)));
-  web_ui()->RegisterMessageCallback("enableHttpPipelining",
-      base::Bind(&NetInternalsTest::MessageHandler::EnableHttpPipelining,
-                 base::Unretained(this)));
-  web_ui()->RegisterMessageCallback("addDummyHttpPipelineFeedback",
-      base::Bind(
-          &NetInternalsTest::MessageHandler::AddDummyHttpPipelineFeedback,
-          base::Unretained(this)));
   web_ui()->RegisterMessageCallback("getNetLogLoggerLog",
       base::Bind(
           &NetInternalsTest::MessageHandler::GetNetLogLoggerLog,
           base::Unretained(this)));
 }
 
 void NetInternalsTest::MessageHandler::RunJavascriptCallback(
     base::Value* value) {
   web_ui()->CallJavascriptFunction("NetInternalsTest.callback", *value);
 }
@@ skipping 77 matching lines @@
 
 void NetInternalsTest::MessageHandler::CloseIncognitoBrowser(
     const base::ListValue* list_value) {
   ASSERT_TRUE(incognito_browser_);
   incognito_browser_->tab_strip_model()->CloseAllTabs();
   // Closing all a Browser's tabs will ultimately result in its destruction,
   // thought it may not have been destroyed yet.
   incognito_browser_ = NULL;
 }
 
-void NetInternalsTest::MessageHandler::EnableHttpPipelining(
-    const base::ListValue* list_value) {
-  bool enable;
-  ASSERT_TRUE(list_value->GetBoolean(0, &enable));
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&EnableHttpPipeliningOnIOThread,
-                 make_scoped_refptr(browser()->profile()->GetRequestContext()),
-                 enable));
-}
-
-void NetInternalsTest::MessageHandler::AddDummyHttpPipelineFeedback(
-    const base::ListValue* list_value) {
-  std::string hostname;
-  double port;
-  std::string raw_capability;
-  net::HttpPipelinedHostCapability capability;
-  ASSERT_TRUE(list_value->GetString(0, &hostname));
-  ASSERT_TRUE(list_value->GetDouble(1, &port));
-  ASSERT_TRUE(list_value->GetString(2, &raw_capability));
-  if (raw_capability == "capable") {
-    capability = net::PIPELINE_CAPABLE;
-  } else if (raw_capability == "incapable") {
-    capability = net::PIPELINE_INCAPABLE;
-  } else {
-    FAIL() << "Unexpected capability string: " << raw_capability;
-  }
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&AddDummyHttpPipelineFeedbackOnIOThread,
-                 make_scoped_refptr(browser()->profile()->GetRequestContext()),
-                 hostname,
-                 static_cast<int>(port),
-                 capability));
-}
-
 void NetInternalsTest::MessageHandler::GetNetLogLoggerLog(
     const base::ListValue* list_value) {
   base::ScopedTempDir temp_directory;
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
   base::FilePath temp_file;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_directory.path(),
                                              &temp_file));
   FILE* temp_file_handle = base::OpenFile(temp_file, "w");
   ASSERT_TRUE(temp_file_handle);
 
@@ skipping 72 matching lines @@
   GURL url_loader = test_server()->GetURL(replacement_path);
   return url_loader;
 }
 
 bool NetInternalsTest::StartTestServer() {
   if (test_server_started_)
     return true;
   test_server_started_ = test_server()->Start();
   return test_server_started_;
 }