Update NetLog in preparation for late binding of HttpStream jobs to requests.

net/http/http_stream_factory_impl_request.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_request.h"
 
 #include "base/logging.h"
 #include "base/stl_util-inl.h"
 #include "net/http/http_stream_factory_impl_job.h"
 
 namespace net {
 
 HttpStreamFactoryImpl::Request::Request(const GURL& url,
                                         HttpStreamFactoryImpl* factory,
-                                        HttpStreamRequest::Delegate* delegate)
+                                        HttpStreamRequest::Delegate* delegate,
+                                        const BoundNetLog& net_log)
     : url_(url),
       factory_(factory),
       delegate_(delegate),
+      net_log_(net_log),
       job_(NULL),
       completed_(false),
       was_alternate_protocol_available_(false),
       was_npn_negotiated_(false),
       using_spdy_(false) {
   DCHECK(factory_);
   DCHECK(delegate_);
+
+  net_log_.BeginEvent(NetLog::TYPE_HTTP_STREAM_REQUEST, NULL);
 }
 
 HttpStreamFactoryImpl::Request::~Request() {
+  net_log_.EndEvent(NetLog::TYPE_HTTP_STREAM_REQUEST, NULL);
+
   factory_->request_map_.erase(job_);
 
   // TODO(willchan): Remove this when we decouple requests and jobs.
   delete job_;
 
   RemoveRequestFromSpdySessionRequestMap();
 }
 
 void HttpStreamFactoryImpl::Request::SetSpdySessionKey(
     const HostPortProxyPair& spdy_session_key) {
   DCHECK(!spdy_session_key_.get());
   spdy_session_key_.reset(new HostPortProxyPair(spdy_session_key));
   RequestSet& request_set =
       factory_->spdy_session_request_map_[spdy_session_key];
   DCHECK(!ContainsKey(request_set, this));
   request_set.insert(this);
 }
 
 void HttpStreamFactoryImpl::Request::BindJob(HttpStreamFactoryImpl::Job* job) {
   DCHECK(job);
   DCHECK(!job_);
   job_ = job;
 }
 
 void HttpStreamFactoryImpl::Request::Complete(
     bool was_alternate_protocol_available,
     bool was_npn_negotiated,
-    bool using_spdy) {
+    bool using_spdy,
+    const NetLog::Source& job_source) {
   DCHECK(!completed_);
   completed_ = true;
   was_alternate_protocol_available_ = was_alternate_protocol_available;
   was_npn_negotiated_ = was_npn_negotiated;
   using_spdy_ = using_spdy;
+  net_log_.AddEvent(
+      NetLog::TYPE_HTTP_STREAM_REQUEST_BOUND_TO_JOB,
+      make_scoped_refptr(new NetLogSourceParameter(
+          "source_dependency", job_source)));
 }
 
 void HttpStreamFactoryImpl::Request::OnStreamReady(
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
     HttpStream* stream) {
   DCHECK(stream);
   DCHECK(completed_);
   delegate_->OnStreamReady(used_ssl_config, used_proxy_info, stream);
 }
@@ skipping 76 matching lines @@
         spdy_session_request_map[*spdy_session_key_];
     DCHECK(ContainsKey(request_set, this));
     request_set.erase(this);
     if (request_set.empty())
       spdy_session_request_map.erase(*spdy_session_key_);
     spdy_session_key_.reset();
   }
 }
 
 }  // namespace net