Build WTF as dll in component build

Source/wtf/ThreadSpecific.h

 /*
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Jian Li <jianli@chromium.org>
  * Copyright (C) 2012 Patrick Gansterer <paroga@paroga.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 24 matching lines @@
  *     repeatedly if there is still non-NULL value associated with the function.
  *   @ In Windows native implementation, the destructor function will be called
  *     only once.
  * This semantic discrepancy does not impose any problem because nowhere in
  * WebKit the repeated call bahavior is utilized.
  */
 
 #ifndef WTF_ThreadSpecific_h
 #define WTF_ThreadSpecific_h
 
-#include <wtf/Noncopyable.h>
-#include <wtf/StdLibExtras.h>
+#include "wtf/Noncopyable.h"
+#include "wtf/StdLibExtras.h"
+#include "wtf/WTFExport.h"
 
 #if USE(PTHREADS)
 #include <pthread.h>
 #elif OS(WINDOWS)
 #include <windows.h>
 #endif
 
 namespace WTF {
 
 #if OS(WINDOWS)
 // ThreadSpecificThreadExit should be called each time when a thread is detached.
 // This is done automatically for threads created with WTF::createThread.
-void ThreadSpecificThreadExit();
+WTF_EXPORT void ThreadSpecificThreadExit();
 #endif
 
 template<typename T> class ThreadSpecific {
     WTF_MAKE_NONCOPYABLE(ThreadSpecific);
 public:
     ThreadSpecific();
     bool isSet(); // Useful as a fast check to see if this thread has set this value.
     T* operator->();
     operator T*();
     T& operator*();
 
 private:
 #if OS(WINDOWS)
-    friend void ThreadSpecificThreadExit();
+    WTF_EXPORT friend void ThreadSpecificThreadExit();
 #endif
 
     // Not implemented. It's technically possible to destroy a thread specific key, but one would need
     // to make sure that all values have been destroyed already (usually, that all threads that used it
     // have exited). It's unlikely that any user of this call will be in that situation - and having
     // a destructor defined can be confusing, given that it has such strong pre-requisites to work correctly.
     ~ThreadSpecific();
 
     T* get();
     void set(T*);
@@ skipping 73 matching lines @@
 // TLS_OUT_OF_INDEXES is not defined on WinCE.
 #ifndef TLS_OUT_OF_INDEXES
 #define TLS_OUT_OF_INDEXES 0xffffffff
 #endif
 
 // The maximum number of TLS keys that can be created. For simplification, we assume that:
 // 1) Once the instance of ThreadSpecific<> is created, it will not be destructed until the program dies.
 // 2) We do not need to hold many instances of ThreadSpecific<> data. This fixed number should be far enough.
 const int kMaxTlsKeySize = 256;
 
-long& tlsKeyCount();
-DWORD* tlsKeys();
+WTF_EXPORT long& tlsKeyCount();
+WTF_EXPORT DWORD* tlsKeys();
 
 class PlatformThreadSpecificKey;
 typedef PlatformThreadSpecificKey* ThreadSpecificKey;
 
-void threadSpecificKeyCreate(ThreadSpecificKey*, void (*)(void *));
-void threadSpecificKeyDelete(ThreadSpecificKey);
-void threadSpecificSet(ThreadSpecificKey, void*);
-void* threadSpecificGet(ThreadSpecificKey);
+WTF_EXPORT void threadSpecificKeyCreate(ThreadSpecificKey*, void (*)(void *));
+WTF_EXPORT void threadSpecificKeyDelete(ThreadSpecificKey);
+WTF_EXPORT void threadSpecificSet(ThreadSpecificKey, void*);
+WTF_EXPORT void* threadSpecificGet(ThreadSpecificKey);
 
 template<typename T>
 inline ThreadSpecific<T>::ThreadSpecific()
     : m_index(-1)
 {
     DWORD tlsKey = TlsAlloc();
     if (tlsKey == TLS_OUT_OF_INDEXES)
         CRASH();
 
     m_index = InterlockedIncrement(&tlsKeyCount()) - 1;
@@ skipping 82 matching lines @@
 
 template<typename T>
 inline T& ThreadSpecific<T>::operator*()
 {
     return *operator T*();
 }
 
 } // namespace WTF
 
 #endif // WTF_ThreadSpecific_h