Rename BASE_API to BASE_EXPORT.

base/threading/simple_thread.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.
 
 // WARNING: You should probably be using Thread (thread.h) instead.  Thread is
 //          Chrome's message-loop based Thread abstraction, and if you are a
 //          thread running in the browser, there will likely be assumptions
 //          that your thread will have an associated message loop.
 //
 // This is a simple thread interface that backs to a native operating system
@@ skipping 27 matching lines @@
 //   // or Start again.
 
 #ifndef BASE_THREADING_SIMPLE_THREAD_H_
 #define BASE_THREADING_SIMPLE_THREAD_H_
 #pragma once
 
 #include <string>
 #include <queue>
 #include <vector>
 
-#include "base/base_api.h"
+#include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/threading/platform_thread.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 
 namespace base {
 
 // This is the base SimpleThread.  You can derive from it and implement the
 // virtual Run method, or you can use the DelegateSimpleThread interface.
-class BASE_API SimpleThread : public PlatformThread::Delegate {
+class BASE_EXPORT SimpleThread : public PlatformThread::Delegate {
  public:
-  class BASE_API Options {
+  class BASE_EXPORT Options {
    public:
     Options() : stack_size_(0) { }
     ~Options() { }
 
     // We use the standard compiler-supplied copy constructor.
 
     // A custom stack size, or 0 for the system default.
     void set_stack_size(size_t size) { stack_size_ = size; }
     size_t stack_size() const { return stack_size_; }
    private:
@@ skipping 42 matching lines @@
  private:
   const std::string name_prefix_;
   std::string name_;
   const Options options_;
   PlatformThreadHandle thread_;  // PlatformThread handle, invalid after Join!
   WaitableEvent event_;          // Signaled if Start() was ever called.
   PlatformThreadId tid_;         // The backing thread's id.
   bool joined_;                  // True if Join has been called.
 };
 
-class BASE_API DelegateSimpleThread : public SimpleThread {
+class BASE_EXPORT DelegateSimpleThread : public SimpleThread {
  public:
-  class BASE_API Delegate {
+  class BASE_EXPORT Delegate {
    public:
     Delegate() { }
     virtual ~Delegate() { }
     virtual void Run() = 0;
   };
 
   DelegateSimpleThread(Delegate* delegate,
                        const std::string& name_prefix);
   DelegateSimpleThread(Delegate* delegate,
                        const std::string& name_prefix,
                        const Options& options);
 
   virtual ~DelegateSimpleThread();
   virtual void Run();
  private:
   Delegate* delegate_;
 };
 
 // DelegateSimpleThreadPool allows you to start up a fixed number of threads,
 // and then add jobs which will be dispatched to the threads.  This is
 // convenient when you have a lot of small work that you want done
 // multi-threaded, but don't want to spawn a thread for each small bit of work.
 //
 // You just call AddWork() to add a delegate to the list of work to be done.
 // JoinAll() will make sure that all outstanding work is processed, and wait
 // for everything to finish.  You can reuse a pool, so you can call Start()
 // again after you've called JoinAll().
-class BASE_API DelegateSimpleThreadPool
+class BASE_EXPORT DelegateSimpleThreadPool
     : public DelegateSimpleThread::Delegate {
  public:
   typedef DelegateSimpleThread::Delegate Delegate;
 
   DelegateSimpleThreadPool(const std::string& name_prefix, int num_threads);
   virtual ~DelegateSimpleThreadPool();
 
   // Start up all of the underlying threads, and start processing work if we
   // have any.
   void Start();
@@ skipping 17 matching lines @@
   int num_threads_;
   std::vector<DelegateSimpleThread*> threads_;
   std::queue<Delegate*> delegates_;
   base::Lock lock_;            // Locks delegates_
   WaitableEvent dry_;    // Not signaled when there is no work to do.
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_SIMPLE_THREAD_H_