A pair of NetLog changes for ongoing refactoring:

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 22 matching lines @@
 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,
                              int value,
                              NetLog::LogLevel /* log_level */) {
   DictionaryValue* event_params = new DictionaryValue();
   event_params->SetInteger(name, value);
   return event_params;
 }
 
 Value* NetLogStringCallback(const char* name,
                             const std::string* value,
                             NetLog::LogLevel /* log_level */) {
   DictionaryValue* event_params = new DictionaryValue();
   event_params->SetString(name, *value);
   return event_params;
 }
 
+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 {
@@ skipping 198 matching lines @@
   return base::Bind(&NetLogIntegerCallback, name, value);
 }
 
 // static
 NetLog::ParametersCallback NetLog::StringCallback(const char* name,
                                                   const std::string* value) {
   DCHECK(value);
   return base::Bind(&NetLogStringCallback, name, value);
 }
 
+// static
+NetLog::ParametersCallback NetLog::StringCallback(const char* name,
+                                                  const string16* value) {
+  DCHECK(value);
+  return base::Bind(&NetLogString16Callback, name, value);
+}
+
 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;
@@ skipping 155 matching lines @@
 }
 
 Value* NetLogSourceParameter::ToValue() const {
   DictionaryValue* dict = new DictionaryValue();
   if (value_.is_valid())
     dict->Set(name_, value_.ToValue());
   return dict;
 }
 
 }  // namespace net