Make NetLog take in callbacks that return Values

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"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
 
 namespace net {
 
 namespace {
@@ skipping 26 matching lines @@
 }
 
 Value* NetLogBytesTransferredParameter::ToValue() const {
   DictionaryValue* dict = new DictionaryValue();
   dict->SetInteger("byte_count", byte_count_);
   if (has_bytes_ && byte_count_ > 0)
     dict->SetString("hex_encoded_bytes", hex_encoded_bytes_);
   return dict;
 }
 
+
+Value* EventParametersCallback(
+    const scoped_refptr<NetLog::EventParameters>& params,
+    NetLog::LogLevel) {
+  if (!params.get())
+    return NULL;
+  return params->ToValue();
+}
+
 }  // 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);
+}
+
+// static
+bool NetLog::Source::FromEventParameters(Value* event_params, Source* source) {
+  DictionaryValue* dict;
+  DictionaryValue* source_dict;
+  int source_id;
+  int source_type;
+  if (!event_params ||
+      !event_params->GetAsDictionary(&dict) ||
+      !dict->GetDictionary("source_dependency", &source_dict) ||
+      !source_dict->GetInteger("id", &source_id) ||
+      !source_dict->GetInteger("type", &source_type)) {
+    *source = Source();
+    return false;
+  }
+  DCHECK_LE(0, source_id);
+  DCHECK_LE(0, source_type);
+  DCHECK_LE(source_type, NetLog::SOURCE_COUNT);
+  *source = Source(static_cast<SourceType>(source_type), source_id);
+  return true;
+}
+
+Value* NetLog::Entry::ToValue() const {
+  DictionaryValue* entry_dict(new DictionaryValue());
+
+  entry_dict->SetString("time", TickCountToString(base::TimeTicks::Now()));
+
+  // Set the entry source.
+  DictionaryValue* source_dict = new DictionaryValue();
+  source_dict->SetInteger("id", source_.id);
+  source_dict->SetInteger("type", static_cast<int>(source_.type));
+  entry_dict->Set("source", source_dict);
+
+  // Set the event info.
+  entry_dict->SetInteger("type", static_cast<int>(type_));
+  entry_dict->SetInteger("phase", static_cast<int>(phase_));
+
+  // Set the event-specific parameters.
+  if (parameters_callback_) {
+    Value* value = parameters_callback_->Run(log_level_);
+    if (value)
+      entry_dict->Set("params", value);
+  }
+
+  return entry_dict;
+}
+
+Value* NetLog::Entry::ParametersToValue() const {
+  if (parameters_callback_)
+    return parameters_callback_->Run(log_level_);
+  return NULL;
+}
+
+NetLog::Entry::Entry(
+    EventType type,
+    Source source,
+    EventPhase phase,
+    const ParametersCallback* parameters_callback,
+    LogLevel log_level)
+    : type_(type),
+      source_(source),
+      phase_(phase),
+      parameters_callback_(parameters_callback),
+      log_level_(log_level) {
+};
+
+NetLog::Entry::~Entry() {
+}
+
 NetLog::ThreadSafeObserver::ThreadSafeObserver() : log_level_(LOG_BASIC),
                                                    net_log_(NULL) {
 }
 
 NetLog::ThreadSafeObserver::~ThreadSafeObserver() {
   // Make sure we aren't watching a NetLog on destruction.  Because the NetLog
   // may pass events to each observer on multiple threads, we cannot safely
   // stop watching a NetLog automatically from a parent class.
   DCHECK(!net_log_);
 }
 
 NetLog::LogLevel NetLog::ThreadSafeObserver::log_level() const {
   DCHECK(net_log_);
   return log_level_;
 }
 
 NetLog* NetLog::ThreadSafeObserver::net_log() const {
   return net_log_;
 }
 
 void NetLog::AddGlobalEntry(EventType type,
                             const scoped_refptr<EventParameters>& params) {
+  ParametersCallback callback = base::Bind(&EventParametersCallback, params);
   AddEntry(type,
-           Source(net::NetLog::SOURCE_NONE, this->NextID()),
+           Source(net::NetLog::SOURCE_NONE, NextID()),
            net::NetLog::PHASE_NONE,
-           params);
+           &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) {
@@ skipping 44 matching lines @@
       return "PHASE_BEGIN";
     case PHASE_END:
       return "PHASE_END";
     case PHASE_NONE:
       return "PHASE_NONE";
   }
   NOTREACHED();
   return NULL;
 }
 
