Rename NET_API to NET_EXPORT, and rename NET_TEST to NET_EXPORT_PRIVATE.

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"
+#include "net/base/net_export.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
 // 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.
 //
-class NET_API NetLog {
+class NET_EXPORT 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 NET_API Source {
+  struct NET_EXPORT 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*.
     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
+  class NET_EXPORT 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 base::Value* ToValue() const = 0;
 
@@ skipping 10 matching lines @@
     // Log all events, but do not include the actual transferred bytes as
     // parameters for bytes sent/received events.
     LOG_ALL_BUT_BYTES,
 
     // Only log events which are cheap, and don't consume much memory.
     LOG_BASIC,
   };
 
   // An observer, that must ensure its own thread safety, for events
   // being added to a NetLog.
-  class NET_API ThreadSafeObserver {
+  class NET_EXPORT ThreadSafeObserver {
    public:
     // Constructs an observer that wants to see network events, with
     // the specified minimum event granularity.  A ThreadSafeObserver can only
     // observe a single NetLog at a time.
     //
     // Typical observers should specify LOG_BASIC.
     //
     // Observers that need to see the full granularity of events can
     // specify LOG_ALL. However doing so will have performance consequences.
     //
@@ skipping 86 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 NET_API BoundNetLog {
+class NET_EXPORT 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 81 matching lines @@
 
   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 {
+class NET_EXPORT 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 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 {
+class NET_EXPORT_PRIVATE ScopedNetLogEvent {
  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_