Make net and ipc explicitly use the base namespace for 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/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
 
 namespace net {
 
 namespace {
 
 // Returns parameters for logging data transferred events. Includes number of
 // bytes transferred and, if the log level indicates bytes should be logged and
 // |byte_count| > 0, the bytes themselves.  The bytes are hex-encoded, since
 // base::StringValue only supports UTF-8.
-Value* BytesTransferredCallback(int byte_count,
-                                const char* bytes,
-                                NetLog::LogLevel log_level) {
-  DictionaryValue* dict = new DictionaryValue();
+base::Value* BytesTransferredCallback(int byte_count,
+                                      const char* bytes,
+                                      NetLog::LogLevel log_level) {
+  base::DictionaryValue* dict = new base::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* SourceEventParametersCallback(const NetLog::Source source,
-                                     NetLog::LogLevel /* log_level */) {
+base::Value* SourceEventParametersCallback(const NetLog::Source source,
+                                           NetLog::LogLevel /* log_level */) {
   if (!source.IsValid())
     return NULL;
-  DictionaryValue* event_params = new DictionaryValue();
+  base::DictionaryValue* event_params = new base::DictionaryValue();
   source.AddToEventParameters(event_params);
   return event_params;
 }
 
-Value* NetLogIntegerCallback(const char* name,
-                             int value,
-                             NetLog::LogLevel /* log_level */) {
-  DictionaryValue* event_params = new DictionaryValue();
+base::Value* NetLogIntegerCallback(const char* name,
+                                   int value,
+                                   NetLog::LogLevel /* log_level */) {
+  base::DictionaryValue* event_params = new base::DictionaryValue();
   event_params->SetInteger(name, value);
   return event_params;
 }
 
-Value* NetLogInt64Callback(const char* name,
-                           int64 value,
-                           NetLog::LogLevel /* log_level */) {
-  DictionaryValue* event_params = new DictionaryValue();
+base::Value* NetLogInt64Callback(const char* name,
+                                 int64 value,
+                                 NetLog::LogLevel /* log_level */) {
+  base::DictionaryValue* event_params = new base::DictionaryValue();
   event_params->SetString(name, base::Int64ToString(value));
   return event_params;
 }
 
-Value* NetLogStringCallback(const char* name,
-                            const std::string* value,
-                            NetLog::LogLevel /* log_level */) {
-  DictionaryValue* event_params = new DictionaryValue();
+base::Value* NetLogStringCallback(const char* name,
+                                  const std::string* value,
+                                  NetLog::LogLevel /* log_level */) {
+  base::DictionaryValue* event_params = new base::DictionaryValue();
   event_params->SetString(name, *value);
   return event_params;
 }
 
-Value* NetLogString16Callback(const char* name,
-                              const base::string16* value,
-                              NetLog::LogLevel /* log_level */) {
-  DictionaryValue* event_params = new DictionaryValue();
+base::Value* NetLogString16Callback(const char* name,
+                                    const base::string16* value,
+                                    NetLog::LogLevel /* log_level */) {
+  base::DictionaryValue* event_params = new base::DictionaryValue();
   event_params->SetString(name, *value);
   return event_params;
 }
 
 }  // namespace
 
 // LoadTimingInfo requires this be 0.
 const uint32 NetLog::Source::kInvalidId = 0;
 
 NetLog::Source::Source() : type(SOURCE_NONE), id(kInvalidId) {
 }
 
 NetLog::Source::Source(SourceType type, uint32 id) : type(type), id(id) {
 }
 
 bool NetLog::Source::IsValid() const {
   return id != kInvalidId;
 }
 
-void NetLog::Source::AddToEventParameters(DictionaryValue* event_params) const {
-  DictionaryValue* dict = new DictionaryValue();
+void NetLog::Source::AddToEventParameters(
+    base::DictionaryValue* event_params) const {
+  base::DictionaryValue* dict = new base::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);
 }
 
 // static
 bool NetLog::Source::FromEventParameters(Value* event_params, Source* source) {
-  DictionaryValue* dict;
-  DictionaryValue* source_dict;
+  base::DictionaryValue* dict;
+  base::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_LT(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());
+base::Value* NetLog::Entry::ToValue() const {
+  base::DictionaryValue* entry_dict(new base::DictionaryValue());
 
   entry_dict->SetString("time", TickCountToString(time_));
 
   // Set the entry source.
-  DictionaryValue* source_dict = new DictionaryValue();
+  base::DictionaryValue* source_dict = new base::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 {
+base::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,
     base::TimeTicks time,
@@ skipping 135 matching lines @@
 #include "net/base/net_log_event_type_list.h"
 #undef EVENT_TYPE
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 // static
 base::Value* NetLog::GetEventTypesAsValue() {
-  DictionaryValue* dict = new DictionaryValue();
+  base::DictionaryValue* dict = new base::DictionaryValue();
   for (int i = 0; i < EVENT_COUNT; ++i) {
     dict->SetInteger(EventTypeToString(static_cast<EventType>(i)), i);
   }
   return dict;
 }
 
 // static
 const char* NetLog::SourceTypeToString(SourceType source) {
   switch (source) {
 #define SOURCE_TYPE(label) case SOURCE_ ## label: return #label;
 #include "net/base/net_log_source_type_list.h"
 #undef SOURCE_TYPE
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 // static
 base::Value* NetLog::GetSourceTypesAsValue() {
-  DictionaryValue* dict = new DictionaryValue();
+  base::DictionaryValue* dict = new base::DictionaryValue();
   for (int i = 0; i < SOURCE_COUNT; ++i) {
     dict->SetInteger(SourceTypeToString(static_cast<SourceType>(i)), i);
   }
   return dict;
 }
 
 // static
 const char* NetLog::EventPhaseToString(EventPhase phase) {
   switch (phase) {
     case PHASE_BEGIN:
@@ skipping 148 matching lines @@
 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);
 }
 
 }  // namespace net