-// static
-Value* NetLog::EntryToDictionaryValue(NetLog::EventType type,
-                                      const base::TimeTicks& time,
-                                      const NetLog::Source& source,
-                                      NetLog::EventPhase phase,
-                                      NetLog::EventParameters* params,
-                                      bool use_strings) {
-  DictionaryValue* entry_dict = new DictionaryValue();
-
-  entry_dict->SetString("time", TickCountToString(time));
-
-  // Set the entry source.
-  DictionaryValue* source_dict = new DictionaryValue();
-  source_dict->SetInteger("id", source.id);
-  if (!use_strings) {
-    source_dict->SetInteger("type", static_cast<int>(source.type));
-  } else {
-    source_dict->SetString("type",
-                           NetLog::SourceTypeToString(source.type));
-  }
-  entry_dict->Set("source", source_dict);
-
-  // Set the event info.
-  if (!use_strings) {
-    entry_dict->SetInteger("type", static_cast<int>(type));
-    entry_dict->SetInteger("phase", static_cast<int>(phase));
-  } else {
-    entry_dict->SetString("type", NetLog::EventTypeToString(type));
-    entry_dict->SetString("phase", NetLog::EventPhaseToString(phase));
-  }
-
-  // Set the event-specific parameters.
-  if (params)
-    entry_dict->Set("params", params->ToValue());
-
-  return entry_dict;
-}
-
 void NetLog::OnAddObserver(ThreadSafeObserver* observer, LogLevel log_level) {
   DCHECK(!observer->net_log_);
   observer->net_log_ = this;
   observer->log_level_ = log_level;
 }
 
 void NetLog::OnSetObserverLogLevel(ThreadSafeObserver* observer,
                                    LogLevel log_level) {
   DCHECK_EQ(this, observer->net_log_);
   observer->log_level_ = log_level;
 }
 
 void NetLog::OnRemoveObserver(ThreadSafeObserver* observer) {
   DCHECK_EQ(this, observer->net_log_);
   observer->net_log_ = NULL;
 }
 
+void NetLog::AddEntry(EventType type,
+                      const Source& source,
+                      EventPhase phase,
+                      const NetLog::ParametersCallback* parameters_callback) {
+  Entry entry(type, source, phase, parameters_callback, GetLogLevel());
+  OnAddEntry(entry);
+}
+
+void BoundNetLog::AddEntry(NetLog::EventType type, NetLog::EventPhase phase) {
+  if (!net_log_)
+    return;
+  net_log_->AddEntry(type, source_, phase, NULL);
+}
+
+void BoundNetLog::AddEntry(NetLog::EventType type,
+                           NetLog::EventPhase phase,
+                           const NetLog::ParametersCallback& get_parameters) {
+  if (!net_log_)
+    return;
+  net_log_->AddEntry(type, source_, phase, &get_parameters);
+}
+
+void BoundNetLog::AddEvent(NetLog::EventType type) {
+  AddEntry(type, NetLog::PHASE_NONE);
+}
+
+void BoundNetLog::AddEvent(NetLog::EventType type,
+                           const NetLog::ParametersCallback& get_parameters) {
+  AddEntry(type, NetLog::PHASE_NONE, get_parameters);
+}
+
+void BoundNetLog::BeginEvent(NetLog::EventType type) {
+  AddEntry(type, NetLog::PHASE_BEGIN);
+}
+
+void BoundNetLog::BeginEvent(NetLog::EventType type,
+                             const NetLog::ParametersCallback& get_parameters) {
+  AddEntry(type, NetLog::PHASE_BEGIN, get_parameters);
+}
+
+void BoundNetLog::EndEvent(NetLog::EventType type) {
+  AddEntry(type, NetLog::PHASE_END);
+}
+
+void BoundNetLog::EndEvent(NetLog::EventType type,
+                           const NetLog::ParametersCallback& get_parameters) {
+  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_)
-    net_log_->AddEntry(type, source_, phase, params);
+  if (!net_log_)
+    return;
+  NetLog::ParametersCallback callback =
+      base::Bind(&EventParametersCallback, params);
+  net_log_->AddEntry(type,

[eroman, 2012/05/22 22:08:06]

nit: perhaps this fits onto 1 line.

+                     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,
@@ skipping 108 matching lines @@
     const scoped_refptr<NetLog::EventParameters>& end_event_params) {
   DCHECK(!end_event_params_.get());
   end_event_params_ = end_event_params;
 }
 
 const BoundNetLog& ScopedNetLogEvent::net_log() const {
   return net_log_;
 }
 
 }  // namespace net