Rename BASE_API to BASE_EXPORT.

base/debug/trace_event.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.
 
 // Trace events are for tracking application performance.
 //
 // Events are issued against categories. Whereas LOG's
 // categories are statically defined, TRACE categories are created
 // implicitly with a string. For example:
 //   TRACE_EVENT_INSTANT0("MY_SUBSYSTEM", "SomeImportantEvent")
@@ skipping 284 matching lines @@
 // Phase indicates the nature of an event entry. E.g. part of a begin/end pair.
 enum TraceEventPhase {
   TRACE_EVENT_PHASE_BEGIN,
   TRACE_EVENT_PHASE_END,
   TRACE_EVENT_PHASE_INSTANT
 };
 
 // Simple union of values. This is much lighter weight than base::Value, which
 // requires dynamic allocation and a vtable. To keep the trace runtime overhead
 // low, we want constant size storage here.
-class BASE_API TraceValue {
+class BASE_EXPORT TraceValue {
  public:
   enum Type {
     TRACE_TYPE_UNDEFINED,
     TRACE_TYPE_BOOL,
     TRACE_TYPE_UINT,
     TRACE_TYPE_INT,
     TRACE_TYPE_DOUBLE,
     TRACE_TYPE_POINTER,
     TRACE_TYPE_STRING
   };
@@ skipping 119 matching lines @@
   TimeTicks timestamp_;
   TraceEventPhase phase_;
   const TraceCategory* category_;
   const char* name_;
   const char* arg_names_[kTraceMaxNumArgs];
   TraceValue arg_values_[kTraceMaxNumArgs];
   scoped_refptr<base::RefCountedString> parameter_copy_storage_;
 };
 
 
-class BASE_API TraceLog {
+class BASE_EXPORT TraceLog {
  public:
   static TraceLog* GetInstance();
 
   // Global enable of tracing. Currently enables all categories or not.
   // TODO(scheib): Replace with an Enable/DisableCategory() that
   // implicitly controls the global logging state.
   void SetEnabled(bool enabled);
   bool IsEnabled() { return enabled_; }
 
   float GetBufferPercentFull() const;
@@ skipping 64 matching lines @@
   OutputCallback output_callback_;
   BufferFullCallback buffer_full_callback_;
   std::vector<TraceEvent> logged_events_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceLog);
 };
 
 namespace internal {
 
 // Used by TRACE_EVENTx macro. Do not use directly.
-class BASE_API TraceEndOnScopeClose {
+class BASE_EXPORT TraceEndOnScopeClose {
  public:
   TraceEndOnScopeClose() : p_data_(NULL) {}
   ~TraceEndOnScopeClose() {
     if (p_data_)
       AddEventIfEnabled();
   }
 
   void Initialize(const TraceCategory* category,
                   const char* name);
 
  private:
   // Add the end event if the category is still enabled.
   void AddEventIfEnabled();
 
   // This Data struct workaround is to avoid initializing all the members
   // in Data during construction of this object, since this object is always
   // constructed, even when tracing is disabled. If the members of Data were
   // members of this class instead, compiler warnings occur about potential
   // uninitialized accesses.
   struct Data {
     const TraceCategory* category;
     const char* name;
   };
   Data* p_data_;
   Data data_;
 };
 
 // Used by TRACE_EVENTx macro. Do not use directly.
-class BASE_API TraceEndOnScopeCloseThreshold {
+class BASE_EXPORT TraceEndOnScopeCloseThreshold {
  public:
   TraceEndOnScopeCloseThreshold() : p_data_(NULL) {}
   ~TraceEndOnScopeCloseThreshold() {
     if (p_data_)
       AddEventIfEnabled();
   }
 
   // Called by macros only when tracing is enabled at the point when the begin
   // event is added.
   void Initialize(const TraceCategory* category,
@@ skipping 19 matching lines @@
   Data* p_data_;
   Data data_;
 };
 
 }  // namespace internal
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_TRACE_EVENT_H_