Turn libbase into a component

src/base/platform/condition-variable.h

 // Copyright 2013 the V8 project 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 V8_BASE_PLATFORM_CONDITION_VARIABLE_H_
 #define V8_BASE_PLATFORM_CONDITION_VARIABLE_H_
 
+#include "src/base/base-export.h"
 #include "src/base/lazy-instance.h"
 #include "src/base/platform/mutex.h"
 
 namespace v8 {
 namespace base {
 
 // Forward declarations.
 class ConditionVariableEvent;
 class TimeDelta;
 
 // -----------------------------------------------------------------------------
 // ConditionVariable
 //
 // This class is a synchronization primitive that can be used to block a thread,
 // or multiple threads at the same time, until:
 // - a notification is received from another thread,
 // - a timeout expires, or
 // - a spurious wakeup occurs
 // Any thread that intends to wait on a ConditionVariable has to acquire a lock
 // on a Mutex first. The |Wait()| and |WaitFor()| operations atomically release
 // the mutex and suspend the execution of the calling thread. When the condition
 // variable is notified, the thread is awakened, and the mutex is reacquired.
 
-class ConditionVariable final {
+class V8_BASE_EXPORT ConditionVariable final {
  public:
   ConditionVariable();
   ~ConditionVariable();
 
   // If any threads are waiting on this condition variable, calling
   // |NotifyOne()| unblocks one of the waiting threads.
   void NotifyOne();
 
   // Unblocks all threads currently waiting for this condition variable.
   void NotifyAll();
@@ skipping 68 matching lines @@
 typedef LazyStaticInstance<
     ConditionVariable, DefaultConstructTrait<ConditionVariable>,
     ThreadSafeInitOnceTrait>::type LazyConditionVariable;
 
 #define LAZY_CONDITION_VARIABLE_INITIALIZER LAZY_STATIC_INSTANCE_INITIALIZER
 
 }  // namespace base
 }  // namespace v8
 
 #endif  // V8_BASE_PLATFORM_CONDITION_VARIABLE_H_