net: Add NET_API to net/base

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"
 
 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
 // 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.
 //
 // ******** The NetLog (and associated logging) is a work in progress ********
 //
 // TODO(eroman): Remove the 'const' qualitifer from the BoundNetLog methods.
 // TODO(eroman): Start a new Source each time URLRequest redirects
 //               (simpler to reason about each as a separate entity).
 
-class NetLog {
+class NET_API NetLog {
  public:
   enum EventType {
 #define EVENT_TYPE(label) TYPE_ ## label,
 #include "net/base/net_log_event_type_list.h"
 #undef EVENT_TYPE
   };
 
   // The 'phase' of an event trace (whether it marks the beginning or end
   // of an event.).
   enum EventPhase {
     PHASE_NONE,
     PHASE_BEGIN,
     PHASE_END,
   };
 
   // The "source" identifies the entity that generated the log message.
   enum SourceType {
 #define SOURCE_TYPE(label, value) SOURCE_ ## label = value,
 #include "net/base/net_log_source_type_list.h"
 #undef SOURCE_TYPE
   };
 
   // Identifies the entity that generated this log. The |id| field should
   // uniquely identify the source, and is used by log observers to infer
   // message groupings. Can use NetLog::NextID() to create unique IDs.
-  struct Source {
+  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;
 
     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 EventParameters : public base::RefCountedThreadSafe<EventParameters> {
+  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;
 
    private:
@@ skipping 64 matching lines @@
                                        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 BoundNetLog {
+class NET_API BoundNetLog {
  public:
   BoundNetLog() : net_log_(NULL) {}
 
   BoundNetLog(const NetLog::Source& source, NetLog* net_log)
       : source_(source), net_log_(net_log) {
   }
 
   // Convenience methods that call through to the NetLog, passing in the
   // currently bound source.
   void AddEntry(NetLog::EventType type,
@@ skipping 95 matching lines @@
 
   virtual 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 ScopedNetLogEvent {
+class NET_TEST ScopedNetLogEvent {

[wtc, 2011/05/16 20:55:17]

This kind of scoped class seems useful, so probably should
be NET_API?

[rvargas (doing something else), 2011/05/16 22:41:56]

The point is that nobody out of net uses this today. I just talked to Eric and
his opinion is to leave it as _TEST.

  public:
   ScopedNetLogEvent(const BoundNetLog& net_log,
                     NetLog::EventType event_type,
                     const scoped_refptr<NetLog::EventParameters>& params);
 
   ~ScopedNetLogEvent();
 
   // Sets the parameters that will logged on object destruction.  Can be called
   // at most once for a given ScopedNetLogEvent object.  If not called, the end
   // event will have no parameters.
   void SetEndEventParameters(
       const scoped_refptr<NetLog::EventParameters>& end_event_params);
 
   const BoundNetLog& net_log() const;
 
  private:
   BoundNetLog net_log_;
   const NetLog::EventType event_type_;
   scoped_refptr<NetLog::EventParameters> end_event_params_;
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NET_LOG_H_