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

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_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
+#include "base/values.h"
 #include "net/base/connection_type_histograms.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/base/ssl_cert_request_info.h"
 #include "net/http/http_basic_stream.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_proxy_client_socket.h"
 #include "net/http/http_proxy_client_socket_pool.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_stream_factory_impl_request.h"
@@ skipping 15 matching lines @@
   GURL::Replacements replacements;
   // new_sheme and new_port need to be in scope here because GURL::Replacements
   // references the memory contained by them directly.
   const std::string new_scheme = "https";
   const std::string new_port = base::IntToString(443);
   replacements.SetSchemeStr(new_scheme);
   replacements.SetPortStr(new_port);
   return original_url.ReplaceComponents(replacements);
 }
 
+// Parameters associated with the creation of a Job.
+class JobCreationParameters : public NetLog::EventParameters {

[mmenke, 2011/02/28 15:57:28]

This class isn't needed - see below.

+ public:
+  JobCreationParameters(const std::string& url) : url_(url) {}
+
+  virtual Value* ToValue() const {
+    DictionaryValue* dict = new DictionaryValue();
+    dict->SetString("url", url_);
+    return dict;
+  }
+
+ private:
+  const std::string url_;
+};
+
 }  // namespace
 
 HttpStreamFactoryImpl::Job::Job(HttpStreamFactoryImpl* stream_factory,
                                 HttpNetworkSession* session)
     : request_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_(this, &Job::OnIOComplete)),
       connection_(new ClientSocketHandle),
       session_(session),
       stream_factory_(stream_factory),
       next_state_(STATE_NONE),
@@ skipping 12 matching lines @@
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
   DCHECK(stream_factory);
   DCHECK(session);
   if (HttpStreamFactory::use_alternate_protocols())
     alternate_protocol_mode_ = kUnspecified;
   else
     alternate_protocol_mode_ = kDoNotUseAlternateProtocol;
 }
 
 HttpStreamFactoryImpl::Job::~Job() {
+  net_log_.EndEvent(NetLog::TYPE_HTTP_STREAM_JOB, NULL);
+
   // When we're in a partially constructed state, waiting for the user to
   // provide certificate handling information or authentication, we can't reuse
   // this stream at all.
   if (next_state_ == STATE_WAITING_USER_ACTION) {
     connection_->socket()->Disconnect();
     connection_.reset();
   }
 
   if (pac_request_)
     session_->proxy_service()->CancelPacRequest(pac_request_);
@@ skipping 68 matching lines @@
   DCHECK(connection_.get() && connection_->socket());
   SSLClientSocket* ssl_socket =
       static_cast<SSLClientSocket*>(connection_->socket());
   ssl_socket->GetSSLInfo(&ssl_info_);
 }
 
 void HttpStreamFactoryImpl::Job::OnStreamReadyCallback() {
   DCHECK(stream_.get());
   request_->Complete(was_alternate_protocol_available(),
                     was_npn_negotiated(),
-                    using_spdy());
+                    using_spdy(),
+                    net_log_.source());
   request_->OnStreamReady(ssl_config_, proxy_info_, stream_.release());
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnSpdySessionReadyCallback() {
   DCHECK(!stream_.get());
   DCHECK(using_spdy());
   DCHECK(new_spdy_session_);
   scoped_refptr<SpdySession> spdy_session = new_spdy_session_;
   new_spdy_session_ = NULL;
@@ skipping 190 matching lines @@
   return rv;
 }
 
 int HttpStreamFactoryImpl::Job::StartInternal(
     const HttpRequestInfo& request_info,
     const SSLConfig& ssl_config,
     const BoundNetLog& net_log) {
   CHECK_EQ(STATE_NONE, next_state_);
   request_info_ = request_info;
   ssl_config_ = ssl_config;
-  net_log_ = net_log;
+  net_log_ = BoundNetLog::Make(net_log.net_log(),
+                               NetLog::SOURCE_HTTP_STREAM_JOB);
+  net_log_.BeginEvent(NetLog::TYPE_HTTP_STREAM_JOB,
+                      make_scoped_refptr(new JobCreationParameters(
+                          request_info.url.GetOrigin().spec())));

[mmenke, 2011/02/28 15:57:28]

You can just use:
new NetLogStringParameter("url", request_info.url.GetOrigin().spec());

   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;
@@ skipping 731 matching lines @@
       break;
   }
 }
 
 bool HttpStreamFactoryImpl::Job::IsPreconnecting() const {
   DCHECK_GE(num_streams_, 0);
   return num_streams_ > 0;
 }
 
 }  // namespace net