Add a force pipelining option to load flags.

net/http/http_pipelined_host_impl.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 "net/http/http_pipelined_host_impl.h"
 
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "net/http/http_pipelined_connection_impl.h"
 #include "net/http/http_pipelined_stream.h"
 
 using base::DictionaryValue;
 using base::ListValue;
 using base::Value;
 
 namespace net {
 
 // TODO(simonjam): Run experiments to see what value minimizes evictions without
 // costing too much performance. Until then, this is just a bad guess.
 static const int kNumKnownSuccessesThreshold = 3;
 
-class HttpPipelinedConnectionImplFactory :
-    public HttpPipelinedConnection::Factory {
- public:
-  HttpPipelinedConnection* CreateNewPipeline(
-      ClientSocketHandle* connection,
-      HttpPipelinedConnection::Delegate* delegate,
-      const HostPortPair& origin,
-      const SSLConfig& used_ssl_config,
-      const ProxyInfo& used_proxy_info,
-      const BoundNetLog& net_log,
-      bool was_npn_negotiated,
-      SSLClientSocket::NextProto protocol_negotiated) OVERRIDE {
-    return new HttpPipelinedConnectionImpl(connection, delegate, origin,
-                                           used_ssl_config, used_proxy_info,
-                                           net_log, was_npn_negotiated,
-                                           protocol_negotiated);
-  }
-};
-
 HttpPipelinedHostImpl::HttpPipelinedHostImpl(
     HttpPipelinedHost::Delegate* delegate,
-    const HostPortPair& origin,
+    const HttpPipelinedHost::Key& key,
     HttpPipelinedConnection::Factory* factory,
     HttpPipelinedHostCapability capability)
     : delegate_(delegate),
-      origin_(origin),
+      key_(key),
       factory_(factory),
       capability_(capability) {
   if (!factory) {
-    factory_.reset(new HttpPipelinedConnectionImplFactory());
+    factory_.reset(new HttpPipelinedConnectionImpl::Factory());
   }
 }
 
 HttpPipelinedHostImpl::~HttpPipelinedHostImpl() {
   CHECK(pipelines_.empty());
 }
 
 HttpPipelinedStream* HttpPipelinedHostImpl::CreateStreamOnNewPipeline(
     ClientSocketHandle* connection,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
     const BoundNetLog& net_log,
     bool was_npn_negotiated,
     SSLClientSocket::NextProto protocol_negotiated) {
   if (capability_ == PIPELINE_INCAPABLE) {
     return NULL;
   }
   HttpPipelinedConnection* pipeline = factory_->CreateNewPipeline(
-      connection, this, origin_, used_ssl_config, used_proxy_info, net_log,
-      was_npn_negotiated, protocol_negotiated);
+      connection, this, key_.origin(), used_ssl_config, used_proxy_info,
+      net_log, was_npn_negotiated, protocol_negotiated);
   PipelineInfo info;
   pipelines_.insert(std::make_pair(pipeline, info));
   return pipeline->CreateNewStream();
 }
 
 HttpPipelinedStream* HttpPipelinedHostImpl::CreateStreamOnExistingPipeline() {
   HttpPipelinedConnection* available_pipeline = NULL;
   for (PipelineInfoMap::iterator it = pipelines_.begin();
        it != pipelines_.end(); ++it) {
     if (CanPipelineAcceptRequests(it->first) &&
@@ skipping 11 matching lines @@
 bool HttpPipelinedHostImpl::IsExistingPipelineAvailable() const {
   for (PipelineInfoMap::const_iterator it = pipelines_.begin();
        it != pipelines_.end(); ++it) {
     if (CanPipelineAcceptRequests(it->first)) {
       return true;
     }
   }
   return false;
 }
 
-const HostPortPair& HttpPipelinedHostImpl::origin() const {
-  return origin_;
+const HttpPipelinedHost::Key& HttpPipelinedHostImpl::key() const {
+  return key_;
 }
 
 void HttpPipelinedHostImpl::OnPipelineEmpty(HttpPipelinedConnection* pipeline) {
   CHECK(ContainsKey(pipelines_, pipeline));
   pipelines_.erase(pipeline);
   delete pipeline;
   if (pipelines_.empty()) {
     delegate_->OnHostIdle(this);
     // WARNING: We'll probably be deleted here.
   }
@@ skipping 92 matching lines @@
       OnPipelineHasCapacity(it->first);
     }
   }
 }
 
 Value* HttpPipelinedHostImpl::PipelineInfoToValue() const {
   ListValue* list_value = new ListValue();
   for (PipelineInfoMap::const_iterator it = pipelines_.begin();
        it != pipelines_.end(); ++it) {
     DictionaryValue* pipeline_dict = new DictionaryValue;
-    pipeline_dict->SetString("host", origin_.ToString());
+    pipeline_dict->SetString("host", key_.origin().ToString());
+    pipeline_dict->SetBoolean("forced", key_.force_pipelining());
     pipeline_dict->SetInteger("depth", it->first->depth());
     pipeline_dict->SetInteger("capacity", GetPipelineCapacity());
     pipeline_dict->SetBoolean("usable", it->first->usable());
     pipeline_dict->SetBoolean("active", it->first->active());
     pipeline_dict->SetInteger("source_id", it->first->net_log().source().id);
     list_value->Append(pipeline_dict);
   }
   return list_value;
 }
 
 HttpPipelinedHostImpl::PipelineInfo::PipelineInfo()
     : num_successes(0) {
 }
 
 }  // namespace net