Cleanup: Address some of the todos in net_log.h...

net/base/net_log.h

 // Copyright (c) 2010 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_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
 #include "net/base/net_log.h"
 
+class Value;
+
 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
 // SocketStream).
 //
 // To avoid needing to pass in the "source id" to the logging functions, NetLog
 // is usually accessed through a BoundNetLog, which will always pass in a
 // specific source ID.
 //
 // Note that NetLog is NOT THREADSAFE.
 //
 // ******** The NetLog (and associated logging) is a work in progress ********
 //
 // TODO(eroman): Remove the 'const' qualitifer from the BoundNetLog methods.
-// TODO(eroman): Remove the AddString() and AddStringLiteral() methods.
-//               These are a carry-over from old approach. Really, consumers
-//               should be calling AddEventWithParameters(), and passing a
-//               custom EventParameters* object that encapsulates all of the
-//               interesting state.
 // TODO(eroman): Remove NetLogUtil. Pretty printing should only be done from
 //               javascript, and should be very context-aware.
 // TODO(eroman): Move Capturing*NetLog to its own file. (And eventually remove
 //               all the consumers of it).
 // TODO(eroman): Make the DNS jobs emit directly into the NetLog.
 // TODO(eroman): Start a new Source each time URLRequest redirects
 //               (simpler to reason about each as a separate entity).
 // TODO(eroman): Add the URLRequest load flags to the start entry.
 
 class NetLog {
@@ skipping 37 matching lines @@
   };
 
   // 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 EventParameters : public base::RefCounted<EventParameters> {
    public:
     EventParameters() {}
     virtual ~EventParameters() {}
 
-    // Serializes the parameters to a string representation (this should be a
-    // lossless conversion).
-    virtual std::string ToString() const = 0;
+    // 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;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(EventParameters);
   };
 
   NetLog() {}
   virtual ~NetLog() {}
 
   // Emits an event to the log stream.
   //  |type| - The type of the event.
@@ skipping 55 matching lines @@
   // Convenience methods that call through to the NetLog, passing in the
   // currently bound source.
   void AddEvent(NetLog::EventType event_type) const;
   void AddEventWithParameters(NetLog::EventType event_type,
                               NetLog::EventParameters* params) const;
   bool HasListener() const;
   void BeginEvent(NetLog::EventType event_type) const;
   void BeginEventWithParameters(NetLog::EventType event_type,
                                 NetLog::EventParameters* params) const;
   void BeginEventWithString(NetLog::EventType event_type,
-                            const std::string& string) const;
-  void BeginEventWithInteger(NetLog::EventType event_type, int integer) const;
-  void AddEventWithInteger(NetLog::EventType event_type, int integer) const;
+                            const char* name, const std::string& value) const;
+  void BeginEventWithInteger(NetLog::EventType event_type,
+                             const char* name, int value) const;
+  void AddEventWithInteger(NetLog::EventType event_type,
+                           const char* name, int value) const;
+  void AddEventWithString(NetLog::EventType event_type,
+                          const char* name, const std::string& value) const;
   void EndEvent(NetLog::EventType event_type) const;
   void EndEventWithParameters(NetLog::EventType event_type,
                               NetLog::EventParameters* params) const;
-  void EndEventWithInteger(NetLog::EventType event_type, int integer) const;
-
-  // Deprecated: Don't add new dependencies that use these methods. Instead, use
-  // AddEventWithParameters().
-  void AddString(const std::string& string) const;
-  void AddStringLiteral(const char* literal) const;
+  void EndEventWithInteger(NetLog::EventType event_type,
+                           const char* name, int value) const;
 
   // Helper to create a BoundNetLog given a NetLog and a SourceType. Takes care
   // of creating a unique source ID, and handles the case of NULL net_log.
   static BoundNetLog Make(NetLog* net_log, NetLog::SourceType source_type);
 
   const NetLog::Source& source() const { return source_; }
   NetLog* net_log() const { return net_log_; }
 
  private:
   NetLog::Source source_;
   NetLog* net_log_;
 };
 
 // NetLogStringParameter is a subclass of EventParameters that encapsulates a
 // single std::string parameter.
 class NetLogStringParameter : public NetLog::EventParameters {
  public:
-  explicit NetLogStringParameter(const std::string& value);
+  // |name| must be a string literal.
+  NetLogStringParameter(const char* name, const std::string& value);
 
   const std::string& value() const {
     return value_;
   }
 
-  virtual std::string ToString() const {
-    return value_;
-  }
+  virtual Value* ToValue() const;
 
  private:
-  std::string value_;
+  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:
-  explicit NetLogIntegerParameter(int value) : value_(value) {}
+  // |name| must be a string literal.
+  NetLogIntegerParameter(const char* name, int value)
+      : name_(name), value_(value) {}
 
   int value() const {
     return value_;
   }
 
-  virtual std::string ToString() const;
+  virtual Value* ToValue() const;
 
  private:
+  const char* name_;
   const int value_;
 };
 
-// NetLogStringLiteralParameter is a subclass of EventParameters that
-// encapsulates a single string literal parameter.
-class NetLogStringLiteralParameter : public NetLog::EventParameters {
- public:
-  explicit NetLogStringLiteralParameter(const char* value) : value_(value) {}
-
-  const char* const value() const {
-    return value_;
-  }
-
-  virtual std::string ToString() const;
-
- private:
-  const char* const value_;
-};
-
-
 // CapturingNetLog is an implementation of NetLog that saves messages to a
 // bounded buffer.
 class CapturingNetLog : public NetLog {
  public:
   struct Entry {
     Entry(EventType type,
           const base::TimeTicks& time,
           Source source,
           EventPhase phase,
           EventParameters* extra_parameters)
@@ skipping 73 matching lines @@
  private:
   NetLog::Source source_;
   scoped_ptr<CapturingNetLog> capturing_net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(CapturingBoundNetLog);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NET_LOG_H_