Rename BASE_API to BASE_EXPORT.

base/tracked_objects.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_TRACKED_OBJECTS_H_
 #define BASE_TRACKED_OBJECTS_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
-#include "base/base_api.h"
+#include "base/base_export.h"
 #include "base/synchronization/lock.h"
 #include "base/tracked.h"
 #include "base/threading/thread_local_storage.h"
 
 // TrackedObjects provides a database of stats about objects (generally Tasks)
 // that are tracked.  Tracking means their birth, death, duration, birth thread,
 // death thread, and birth place are recorded.  This data is carefully spread
 // across a series of objects so that the counts and times can be rapidly
 // updated without (usually) having to lock the data, and hence there is usually
 // very little contention caused by the tracking.  The data can be viewed via
@@ skipping 126 matching lines @@
 //
 class MessageLoop;
 
 
 namespace tracked_objects {
 
 //------------------------------------------------------------------------------
 // For a specific thread, and a specific birth place, the collection of all
 // death info (with tallies for each death thread, to prevent access conflicts).
 class ThreadData;
-class BASE_API BirthOnThread {
+class BASE_EXPORT BirthOnThread {
  public:
   explicit BirthOnThread(const Location& location);
 
   const Location location() const { return location_; }
   const ThreadData* birth_thread() const { return birth_thread_; }
 
  private:
   // File/lineno of birth.  This defines the essence of the type, as the context
   // of the birth (construction) often tell what the item is for.  This field
   // is const, and hence safe to access from any thread.
   const Location location_;
 
   // The thread that records births into this object.  Only this thread is
   // allowed to access birth_count_ (which changes over time).
   const ThreadData* birth_thread_;  // The thread this birth took place on.
 
   DISALLOW_COPY_AND_ASSIGN(BirthOnThread);
 };
 
 //------------------------------------------------------------------------------
 // A class for accumulating counts of births (without bothering with a map<>).
 
-class BASE_API Births: public BirthOnThread {
+class BASE_EXPORT Births: public BirthOnThread {
  public:
   explicit Births(const Location& location);
 
   int birth_count() const { return birth_count_; }
 
   // When we have a birth we update the count for this BirhPLace.
   void RecordBirth() { ++birth_count_; }
 
   // When a birthplace is changed (updated), we need to decrement the counter
   // for the old instance.
   void ForgetBirth() { --birth_count_; }  // We corrected a birth place.
 
   // Hack to quickly reset all counts to zero.
   void Clear() { birth_count_ = 0; }
 
  private:
   // The number of births on this thread for our location_.
   int birth_count_;
 
   DISALLOW_COPY_AND_ASSIGN(Births);
 };
 
 //------------------------------------------------------------------------------
 // Basic info summarizing multiple destructions of an object with a single
 // birthplace (fixed Location).  Used both on specific threads, and also used
 // in snapshots when integrating assembled data.
 
-class BASE_API DeathData {
+class BASE_EXPORT DeathData {
  public:
   // Default initializer.
   DeathData() : count_(0), square_duration_(0) {}
 
   // When deaths have not yet taken place, and we gather data from all the
   // threads, we create DeathData stats that tally the number of births without
   // a corrosponding death.
   explicit DeathData(int count) : count_(count), square_duration_(0) {}
 
   void RecordDeath(const base::TimeDelta& duration);
@@ skipping 20 matching lines @@
   int64 square_duration_;  // Sum of squares in milliseconds.
 };
 
 //------------------------------------------------------------------------------
 // A temporary collection of data that can be sorted and summarized.  It is
 // gathered (carefully) from many threads.  Instances are held in arrays and
 // processed, filtered, and rendered.
 // The source of this data was collected on many threads, and is asynchronously
 // changing.  The data in this instance is not asynchronously changing.
 
-class BASE_API Snapshot {
+class BASE_EXPORT Snapshot {
  public:
   // When snapshotting a full life cycle set (birth-to-death), use this:
   Snapshot(const BirthOnThread& birth_on_thread, const ThreadData& death_thread,
            const DeathData& death_data);
 
   // When snapshotting a birth, with no death yet, use this:
   Snapshot(const BirthOnThread& birth_on_thread, int count);
 
 
   const ThreadData* birth_thread() const { return birth_->birth_thread(); }
@@ skipping 15 matching lines @@
  private:
   const BirthOnThread* birth_;  // Includes Location and birth_thread.
   const ThreadData* death_thread_;
   DeathData death_data_;
 };
 //------------------------------------------------------------------------------
 // DataCollector is a container class for Snapshot and BirthOnThread count
 // items.  It protects the gathering under locks, so that it could be called via
 // Posttask on any threads, or passed to all the target threads in parallel.
 
-class BASE_API DataCollector {
+class BASE_EXPORT DataCollector {
  public:
   typedef std::vector<Snapshot> Collection;
 
   // Construct with a list of how many threads should contribute.  This helps us
   // determine (in the async case) when we are done with all contributions.
   DataCollector();
   ~DataCollector();
 
   // Add all stats from the indicated thread into our arrays.  This function is
   // mutex protected, and *could* be called from any threads (although current
@@ skipping 26 matching lines @@
 
   base::Lock accumulation_lock_;  // Protects access during accumulation phase.
 
   DISALLOW_COPY_AND_ASSIGN(DataCollector);
 };
 
 //------------------------------------------------------------------------------
 // Aggregation contains summaries (totals and subtotals) of groups of Snapshot
 // instances to provide printing of these collections on a single line.
 
-class BASE_API Aggregation: public DeathData {
+class BASE_EXPORT Aggregation: public DeathData {
  public:
   Aggregation();
   ~Aggregation();
 
   void AddDeathSnapshot(const Snapshot& snapshot);
   void AddBirths(const Births& births);
   void AddBirth(const BirthOnThread& birth);
   void AddBirthPlace(const Location& location);
   void Write(std::string* output) const;
   void Clear();
@@ skipping 11 matching lines @@
 
 //------------------------------------------------------------------------------
 // Comparator is a class that supports the comparison of Snapshot instances.
 // An instance is actually a list of chained Comparitors, that can provide for
 // arbitrary ordering.  The path portion of an about:tasks URL is translated
 // into such a chain, which is then used to order Snapshot instances in a
 // vector.  It orders them into groups (for aggregation), and can also order
 // instances within the groups (for detailed rendering of the instances in an
 // aggregation).
 
-class BASE_API Comparator {
+class BASE_EXPORT Comparator {
  public:
   // Selector enum is the token identifier for each parsed keyword, most of
   // which specify a sort order.
   // Since it is not meaningful to sort more than once on a specific key, we
   // use bitfields to accumulate what we have sorted on so far.
   enum Selector {
     // Sort orders.
     NIL = 0,
     BIRTH_THREAD = 1,
     DEATH_THREAD = 2,
@@ skipping 80 matching lines @@
   // when deciding if two items are in equivalent groups.  This flag tells us
   // to ignore the tiebreaker when doing Equivalent() testing.
   bool use_tiebreaker_for_sort_only_;
 };
 
 
 //------------------------------------------------------------------------------
 // For each thread, we have a ThreadData that stores all tracking info generated
 // on this thread.  This prevents the need for locking as data accumulates.
 
-class BASE_API ThreadData {
+class BASE_EXPORT ThreadData {
  public:
   typedef std::map<Location, Births*> BirthMap;
   typedef std::map<const Births*, DeathData> DeathMap;
 
   ThreadData();
   ~ThreadData();
 
   // Using Thread Local Store, find the current instance for collecting data.
   // If an instance does not exist, construct one (and remember it for use on
   // this thread.
@@ skipping 152 matching lines @@
 // Provide simple way to to start global tracking, and to tear down tracking
 // when done.  Note that construction and destruction of this object must be
 // done when running in  threaded mode (before spawning a lot of threads
 // for construction, and after shutting down all the threads for destruction).
 
 // To prevent grabbing thread local store resources time and again if someone
 // chooses to try to re-run the browser many times, we maintain global state and
 // only allow the tracking system to be started up at most once, and shutdown
 // at most once.  See bug 31344 for an example.
 
-class BASE_API AutoTracking {
+class BASE_EXPORT AutoTracking {
  public:
   AutoTracking() {
     if (state_ != kNeverBeenRun)
       return;
     ThreadData::StartTracking(true);
     state_ = kRunning;
   }
 
   ~AutoTracking() {
 #ifndef NDEBUG
@@ skipping 14 matching lines @@
   };
   static State state_;
 
   DISALLOW_COPY_AND_ASSIGN(AutoTracking);
 };
 
 
 }  // namespace tracked_objects
 
 #endif  // BASE_TRACKED_OBJECTS_H_