Turn libplatform into a component

include/libplatform/v8-tracing.h

 // Copyright 2016 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_LIBPLATFORM_V8_TRACING_H_
 #define V8_LIBPLATFORM_V8_TRACING_H_
 
 #include <fstream>
 #include <memory>
 #include <vector>
 
+#include "libplatform/libplatform-export.h"
+
 namespace v8 {
 namespace platform {
 namespace tracing {
 
 const int kTraceMaxNumArgs = 2;
 
-class TraceObject {
+class V8_PLATFORM_EXPORT TraceObject {
  public:
   union ArgValue {
     bool as_bool;
     uint64_t as_uint;
     int64_t as_int;
     double as_double;
     const void* as_pointer;
     const char* as_string;
   };
 
@@ skipping 51 matching lines @@
   int64_t ts_;
   int64_t tts_;
   uint64_t duration_;
   uint64_t cpu_duration_;
 
   // Disallow copy and assign
   TraceObject(const TraceObject&) = delete;
   void operator=(const TraceObject&) = delete;
 };
 
-class TraceWriter {
+class V8_PLATFORM_EXPORT TraceWriter {
  public:
   TraceWriter() {}
   virtual ~TraceWriter() {}
   virtual void AppendTraceEvent(TraceObject* trace_event) = 0;
   virtual void Flush() = 0;
 
   static TraceWriter* CreateJSONTraceWriter(std::ostream& stream);
 
  private:
   // Disallow copy and assign
   TraceWriter(const TraceWriter&) = delete;
   void operator=(const TraceWriter&) = delete;
 };
 
-class TraceBufferChunk {
+class V8_PLATFORM_EXPORT TraceBufferChunk {
  public:
   explicit TraceBufferChunk(uint32_t seq);
 
   void Reset(uint32_t new_seq);
   bool IsFull() const { return next_free_ == kChunkSize; }
   TraceObject* AddTraceEvent(size_t* event_index);
   TraceObject* GetEventAt(size_t index) { return &chunk_[index]; }
 
   uint32_t seq() const { return seq_; }
   size_t size() const { return next_free_; }
 
   static const size_t kChunkSize = 64;
 
  private:
   size_t next_free_ = 0;
   TraceObject chunk_[kChunkSize];
   uint32_t seq_;
 
   // Disallow copy and assign
   TraceBufferChunk(const TraceBufferChunk&) = delete;
   void operator=(const TraceBufferChunk&) = delete;
 };
 
-class TraceBuffer {
+class V8_PLATFORM_EXPORT TraceBuffer {
  public:
   TraceBuffer() {}
   virtual ~TraceBuffer() {}
 
   virtual TraceObject* AddTraceEvent(uint64_t* handle) = 0;
   virtual TraceObject* GetEventByHandle(uint64_t handle) = 0;
   virtual bool Flush() = 0;
 
   static const size_t kRingBufferChunks = 1024;
 
@@ skipping 15 matching lines @@
   // and we use it as a ring buffer during recording.
   RECORD_CONTINUOUSLY,
 
   // Record until the trace buffer is full, but with a huge buffer size.
   RECORD_AS_MUCH_AS_POSSIBLE,
 
   // Echo to console. Events are discarded.
   ECHO_TO_CONSOLE,
 };
 
-class TraceConfig {
+class V8_PLATFORM_EXPORT TraceConfig {
  public:
   typedef std::vector<std::string> StringList;
 
   static TraceConfig* CreateDefaultTraceConfig();
 
   TraceConfig()
       : enable_sampling_(false),
         enable_systrace_(false),
         enable_argument_filter_(false) {}
   TraceRecordMode GetTraceRecordMode() const { return record_mode_; }
@@ skipping 17 matching lines @@
   bool enable_systrace_ : 1;
   bool enable_argument_filter_ : 1;
   StringList included_categories_;
   StringList excluded_categories_;
 
   // Disallow copy and assign
   TraceConfig(const TraceConfig&) = delete;
   void operator=(const TraceConfig&) = delete;
 };
 
-class TracingController {
+class V8_PLATFORM_EXPORT TracingController {
  public:
   enum Mode { DISABLED = 0, RECORDING_MODE };
 
   // The pointer returned from GetCategoryGroupEnabledInternal() points to a
   // value with zero or more of the following bits. Used in this class only.
   // The TRACE_EVENT macros should only use the value as a bool.
   // These values must be in sync with macro values in TraceEvent.h in Blink.
   enum CategoryGroupEnabledFlags {
     // Category group enabled for the recording mode.
     ENABLED_FOR_RECORDING = 1 << 0,
@@ skipping 30 matching lines @@
   // Disallow copy and assign
   TracingController(const TracingController&) = delete;
   void operator=(const TracingController&) = delete;
 };
 
 }  // namespace tracing
 }  // namespace platform
 }  // namespace v8
 
 #endif  // V8_LIBPLATFORM_V8_TRACING_H_