NetLogEventParameter to Callback refactoring 5.

net/http/http_stream_factory_impl_job.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_stream_factory_impl_job.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 22 matching lines @@
 #include "net/socket/client_socket_pool_manager.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 {
 
-// 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));
-  }
-
-  virtual Value* ToValue() const;
-
- protected:
-  virtual ~HttpStreamJobParameters() {}
-
- 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 {
+// Returns parameters associated with the start of a HTTP stream job.
+Value* NetLogHttpStreamJobCallback(const GURL* original_url,
+                                   const GURL* url,
+                                   NetLog::LogLevel /* log_level */) {
   DictionaryValue* dict = new DictionaryValue();
-  dict->SetString("original_url", original_url_);
-  dict->SetString("url", url_);
+  dict->SetString("original_url", original_url->GetOrigin().spec());
+  dict->SetString("url", url->GetOrigin().spec());
   return dict;
 }
 
-// Parameters associated with the Proto (with NPN negotiation) of a HTTP stream.
-class HttpStreamProtoParameters : public NetLog::EventParameters {
- public:
-  static scoped_refptr<HttpStreamProtoParameters> Create(
-      const SSLClientSocket::NextProtoStatus status,
-      const std::string& proto,
-      const std::string& server_protos) {
-    return make_scoped_refptr(new HttpStreamProtoParameters(
-        status, proto, server_protos));
-  }
-
-  virtual Value* ToValue() const;
-
- protected:
-  virtual ~HttpStreamProtoParameters() {}
-
- private:
-  HttpStreamProtoParameters(const SSLClientSocket::NextProtoStatus status,
-                            const std::string& proto,
-                            const std::string& server_protos)
-      : status_(status),
-        proto_(proto),
-        server_protos_(server_protos) {
-  }
-
-  const SSLClientSocket::NextProtoStatus status_;
-  const std::string proto_;
-  const std::string server_protos_;
-};
-
-Value* HttpStreamProtoParameters::ToValue() const {
+// Returns parameters associated with the Proto (with NPN negotiation) of a HTTP
+// stream.
+Value* NetLogHttpStreamProtoCallback(
+    const SSLClientSocket::NextProtoStatus status,
+    const std::string* proto,
+    const std::string* server_protos,
+    NetLog::LogLevel /* log_level */) {
   DictionaryValue* dict = new DictionaryValue();
 
   dict->SetString("next_proto_status",
-                  SSLClientSocket::NextProtoStatusToString(status_));
-  dict->SetString("proto", proto_);
+                  SSLClientSocket::NextProtoStatusToString(status));
+  dict->SetString("proto", *proto);
   dict->SetString("server_protos",
-                  SSLClientSocket::ServerProtosToString(server_protos_));
+                  SSLClientSocket::ServerProtosToString(*server_protos));
   return dict;
 }
 
 HttpStreamFactoryImpl::Job::Job(HttpStreamFactoryImpl* stream_factory,
                                 HttpNetworkSession* session,
                                 const HttpRequestInfo& request_info,
                                 const SSLConfig& server_ssl_config,
                                 const SSLConfig& proxy_ssl_config,
                                 NetLog* net_log)
     : request_(NULL),
@@ skipping 20 matching lines @@
       protocol_negotiated_(kProtoUnknown),
       num_streams_(0),
       spdy_session_direct_(false),
       existing_available_pipeline_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(ptr_factory_(this)) {
   DCHECK(stream_factory);
   DCHECK(session);
 }
 
 HttpStreamFactoryImpl::Job::~Job() {
-  net_log_.EndEvent(NetLog::TYPE_HTTP_STREAM_JOB, NULL);
+  net_log_.EndEvent(NetLog::TYPE_HTTP_STREAM_JOB);
 
   // 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_)
@@ skipping 427 matching lines @@
 }
 
 int HttpStreamFactoryImpl::Job::DoStart() {
   int port = request_info_.url.EffectiveIntPort();
   origin_ = HostPortPair(request_info_.url.HostNoBrackets(), port);
   origin_url_ = HttpStreamFactory::ApplyHostMappingRules(
       request_info_.url, &origin_);
   http_pipelining_key_.reset(new HttpPipelinedHost::Key(origin_));
 
   net_log_.BeginEvent(NetLog::TYPE_HTTP_STREAM_JOB,
-                      HttpStreamJobParameters::Create(request_info_.url,
-                                                      origin_url_));
+                      base::Bind(&NetLogHttpStreamJobCallback,
+                                 &request_info_.url, &origin_url_));
 
   // Don't connect to restricted ports.
   if (!IsPortAllowedByDefault(port) && !IsPortAllowedByOverride(port)) {
     if (waiting_job_) {
       waiting_job_->Resume(this);
       waiting_job_ = NULL;
     }
     return ERR_UNSAFE_PORT;
   }
 
@@ skipping 221 matching lines @@
       was_npn_negotiated_ = true;
       std::string proto;
       std::string server_protos;
       SSLClientSocket::NextProtoStatus status =
           ssl_socket->GetNextProto(&proto, &server_protos);
       NextProto protocol_negotiated =
           SSLClientSocket::NextProtoFromString(proto);
       protocol_negotiated_ = protocol_negotiated;
       net_log_.AddEvent(
            NetLog::TYPE_HTTP_STREAM_REQUEST_PROTO,
-           HttpStreamProtoParameters::Create(status, proto, server_protos));
+           base::Bind(&NetLogHttpStreamProtoCallback,
+                      status, &proto, &server_protos));
       if (ssl_socket->was_spdy_negotiated())
         SwitchToSpdyMode();
     }
     if (ShouldForceSpdySSL())
       SwitchToSpdyMode();
   } else if (proxy_info_.is_https() && connection_->socket() &&
         result == OK) {
     ProxyClientSocket* proxy_socket =
       static_cast<ProxyClientSocket*>(connection_->socket());
     if (proxy_socket->IsUsingSpdy()) {
@@ skipping 455 matching lines @@
       (net::LOAD_MAIN_FRAME | net::LOAD_SUB_FRAME | net::LOAD_PREFETCH |
        net::LOAD_IS_DOWNLOAD)) {
     // Avoid pipelining resources that may be streamed for a long time.
     return false;
   }
   return stream_factory_->http_pipelined_host_pool_.IsKeyEligibleForPipelining(
       *http_pipelining_key_.get());
 }
 
 }  // namespace net