Base: A few more files using BASE_API (for base.dll)

base/threading/thread_collision_warner.h

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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_THREADING_THREAD_COLLISION_WARNER_H_
 #define BASE_THREADING_THREAD_COLLISION_WARNER_H_
 #pragma once
 
 #include <memory>
 
+#include "base/base_api.h"
 #include "base/atomicops.h"
 
 // A helper class alongside macros to be used to verify assumptions about thread
 // safety of a class.
 //
 // Example: Queue implementation non thread-safe but still usable if clients
 //          are synchronized somehow.
 //
 //          In this case the macro DFAKE_SCOPED_LOCK has to be
 //          used, it checks that if a thread is inside the push/pop then
@@ skipping 112 matching lines @@
 struct AsserterBase {
   virtual ~AsserterBase() {}
   virtual void warn() = 0;
 };
 
 struct DCheckAsserter : public AsserterBase {
   virtual ~DCheckAsserter() {}
   virtual void warn();
 };
 
-class ThreadCollisionWarner {
+class BASE_API ThreadCollisionWarner {
  public:
   // The parameter asserter is there only for test purpose
   ThreadCollisionWarner(AsserterBase* asserter = new DCheckAsserter())
       : valid_thread_id_(0),
         counter_(0),
         asserter_(asserter) {}
 
   ~ThreadCollisionWarner() {
     delete asserter_;
   }
 
   // This class is meant to be used through the macro
   // DFAKE_SCOPED_LOCK_THREAD_LOCKED
   // it doesn't leave the critical section, as opposed to ScopedCheck,
   // because the critical section being pinned is allowed to be used only
   // from one thread
-  class Check {
+  class BASE_API Check {
    public:
     explicit Check(ThreadCollisionWarner* warner)
         : warner_(warner) {
       warner_->EnterSelf();
     }
 
     ~Check() {}
 
    private:
     ThreadCollisionWarner* warner_;
 
     DISALLOW_COPY_AND_ASSIGN(Check);
   };
 
   // This class is meant to be used through the macro
   // DFAKE_SCOPED_LOCK
-  class ScopedCheck {
+  class BASE_API ScopedCheck {
    public:
     explicit ScopedCheck(ThreadCollisionWarner* warner)
         : warner_(warner) {
       warner_->Enter();
     }
 
     ~ScopedCheck() {
       warner_->Leave();
     }
 
    private:
     ThreadCollisionWarner* warner_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedCheck);
   };
 
   // This class is meant to be used through the macro
   // DFAKE_SCOPED_RECURSIVE_LOCK
-  class ScopedRecursiveCheck {
+  class BASE_API ScopedRecursiveCheck {
    public:
     explicit ScopedRecursiveCheck(ThreadCollisionWarner* warner)
         : warner_(warner) {
       warner_->EnterSelf();
     }
 
     ~ScopedRecursiveCheck() {
       warner_->Leave();
     }
 
@@ skipping 27 matching lines @@
   // Here only for class unit tests purpose, during the test I need to not
   // DCHECK but notify the collision with something else.
   AsserterBase* asserter_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadCollisionWarner);
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_THREAD_COLLISION_WARNER_H_