Fix --host-rules command switch.

net/http/http_stream_factory_impl_job.cc

 // Copyright (c) 2011 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_stream_factory_impl_job.h"
 
 #include "base/logging.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
@@ skipping 12 matching lines @@
 #include "net/socket/client_socket_pool.h"
 #include "net/socket/socks_client_socket_pool.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/ssl_client_socket_pool.h"
 #include "net/spdy/spdy_http_stream.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 
 namespace net {
 
-namespace {
+// Parameters associated with the start of a HTTP stream job.
+class HttpStreamJobParameters : public NetLog::EventParameters {
+ public:
+  static scoped_refptr<HttpStreamJobParameters> Create(
+      const GURL& original_url,
+      const GURL& url) {
+    return make_scoped_refptr(new HttpStreamJobParameters(original_url, url));
+  }
 
-}  // namespace
+  virtual Value* ToValue() const;
+
+ private:
+  HttpStreamJobParameters(const GURL& original_url, const GURL& url)
+      : original_url_(original_url.GetOrigin().spec()),
+        url_(url.GetOrigin().spec()) {}
+
+  const std::string original_url_;
+  const std::string url_;
+};
+
+Value* HttpStreamJobParameters::ToValue() const {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetString("original_url", original_url_);
+  dict->SetString("url", url_);
+  return dict;
+}
 
 HttpStreamFactoryImpl::Job::Job(HttpStreamFactoryImpl* stream_factory,
                                 HttpNetworkSession* session,
                                 const HttpRequestInfo& request_info,
                                 const SSLConfig& ssl_config,
                                 const BoundNetLog& net_log)
     : request_(NULL),
       request_info_(request_info),
       ssl_config_(ssl_config),
       net_log_(BoundNetLog::Make(net_log.net_log(),
@@ skipping 387 matching lines @@
         NOTREACHED() << "bad state";
         rv = ERR_FAILED;
         break;
     }
   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
   return rv;
 }
 
 int HttpStreamFactoryImpl::Job::StartInternal() {
   CHECK_EQ(STATE_NONE, next_state_);
+
+  origin_ = HostPortPair(request_info_.url.HostNoBrackets(),
+                         request_info_.url.EffectiveIntPort());
+  origin_url_ = HttpStreamFactory::ApplyHostMappingRules(
+      request_info_.url, &origin_);
+
   net_log_.BeginEvent(NetLog::TYPE_HTTP_STREAM_JOB,
-                      make_scoped_refptr(new NetLogStringParameter(
-                          "url", request_info_.url.GetOrigin().spec())));
+                      HttpStreamJobParameters::Create(request_info_.url,
+                                                      origin_url_));
   next_state_ = STATE_RESOLVE_PROXY;
   int rv = RunLoop(OK);
   DCHECK_EQ(ERR_IO_PENDING, rv);
   return rv;
 }
 
 int HttpStreamFactoryImpl::Job::DoResolveProxy() {
   DCHECK(!pac_request_);
 
   next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
 
-  origin_ = HostPortPair(request_info_.url.HostNoBrackets(),
-                         request_info_.url.EffectiveIntPort());
-
   if (request_info_.load_flags & LOAD_BYPASS_PROXY) {
     proxy_info_.UseDirect();
     return OK;
   }
 
   return session_->proxy_service()->ResolveProxy(
       request_info_.url, &proxy_info_, &io_callback_, &pac_request_,
       net_log_);
 }
 
@@ skipping 99 matching lines @@
   if (proxy_info_.is_https()) {
     InitSSLConfig(proxy_info_.proxy_server().host_port_pair(),
                   &ssl_config_for_proxy);
   }
   if (using_ssl_) {
     InitSSLConfig(origin_, &ssl_config_);
   }
 
   if (IsPreconnecting()) {
     return ClientSocketPoolManager::PreconnectSocketsForHttpRequest(
-        request_info_,
+        origin_url_,
+        request_info_.referrer,
+        request_info_.extra_headers,
+        request_info_.load_flags,
+        request_info_.priority,
         session_,
         proxy_info_,
         ShouldForceSpdySSL(),
         want_spdy_over_npn,
         ssl_config_,
         ssl_config_for_proxy,
         net_log_,
         num_streams_);
   } else {
     return ClientSocketPoolManager::InitSocketHandleForHttpRequest(
-        request_info_,
+        origin_url_,
+        request_info_.referrer,
+        request_info_.extra_headers,
+        request_info_.load_flags,
+        request_info_.priority,
         session_,
         proxy_info_,
         ShouldForceSpdySSL(),
         want_spdy_over_npn,
         ssl_config_,
         ssl_config_for_proxy,
         net_log_,
         connection_.get(),
         &io_callback_);
   }
@@ skipping 457 matching lines @@
 bool HttpStreamFactoryImpl::Job::IsPreconnecting() const {
   DCHECK_GE(num_streams_, 0);
   return num_streams_ > 0;
 }
 
 bool HttpStreamFactoryImpl::Job::IsOrphaned() const {
   return !IsPreconnecting() && !request_;
 }
 
 }  // namespace net