Build WTF as dll in component build

Source/wtf/MemoryInstrumentation.h

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef MemoryInstrumentation_h
 #define MemoryInstrumentation_h
 
-#include <wtf/OwnPtr.h>
-#include <wtf/PassOwnPtr.h>
-#include <wtf/RefPtr.h>
+#include "wtf/OwnPtr.h"
+#include "wtf/PassOwnPtr.h"
+#include "wtf/RefPtr.h"
+#include "wtf/WTFExport.h"
 
 #define DEBUG_POINTER_INSTRUMENTATION 0
 
 namespace WTF {
 
 class MemoryClassInfo;
 class MemoryObjectInfo;
 class MemoryInstrumentation;
 
 typedef const char* MemoryObjectType;
@@ skipping 39 matching lines @@
     virtual bool visited(const void*) = 0;
     virtual bool checkCountedObject(const void*) = 0;
 
     virtual void reportNode(const MemoryObjectInfo&) = 0;
     virtual void reportEdge(const void* target, const char* edgeName, MemberType) = 0;
     virtual void reportLeaf(const MemoryObjectInfo&, const char* edgeName) = 0;
     virtual void reportBaseAddress(const void* base, const void* real) = 0;
     virtual int registerString(const char*) = 0;
 };
 
-class MemoryInstrumentation {
+class WTF_EXPORT MemoryInstrumentation {
 public:
     explicit MemoryInstrumentation(MemoryInstrumentationClient*);
     virtual ~MemoryInstrumentation();
 
     template <typename T> void addRootObject(const T& t, MemoryObjectType objectType = 0)
     {
         MemberTypeTraits<T>::addRootObject(this, t, objectType);
         processDeferredObjects();
     }
 
@@ skipping 29 matching lines @@
 
         template <typename U> static no deduce(U*, Helper<void (BaseMixin::*)(MemoryObjectInfo*) const, &U::reportMemoryUsage>* = 0);
         static yes deduce(...);
 
     public:
         static const bool result = sizeof(yes) == sizeof(deduce((Base*)(0)));
 
     };
 
 protected:
-    class WrapperBase {
+    class WTF_EXPORT WrapperBase {
     public:
         WrapperBase(MemoryObjectType, const void* pointer);
         virtual ~WrapperBase() { }
         void process(MemoryInstrumentation*);
         void processPointer(MemoryInstrumentation*, bool isRoot);
         void processRootObjectRef(MemoryInstrumentation*);
 
     protected:
         virtual void callReportMemoryUsage(MemoryObjectInfo*) = 0;
         const void* m_pointer;
@@ skipping 84 matching lines @@
 #if COMPILER(MSVC)
 template <typename T> struct FN {
     static char* fn() { return const_cast<char*>(__FUNCTION__); }
 };
 
 template <typename T> char* fn() { return FN<T>::fn(); }
 #else
 template <typename T> char* fn() { return const_cast<char*>(__PRETTY_FUNCTION__); }
 #endif
 
-class MemoryClassInfo {
+class WTF_EXPORT MemoryClassInfo {
 public:
     template<typename T>
     MemoryClassInfo(MemoryObjectInfo* memoryObjectInfo, const T* pointer, MemoryObjectType objectType = 0, size_t actualSize = sizeof(T))
         : m_memoryObjectInfo(memoryObjectInfo)
         , m_memoryInstrumentation(0)
         , m_objectType(0)
         , m_skipMembers(false)
     {
         init(pointer, fn<T>(), objectType, actualSize);
     }
@@ skipping 127 matching lines @@
 void reportMemoryUsage(const ParsedURL*, MemoryObjectInfo*);
 
 class URLString;
 void reportMemoryUsage(const URLString*, MemoryObjectInfo*);
 
 } // namespace WTF
 
 using WTF::MemoryReporterTag;
 
 #endif // !defined(MemoryInstrumentation_h)