Move base/values.h into the base namespace.

net/base/net_log.h

 // Copyright (c) 2011 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.
 
 #ifndef NET_BASE_NET_LOG_H_
 #define NET_BASE_NET_LOG_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "net/base/net_api.h"
 
+namespace base {
 class Value;
+}
 
 namespace base {
 class TimeTicks;
 }
 
 namespace net {
 
 // NetLog is the destination for log messages generated by the network stack.
 // Each log message has a "source" field which identifies the specific entity
 // that generated the message (for example, which URLRequest or which
@@ skipping 30 matching lines @@
   // uniquely identify the source, and is used by log observers to infer
   // message groupings. Can use NetLog::NextID() to create unique IDs.
   struct NET_API Source {
     static const uint32 kInvalidId = 0;
 
     Source() : type(SOURCE_NONE), id(kInvalidId) {}
     Source(SourceType type, uint32 id) : type(type), id(id) {}
     bool is_valid() const { return id != kInvalidId; }
 
     // The caller takes ownership of the returned Value*.
-    Value* ToValue() const;
+    base::Value* ToValue() const;
 
     SourceType type;
     uint32 id;
   };
 
   // Base class for associating additional parameters with an event. Log
   // observers need to know what specific derivations of EventParameters a
   // particular EventType uses, in order to get at the individual components.
   class NET_API EventParameters
       : public base::RefCountedThreadSafe<EventParameters> {
    public:
     EventParameters() {}
     virtual ~EventParameters() {}
 
     // Serializes the parameters to a Value tree. This is intended to be a
     // lossless conversion, which is used to serialize the parameters to JSON.
     // The caller takes ownership of the returned Value*.
-    virtual Value* ToValue() const = 0;
+    virtual base::Value* ToValue() const = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(EventParameters);
   };
 
   // Specifies the granularity of events that should be emitted to the log.
   enum LogLevel {
     // Log everything possible, even if it is slow and memory expensive.
     // Includes logging of transferred bytes.
     LOG_ALL,
@@ skipping 43 matching lines @@
   static std::vector<EventType> GetAllEventTypes();
 
   // Returns a C-String symbolic name for |source_type|.
   static const char* SourceTypeToString(SourceType source_type);
 
   // Returns a C-String symbolic name for |event_phase|.
   static const char* EventPhaseToString(EventPhase event_phase);
 
   // Serializes the specified event to a DictionaryValue.
   // If |use_strings| is true, uses strings rather than numeric ids.
-  static Value* EntryToDictionaryValue(NetLog::EventType type,
-                                       const base::TimeTicks& time,
-                                       const NetLog::Source& source,
-                                       NetLog::EventPhase phase,
-                                       NetLog::EventParameters* params,
-                                       bool use_strings);
+  static base::Value* EntryToDictionaryValue(NetLog::EventType type,
+                                             const base::TimeTicks& time,
+                                             const NetLog::Source& source,
+                                             NetLog::EventPhase phase,
+                                             NetLog::EventParameters* params,
+                                             bool use_strings);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NetLog);
 };
 
 // Helper that binds a Source to a NetLog, and exposes convenience methods to
 // output log messages without needing to pass in the source.
 class NET_API BoundNetLog {
  public:
   BoundNetLog() : net_log_(NULL) {}
@@ skipping 61 matching lines @@
 class NetLogStringParameter : public NetLog::EventParameters {
  public:
   // |name| must be a string literal.
   NetLogStringParameter(const char* name, const std::string& value);
   virtual ~NetLogStringParameter();
 
   const std::string& value() const {
     return value_;
   }
 
-  virtual Value* ToValue() const;
+  virtual base::Value* ToValue() const;
 
  private:
   const char* const name_;
   const std::string value_;
 };
 
 // NetLogIntegerParameter is a subclass of EventParameters that encapsulates a
 // single integer parameter.
 class NetLogIntegerParameter : public NetLog::EventParameters {
  public:
   // |name| must be a string literal.
   NetLogIntegerParameter(const char* name, int value)
       : name_(name), value_(value) {}
 
   int value() const {
     return value_;
   }
 
-  virtual Value* ToValue() const;
+  virtual base::Value* ToValue() const;
 
  private:
   const char* name_;
   const int value_;
 };
 
 // NetLogSourceParameter is a subclass of EventParameters that encapsulates a
 // single NetLog::Source parameter.
 class NET_API NetLogSourceParameter : public NetLog::EventParameters {
  public:
   // |name| must be a string literal.
   NetLogSourceParameter(const char* name, const NetLog::Source& value)
       : name_(name), value_(value) {}
 
   const NetLog::Source& value() const {
     return value_;
   }
 
-  virtual Value* ToValue() const;
+  virtual base::Value* ToValue() const;
 
  private:
   const char* name_;
   const NetLog::Source value_;
 };
 
 // ScopedNetLogEvent logs a begin event on creation, and the corresponding end
 // event on destruction.
 class NET_TEST ScopedNetLogEvent {
  public:
@@ skipping 13 matching lines @@
 
  private:
   BoundNetLog net_log_;
   const NetLog::EventType event_type_;
   scoped_refptr<NetLog::EventParameters> end_event_params_;
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NET_LOG_H_