(Finally) Remove NetLog::EventParameters.

net/base/net_log.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/base/net_log.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
@@ skipping 12 matching lines @@
 Value* BytesTransferredCallback(int byte_count,
                                 const char* bytes,
                                 NetLog::LogLevel log_level) {
   DictionaryValue* dict = new DictionaryValue();
   dict->SetInteger("byte_count", byte_count);
   if (NetLog::IsLoggingBytes(log_level) && byte_count > 0)
     dict->SetString("hex_encoded_bytes", base::HexEncode(bytes, byte_count));
   return dict;
 }
 
-Value* EventParametersCallback(
-    const scoped_refptr<NetLog::EventParameters>& params,
-    NetLog::LogLevel /* log_level */) {
-  if (!params.get())
-    return NULL;
-  return params->ToValue();
-}
-
 Value* SourceEventParametersCallback(const NetLog::Source source,
                                      NetLog::LogLevel /* log_level */) {
   if (!source.is_valid())
     return NULL;
   DictionaryValue* event_params = new DictionaryValue();
   source.AddToEventParameters(event_params);
   return event_params;
 }
 
 Value* NetLogIntegerCallback(const char* name,
@@ skipping 23 matching lines @@
 Value* NetLogString16Callback(const char* name,
                               const string16* value,
                               NetLog::LogLevel /* log_level */) {
   DictionaryValue* event_params = new DictionaryValue();
   event_params->SetString(name, *value);
   return event_params;
 }
 
 }  // namespace
 
-Value* NetLog::Source::ToValue() const {
-  DictionaryValue* dict = new DictionaryValue();
-  dict->SetInteger("type", static_cast<int>(type));
-  dict->SetInteger("id", static_cast<int>(id));
-  return dict;
-}
-
 void NetLog::Source::AddToEventParameters(DictionaryValue* event_params) const {
   DictionaryValue* dict = new DictionaryValue();
   dict->SetInteger("type", static_cast<int>(type));
   dict->SetInteger("id", static_cast<int>(id));
   event_params->Set("source_dependency", dict);
 }
 
 NetLog::ParametersCallback NetLog::Source::ToEventParametersCallback() const {
   return base::Bind(&SourceEventParametersCallback, *this);
 }
@@ skipping 95 matching lines @@
 
 void NetLog::AddGlobalEntry(
     EventType type,
     const NetLog::ParametersCallback& parameters_callback) {
   AddEntry(type,
            Source(net::NetLog::SOURCE_NONE, NextID()),
            net::NetLog::PHASE_NONE,
            &parameters_callback);
 }
 
-void NetLog::AddGlobalEntry(EventType type,
-                            const scoped_refptr<EventParameters>& params) {
-  ParametersCallback callback = base::Bind(&EventParametersCallback, params);
-  AddEntry(type,
-           Source(net::NetLog::SOURCE_NONE, NextID()),
-           net::NetLog::PHASE_NONE,
-           &callback);
-}
-
 // static
 std::string NetLog::TickCountToString(const base::TimeTicks& time) {
   int64 delta_time = (time - base::TimeTicks()).InMilliseconds();
   return base::Int64ToString(delta_time);
 }
 
 // static
 const char* NetLog::EventTypeToString(EventType event) {
   switch (event) {
 #define EVENT_TYPE(label) case TYPE_ ## label: return #label;
@@ skipping 149 matching lines @@
 void BoundNetLog::EndEvent(NetLog::EventType type) const {
   AddEntry(type, NetLog::PHASE_END);
 }
 
 void BoundNetLog::EndEvent(
     NetLog::EventType type,
     const NetLog::ParametersCallback& get_parameters) const {
   AddEntry(type, NetLog::PHASE_END, get_parameters);
 }
 
-void BoundNetLog::AddEntry(
-    NetLog::EventType type,
-    NetLog::EventPhase phase,
-    const scoped_refptr<NetLog::EventParameters>& params) const {
-  if (!net_log_)
-    return;
-  NetLog::ParametersCallback callback =
-      base::Bind(&EventParametersCallback, params);
-  net_log_->AddEntry(type, source_, phase, &callback);
-}
-
-void BoundNetLog::AddEvent(
-    NetLog::EventType event_type,
-    const scoped_refptr<NetLog::EventParameters>& params) const {
-  AddEntry(event_type, NetLog::PHASE_NONE, params);
-}
-
-void BoundNetLog::BeginEvent(
-    NetLog::EventType event_type,
-    const scoped_refptr<NetLog::EventParameters>& params) const {
-  AddEntry(event_type, NetLog::PHASE_BEGIN, params);
-}
-
-void BoundNetLog::EndEvent(
-    NetLog::EventType event_type,
-    const scoped_refptr<NetLog::EventParameters>& params) const {
-  AddEntry(event_type, NetLog::PHASE_END, params);
-}
-
 void BoundNetLog::AddEventWithNetErrorCode(NetLog::EventType event_type,
                                            int net_error) const {
   DCHECK_GT(0, net_error);
   DCHECK_NE(ERR_IO_PENDING, net_error);
   AddEvent(event_type, NetLog::IntegerCallback("net_error", net_error));
 }
 
 void BoundNetLog::EndEventWithNetErrorCode(NetLog::EventType event_type,
                                            int net_error) const {
   DCHECK_NE(ERR_IO_PENDING, net_error);
@@ skipping 27 matching lines @@
 // static
 BoundNetLog BoundNetLog::Make(NetLog* net_log,
                               NetLog::SourceType source_type) {
   if (!net_log)
     return BoundNetLog();
 
   NetLog::Source source(source_type, net_log->NextID());
   return BoundNetLog(source, net_log);
 }
 
-NetLogStringParameter::NetLogStringParameter(const char* name,
-                                             const std::string& value)
-    : name_(name), value_(value) {
-}
-
-NetLogStringParameter::~NetLogStringParameter() {
-}
-
-Value* NetLogIntegerParameter::ToValue() const {
-  DictionaryValue* dict = new DictionaryValue();
-  dict->SetInteger(name_, value_);
-  return dict;
-}
-
-Value* NetLogStringParameter::ToValue() const {
-  DictionaryValue* dict = new DictionaryValue();
-  dict->SetString(name_, value_);
-  return dict;
-}
-
-Value* NetLogSourceParameter::ToValue() const {
-  DictionaryValue* dict = new DictionaryValue();
-  if (value_.is_valid())
-    dict->Set(name_, value_.ToValue());
-  return dict;
-}
-
 }  // namespace net