Rename BASE_API to BASE_EXPORT.

base/metrics/stats_counters.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 BASE_METRICS_STATS_COUNTERS_H_
 #define BASE_METRICS_STATS_COUNTERS_H_
 #pragma once
 
 #include <string>
 
-#include "base/base_api.h"
+#include "base/base_export.h"
 #include "base/metrics/stats_table.h"
 #include "base/time.h"
 
 namespace base {
 
 // StatsCounters are dynamically created values which can be tracked in
 // the StatsTable.  They are designed to be lightweight to create and
 // easy to use.
 //
 // Since StatsCounters can be created dynamically by name, there is
@@ skipping 46 matching lines @@
 #else  // NDEBUG
 
 #define DSTATS_COUNTER(name, delta) do {} while (0)
 #define DSIMPLE_STATS_COUNTER(name) do {} while (0)
 #define DRATE_COUNTER(name, duration) do {} while (0)
 
 #endif  // NDEBUG
 
 //------------------------------------------------------------------------------
 // StatsCounter represents a counter in the StatsTable class.
-class BASE_API StatsCounter {
+class BASE_EXPORT StatsCounter {
  public:
   // Create a StatsCounter object.
   explicit StatsCounter(const std::string& name);
   virtual ~StatsCounter();
 
   // Sets the counter to a specific value.
   void Set(int value);
 
   // Increments the counter.
   void Increment() {
@@ skipping 33 matching lines @@
   // The counter id in the table.  We initialize to -1 (an invalid value)
   // and then cache it once it has been looked up.  The counter_id is
   // valid across all threads and processes.
   int32 counter_id_;
 };
 
 
 // A StatsCounterTimer is a StatsCounter which keeps a timer during
 // the scope of the StatsCounterTimer.  On destruction, it will record
 // its time measurement.
-class BASE_API StatsCounterTimer : protected StatsCounter {
+class BASE_EXPORT StatsCounterTimer : protected StatsCounter {
  public:
   // Constructs and starts the timer.
   explicit StatsCounterTimer(const std::string& name);
   virtual ~StatsCounterTimer();
 
   // Start the timer.
   void Start();
 
   // Stop the timer and record the results.
   void Stop();
 
   // Returns true if the timer is running.
   bool Running();
 
   // Accept a TimeDelta to increment.
   virtual void AddTime(TimeDelta time);
 
  protected:
   // Compute the delta between start and stop, in milliseconds.
   void Record();
 
   TimeTicks start_time_;
   TimeTicks stop_time_;
 };
 
 // A StatsRate is a timer that keeps a count of the number of intervals added so
 // that several statistics can be produced:
 //    min, max, avg, count, total
-class BASE_API StatsRate : public StatsCounterTimer {
+class BASE_EXPORT StatsRate : public StatsCounterTimer {
  public:
   // Constructs and starts the timer.
   explicit StatsRate(const std::string& name);
   virtual ~StatsRate();
 
   virtual void Add(int value);
 
  private:
   StatsCounter counter_;
   StatsCounter largest_add_;
@@ skipping 16 matching lines @@
     timer_.Stop();
   }
 
  private:
   T& timer_;
 };
 
 }  // namespace base
 
 #endif  // BASE_METRICS_STATS_COUNTERS_H_