NetLogEventParameter to Callback refactoring 5.

net/http/http_pipelined_connection_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_connection_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "net/base/io_buffer.h"
 #include "net/http/http_pipelined_stream.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_body_drainer.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_stream_parser.h"
 #include "net/http/http_version.h"
 #include "net/socket/client_socket_handle.h"
 
 using base::DictionaryValue;
 using base::Value;
 
 namespace net {
 
 namespace {
 
-class ReceivedHeadersParameters : public NetLog::EventParameters {
- public:
-  ReceivedHeadersParameters(const NetLog::Source& source,
-                            const std::string& feedback)
-      : source_(source), feedback_(feedback) {}
+Value* NetLogReceivedHeadersCallback(const NetLog::Source& source,
+                                     const std::string* feedback,
+                                     NetLog::LogLevel /* log_level */) {
+  DictionaryValue* dict = new DictionaryValue;
+  source.AddToEventParameters(dict);
+  dict->SetString("feedback", *feedback);
+  return dict;
+}
 
-  virtual Value* ToValue() const OVERRIDE {
-    DictionaryValue* dict = new DictionaryValue;
-    dict->Set("source_dependency", source_.ToValue());
-    dict->SetString("feedback", feedback_);
-    return dict;
-  }
+Value* NetLogStreamClosedCallback(const NetLog::Source& source,
+                                  bool not_reusable,
+                                  NetLog::LogLevel /* log_level */) {
+  DictionaryValue* dict = new DictionaryValue;
+  source.AddToEventParameters(dict);
+  dict->SetBoolean("not_reusable", not_reusable);
+  return dict;
+}
 
- protected:
-  virtual ~ReceivedHeadersParameters() {}
-
- private:
-  const NetLog::Source source_;
-  const std::string feedback_;
-};
-
-class StreamClosedParameters : public NetLog::EventParameters {
- public:
-  StreamClosedParameters(const NetLog::Source& source, bool not_reusable)
-      : source_(source), not_reusable_(not_reusable) {}
-
-  virtual Value* ToValue() const OVERRIDE {
-    DictionaryValue* dict = new DictionaryValue;
-    dict->Set("source_dependency", source_.ToValue());
-    dict->SetBoolean("not_reusable", not_reusable_);
-    return dict;
-  }
-
- protected:
-  virtual ~StreamClosedParameters() {}
-
- private:
-  const NetLog::Source source_;
-  const bool not_reusable_;
-};
+Value* NetLogHostPortPairCallback(const HostPortPair* host_port_pair,
+                                  NetLog::LogLevel /* log_level */) {
+  DictionaryValue* dict = new DictionaryValue;
+  dict->SetString("host_and_port", host_port_pair->ToString());
+  return dict;
+}
 
 }  // anonymous namespace
 
 HttpPipelinedConnectionImpl::HttpPipelinedConnectionImpl(
     ClientSocketHandle* connection,
     HttpPipelinedConnection::Delegate* delegate,
     const HostPortPair& origin,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
     const BoundNetLog& net_log,
@@ skipping 14 matching lines @@
       completed_one_request_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       send_next_state_(SEND_STATE_NONE),
       send_still_on_call_stack_(false),
       read_next_state_(READ_STATE_NONE),
       active_read_id_(0),
       read_still_on_call_stack_(false) {
   CHECK(connection_.get());
   net_log_.BeginEvent(
       NetLog::TYPE_HTTP_PIPELINED_CONNECTION,
-      make_scoped_refptr(new NetLogStringParameter(
-          "host_and_port", origin.ToString())));
+      base::Bind(&NetLogHostPortPairCallback, &origin));
 }
 
 HttpPipelinedConnectionImpl::~HttpPipelinedConnectionImpl() {
   CHECK_EQ(depth(), 0);
   CHECK(stream_info_map_.empty());
   CHECK(pending_send_request_queue_.empty());
   CHECK(request_order_.empty());
   CHECK_EQ(send_next_state_, SEND_STATE_NONE);
   CHECK_EQ(read_next_state_, READ_STATE_NONE);
   CHECK(!active_send_request_.get());
   CHECK(!active_read_id_);
   if (!usable_) {
     connection_->socket()->Disconnect();
   }
   connection_->Reset();
-  net_log_.EndEvent(NetLog::TYPE_HTTP_PIPELINED_CONNECTION, NULL);
+  net_log_.EndEvent(NetLog::TYPE_HTTP_PIPELINED_CONNECTION);
 }
 
 HttpPipelinedStream* HttpPipelinedConnectionImpl::CreateNewStream() {
   int pipeline_id = next_pipeline_id_++;
   CHECK(pipeline_id);
   HttpPipelinedStream* stream = new HttpPipelinedStream(this, pipeline_id);
   stream_info_map_.insert(std::make_pair(pipeline_id, StreamInfo()));
   return stream;
 }
 
@@ skipping 156 matching lines @@
 
 int HttpPipelinedConnectionImpl::DoSendComplete(int result) {
   CHECK(active_send_request_.get());
   CHECK_EQ(STREAM_SENDING,
            stream_info_map_[active_send_request_->pipeline_id].state);
 
   request_order_.push(active_send_request_->pipeline_id);
   stream_info_map_[active_send_request_->pipeline_id].state = STREAM_SENT;
   net_log_.AddEvent(
       NetLog::TYPE_HTTP_PIPELINED_CONNECTION_SENT_REQUEST,
-      make_scoped_refptr(new NetLogSourceParameter(
-          "source_dependency",
-          stream_info_map_[active_send_request_->pipeline_id].source)));
+      stream_info_map_[active_send_request_->pipeline_id].source.
+          ToEventParametersCallback());
 
   if (result == ERR_SOCKET_NOT_CONNECTED && completed_one_request_) {
     result = ERR_PIPELINE_EVICTION;
   }
   if (result < OK) {
     usable_ = false;
   }
 
   if (!send_still_on_call_stack_) {
     QueueUserCallback(active_send_request_->pipeline_id,
@@ skipping 233 matching lines @@
   }
   read_next_state_ = READ_STATE_NONE;
   return result;
 }
 
 void HttpPipelinedConnectionImpl::Close(int pipeline_id,
                                         bool not_reusable) {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   net_log_.AddEvent(
       NetLog::TYPE_HTTP_PIPELINED_CONNECTION_STREAM_CLOSED,
-      make_scoped_refptr(new StreamClosedParameters(
-          stream_info_map_[pipeline_id].source, not_reusable)));
+      base::Bind(&NetLogStreamClosedCallback,
+                 stream_info_map_[pipeline_id].source, not_reusable));
   switch (stream_info_map_[pipeline_id].state) {
     case STREAM_CREATED:
       stream_info_map_[pipeline_id].state = STREAM_UNUSED;
       break;
 
     case STREAM_BOUND:
       stream_info_map_[pipeline_id].state = STREAM_CLOSED;
       break;
 
     case STREAM_SENDING:
@@ skipping 191 matching lines @@
       feedback_str = "AUTHENTICATION_REQUIRED";
       break;
 
     default:
       NOTREACHED();
       feedback_str = "UNKNOWN";
       break;
   }
   net_log_.AddEvent(
       NetLog::TYPE_HTTP_PIPELINED_CONNECTION_RECEIVED_HEADERS,
-      make_scoped_refptr(new ReceivedHeadersParameters(
-          stream_info_map_[pipeline_id].source, feedback_str)));
+      base::Bind(&NetLogReceivedHeadersCallback,
+                 stream_info_map_[pipeline_id].source, &feedback_str));
   delegate_->OnPipelineFeedback(this, feedback);
 }
 
 void HttpPipelinedConnectionImpl::QueueUserCallback(
     int pipeline_id, const CompletionCallback& callback, int rv,
     const tracked_objects::Location& from_here) {
   CHECK(stream_info_map_[pipeline_id].pending_user_callback.is_null());
   stream_info_map_[pipeline_id].pending_user_callback = callback;
   MessageLoop::current()->PostTask(
       from_here,
@@ skipping 55 matching lines @@
 }
 
 HttpPipelinedConnectionImpl::StreamInfo::StreamInfo()
     : state(STREAM_CREATED) {
 }
 
 HttpPipelinedConnectionImpl::StreamInfo::~StreamInfo() {
 }
 
 }  // namespace net