libv8 7.3.492.27.1-universal-darwin16

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4b473ad6e4bbea0f1b9d70e8fabdd0db0ca95d82c3096e336fdedd6df3da4e5f
+  data.tar.gz: 2993e30d027e6a3dfa589b32369cf89f6f3bf916c194af2025b9685cbe994360
+SHA512:
+  metadata.gz: c44a0fd78cb1b4aecebc88f3636dd634d708e18d560a629630c07516a05e2d1e5ab3791c5bc828f4ff8d6b6bd438bf4c01f48fc6216565b4b05d5c07eaaca64c
+  data.tar.gz: 01beabe417ca925484010680cc57f097efe2be61b9cf98ec333cd8b7e8d9658c10599136b9084417794df062ef08f1d9bf8573c795ad0fc473025f6b71d62ec4

data/ext/libv8/.location.yml

@@ -0,0 +1 @@
+--- !ruby/object:Libv8::Location::Vendor {}

data/ext/libv8/location.rb

@@ -0,0 +1,89 @@
+require 'yaml'
+require 'pathname'
+require File.expand_path '../paths', __FILE__
+
+module Libv8
+  class Location
+    def install!
+      File.open(Pathname(__FILE__).dirname.join('.location.yml'), "w") do |f|
+        f.write self.to_yaml
+      end
+      return 0
+    end
+
+    def self.load!
+      File.open(Pathname(__FILE__).dirname.join('.location.yml')) do |f|
+        YAML.load f
+      end
+    end
+
+    class Vendor < Location
+      def install!
+        require File.expand_path '../builder', __FILE__
+        builder = Libv8::Builder.new
+        exit_status = builder.build_libv8!
+        super if exit_status == 0
+        verify_installation!
+        return exit_status
+      end
+
+      def configure(context = MkmfContext.new)
+        context.incflags.insert 0, Libv8::Paths.include_paths.map{ |p| "-I#{p}" }.join(" ")  + " "
+        context.ldflags.insert 0, Libv8::Paths.object_paths.join(" ") + " "
+      end
+
+      def verify_installation!
+        include_paths = Libv8::Paths.include_paths
+        unless include_paths.detect { |p| Pathname(p).join('v8.h').exist? }
+          fail HeaderNotFound, "Unable to locate 'v8.h' in the libv8 header paths: #{include_paths.inspect}"
+        end
+        Libv8::Paths.object_paths.each do |p|
+          fail ArchiveNotFound, p unless File.exist? p
+        end
+      end
+
+      class HeaderNotFound < StandardError; end
+
+      class ArchiveNotFound < StandardError
+        def initialize(filename)
+          super "libv8 did not install properly, expected binary v8 archive '#{filename}'to exist, but it was not found"
+        end
+      end
+    end
+
+    class System < Location
+      def configure(context = MkmfContext.new)
+        context.send(:dir_config, 'v8')
+        context.send(:find_header, 'v8.h') or fail NotFoundError
+        context.send(:find_header, 'libplatform/libplatform.h') or fail NotFoundError
+        context.send(:have_library, 'v8') or fail NotFoundError
+      end
+
+      class NotFoundError < StandardError
+        def initialize(*args)
+          super(<<-EOS)
+By using --with-system-v8, you have chosen to use the version
+of V8 found on your system and *not* the one that is bundled with
+the libv8 rubygem.
+
+However, your system version of v8 could not be located.
+
+Please make sure your system version of v8 that is compatible
+with #{Libv8::VERSION} installed. You may need to use the
+--with-v8-dir option if it is installed in a non-standard location
+EOS
+        end
+      end
+    end
+
+    class MkmfContext
+      def incflags
+        $INCFLAGS
+      end
+
+      def ldflags
+        $LDFLAGS
+      end
+    end
+  end
+end

data/ext/libv8/paths.rb

@@ -0,0 +1,28 @@
+require 'rbconfig'
+require 'shellwords'
+
+module Libv8
+  module Paths
+    module_function
+
+    def include_paths
+      [Shellwords.escape(File.join(vendored_source_path, 'include'))]
+    end
+
+    def object_paths
+      [Shellwords.escape(File.join(vendored_source_path,
+                                   'out.gn',
+                                   'libv8',
+                                   'obj',
+                                   "libv8_monolith.#{config['LIBEXT']}"))]
+    end
+
+    def config
+      RbConfig::MAKEFILE_CONFIG
+    end
+
+    def vendored_source_path
+      File.expand_path "../../../vendor/v8", __FILE__
+    end
+  end
+end

data/lib/libv8.rb

@@ -0,0 +1,9 @@
+require 'libv8/version'
+require 'libv8/location'
+
+module Libv8
+  def self.configure_makefile
+    location = Location.load!
+    location.configure
+  end
+end

data/lib/libv8/version.rb

@@ -0,0 +1,3 @@
+module Libv8
+  VERSION = "7.3.492.27.1"
+end

data/vendor/v8/include/libplatform/libplatform-export.h

@@ -0,0 +1,29 @@
+// 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_LIBPLATFORM_EXPORT_H_
+#define V8_LIBPLATFORM_LIBPLATFORM_EXPORT_H_
+
+#if defined(_WIN32)
+
+#ifdef BUILDING_V8_PLATFORM_SHARED
+#define V8_PLATFORM_EXPORT __declspec(dllexport)
+#elif USING_V8_PLATFORM_SHARED
+#define V8_PLATFORM_EXPORT __declspec(dllimport)
+#else
+#define V8_PLATFORM_EXPORT
+#endif  // BUILDING_V8_PLATFORM_SHARED
+
+#else  // defined(_WIN32)
+
+// Setup for Linux shared library export.
+#ifdef BUILDING_V8_PLATFORM_SHARED
+#define V8_PLATFORM_EXPORT __attribute__((visibility("default")))
+#else
+#define V8_PLATFORM_EXPORT
+#endif
+
+#endif  // defined(_WIN32)
+
+#endif  // V8_LIBPLATFORM_LIBPLATFORM_EXPORT_H_

data/vendor/v8/include/libplatform/libplatform.h

@@ -0,0 +1,91 @@
+// Copyright 2014 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_LIBPLATFORM_H_
+#define V8_LIBPLATFORM_LIBPLATFORM_H_
+
+#include "libplatform/libplatform-export.h"
+#include "libplatform/v8-tracing.h"
+#include "v8-platform.h"  // NOLINT(build/include)
+#include "v8config.h"     // NOLINT(build/include)
+
+namespace v8 {
+namespace platform {
+
+enum class IdleTaskSupport { kDisabled, kEnabled };
+enum class InProcessStackDumping { kDisabled, kEnabled };
+
+enum class MessageLoopBehavior : bool {
+  kDoNotWait = false,
+  kWaitForWork = true
+};
+
+/**
+ * Returns a new instance of the default v8::Platform implementation.
+ *
+ * The caller will take ownership of the returned pointer. |thread_pool_size|
+ * is the number of worker threads to allocate for background jobs. If a value
+ * of zero is passed, a suitable default based on the current number of
+ * processors online will be chosen.
+ * If |idle_task_support| is enabled then the platform will accept idle
+ * tasks (IdleTasksEnabled will return true) and will rely on the embedder
+ * calling v8::platform::RunIdleTasks to process the idle tasks.
+ * If |tracing_controller| is nullptr, the default platform will create a
+ * v8::platform::TracingController instance and use it.
+ */
+V8_PLATFORM_EXPORT std::unique_ptr<v8::Platform> NewDefaultPlatform(
+    int thread_pool_size = 0,
+    IdleTaskSupport idle_task_support = IdleTaskSupport::kDisabled,
+    InProcessStackDumping in_process_stack_dumping =
+        InProcessStackDumping::kDisabled,
+    std::unique_ptr<v8::TracingController> tracing_controller = {});
+
+V8_PLATFORM_EXPORT V8_DEPRECATED(
+    "Use NewDefaultPlatform instead",
+    v8::Platform* CreateDefaultPlatform(
+        int thread_pool_size = 0,
+        IdleTaskSupport idle_task_support = IdleTaskSupport::kDisabled,
+        InProcessStackDumping in_process_stack_dumping =
+            InProcessStackDumping::kDisabled,
+        v8::TracingController* tracing_controller = nullptr));
+
+/**
+ * Pumps the message loop for the given isolate.
+ *
+ * The caller has to make sure that this is called from the right thread.
+ * Returns true if a task was executed, and false otherwise. Unless requested
+ * through the |behavior| parameter, this call does not block if no task is
+ * pending. The |platform| has to be created using |NewDefaultPlatform|.
+ */
+V8_PLATFORM_EXPORT bool PumpMessageLoop(
+    v8::Platform* platform, v8::Isolate* isolate,
+    MessageLoopBehavior behavior = MessageLoopBehavior::kDoNotWait);
+
+/**
+ * Runs pending idle tasks for at most |idle_time_in_seconds| seconds.
+ *
+ * The caller has to make sure that this is called from the right thread.
+ * This call does not block if no task is pending. The |platform| has to be
+ * created using |NewDefaultPlatform|.
+ */
+V8_PLATFORM_EXPORT void RunIdleTasks(v8::Platform* platform,
+                                     v8::Isolate* isolate,
+                                     double idle_time_in_seconds);
+
+/**
+ * Attempts to set the tracing controller for the given platform.
+ *
+ * The |platform| has to be created using |NewDefaultPlatform|.
+ *
+ */
+V8_PLATFORM_EXPORT V8_DEPRECATE_SOON(
+    "Access the DefaultPlatform directly",
+    void SetTracingController(
+        v8::Platform* platform,
+        v8::platform::tracing::TracingController* tracing_controller));
+
+}  // namespace platform
+}  // namespace v8
+
+#endif  // V8_LIBPLATFORM_LIBPLATFORM_H_

data/vendor/v8/include/libplatform/v8-tracing.h

@@ -0,0 +1,297 @@
+// 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 <unordered_set>
+#include <vector>
+
+#include "libplatform/libplatform-export.h"
+#include "v8-platform.h"  // NOLINT(build/include)
+
+namespace v8 {
+
+namespace base {
+class Mutex;
+}  // namespace base
+
+namespace platform {
+namespace tracing {
+
+const int kTraceMaxNumArgs = 2;
+
+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;
+  };
+
+  TraceObject() = default;
+  ~TraceObject();
+  void Initialize(
+      char phase, const uint8_t* category_enabled_flag, const char* name,
+      const char* scope, uint64_t id, uint64_t bind_id, int num_args,
+      const char** arg_names, const uint8_t* arg_types,
+      const uint64_t* arg_values,
+      std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables,
+      unsigned int flags, int64_t timestamp, int64_t cpu_timestamp);
+  void UpdateDuration(int64_t timestamp, int64_t cpu_timestamp);
+  void InitializeForTesting(
+      char phase, const uint8_t* category_enabled_flag, const char* name,
+      const char* scope, uint64_t id, uint64_t bind_id, int num_args,
+      const char** arg_names, const uint8_t* arg_types,
+      const uint64_t* arg_values,
+      std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables,
+      unsigned int flags, int pid, int tid, int64_t ts, int64_t tts,
+      uint64_t duration, uint64_t cpu_duration);
+
+  int pid() const { return pid_; }
+  int tid() const { return tid_; }
+  char phase() const { return phase_; }
+  const uint8_t* category_enabled_flag() const {
+    return category_enabled_flag_;
+  }
+  const char* name() const { return name_; }
+  const char* scope() const { return scope_; }
+  uint64_t id() const { return id_; }
+  uint64_t bind_id() const { return bind_id_; }
+  int num_args() const { return num_args_; }
+  const char** arg_names() { return arg_names_; }
+  uint8_t* arg_types() { return arg_types_; }
+  ArgValue* arg_values() { return arg_values_; }
+  std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables() {
+    return arg_convertables_;
+  }
+  unsigned int flags() const { return flags_; }
+  int64_t ts() { return ts_; }
+  int64_t tts() { return tts_; }
+  uint64_t duration() { return duration_; }
+  uint64_t cpu_duration() { return cpu_duration_; }
+
+ private:
+  int pid_;
+  int tid_;
+  char phase_;
+  const char* name_;
+  const char* scope_;
+  const uint8_t* category_enabled_flag_;
+  uint64_t id_;
+  uint64_t bind_id_;
+  int num_args_ = 0;
+  const char* arg_names_[kTraceMaxNumArgs];
+  uint8_t arg_types_[kTraceMaxNumArgs];
+  ArgValue arg_values_[kTraceMaxNumArgs];
+  std::unique_ptr<v8::ConvertableToTraceFormat>
+      arg_convertables_[kTraceMaxNumArgs];
+  char* parameter_copy_storage_ = nullptr;
+  unsigned int flags_;
+  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 V8_PLATFORM_EXPORT TraceWriter {
+ public:
+  TraceWriter() = default;
+  virtual ~TraceWriter() = default;
+  virtual void AppendTraceEvent(TraceObject* trace_event) = 0;
+  virtual void Flush() = 0;
+
+  static TraceWriter* CreateJSONTraceWriter(std::ostream& stream);
+  static TraceWriter* CreateJSONTraceWriter(std::ostream& stream,
+                                            const std::string& tag);
+
+ private:
+  // Disallow copy and assign
+  TraceWriter(const TraceWriter&) = delete;
+  void operator=(const TraceWriter&) = delete;
+};
+
+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 V8_PLATFORM_EXPORT TraceBuffer {
+ public:
+  TraceBuffer() = default;
+  virtual ~TraceBuffer() = default;
+
+  virtual TraceObject* AddTraceEvent(uint64_t* handle) = 0;
+  virtual TraceObject* GetEventByHandle(uint64_t handle) = 0;
+  virtual bool Flush() = 0;
+
+  static const size_t kRingBufferChunks = 1024;
+
+  static TraceBuffer* CreateTraceBufferRingBuffer(size_t max_chunks,
+                                                  TraceWriter* trace_writer);
+
+ private:
+  // Disallow copy and assign
+  TraceBuffer(const TraceBuffer&) = delete;
+  void operator=(const TraceBuffer&) = delete;
+};
+
+// Options determines how the trace buffer stores data.
+enum TraceRecordMode {
+  // Record until the trace buffer is full.
+  RECORD_UNTIL_FULL,
+
+  // Record until the user ends the trace. The trace buffer is a fixed size
+  // 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 V8_PLATFORM_EXPORT TraceConfig {
+ public:
+  typedef std::vector<std::string> StringList;
+
+  static TraceConfig* CreateDefaultTraceConfig();
+
+  TraceConfig() : enable_systrace_(false), enable_argument_filter_(false) {}
+  TraceRecordMode GetTraceRecordMode() const { return record_mode_; }
+  bool IsSystraceEnabled() const { return enable_systrace_; }
+  bool IsArgumentFilterEnabled() const { return enable_argument_filter_; }
+
+  void SetTraceRecordMode(TraceRecordMode mode) { record_mode_ = mode; }
+  void EnableSystrace() { enable_systrace_ = true; }
+  void EnableArgumentFilter() { enable_argument_filter_ = true; }
+
+  void AddIncludedCategory(const char* included_category);
+
+  bool IsCategoryGroupEnabled(const char* category_group) const;
+
+ private:
+  TraceRecordMode record_mode_;
+  bool enable_systrace_ : 1;
+  bool enable_argument_filter_ : 1;
+  StringList included_categories_;
+
+  // Disallow copy and assign
+  TraceConfig(const TraceConfig&) = delete;
+  void operator=(const TraceConfig&) = delete;
+};
+
+#if defined(_MSC_VER)
+#define V8_PLATFORM_NON_EXPORTED_BASE(code) \
+  __pragma(warning(suppress : 4275)) code
+#else
+#define V8_PLATFORM_NON_EXPORTED_BASE(code) code
+#endif  // defined(_MSC_VER)
+
+class V8_PLATFORM_EXPORT TracingController
+    : public V8_PLATFORM_NON_EXPORTED_BASE(v8::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,
+    // Category group enabled by SetEventCallbackEnabled().
+    ENABLED_FOR_EVENT_CALLBACK = 1 << 2,
+    // Category group enabled to export events to ETW.
+    ENABLED_FOR_ETW_EXPORT = 1 << 3
+  };
+
+  TracingController();
+  ~TracingController() override;
+  void Initialize(TraceBuffer* trace_buffer);
+
+  // v8::TracingController implementation.
+  const uint8_t* GetCategoryGroupEnabled(const char* category_group) override;
+  uint64_t AddTraceEvent(
+      char phase, const uint8_t* category_enabled_flag, const char* name,
+      const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args,
+      const char** arg_names, const uint8_t* arg_types,
+      const uint64_t* arg_values,
+      std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables,
+      unsigned int flags) override;
+  uint64_t AddTraceEventWithTimestamp(
+      char phase, const uint8_t* category_enabled_flag, const char* name,
+      const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args,
+      const char** arg_names, const uint8_t* arg_types,
+      const uint64_t* arg_values,
+      std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables,
+      unsigned int flags, int64_t timestamp) override;
+  void UpdateTraceEventDuration(const uint8_t* category_enabled_flag,
+                                const char* name, uint64_t handle) override;
+  void AddTraceStateObserver(
+      v8::TracingController::TraceStateObserver* observer) override;
+  void RemoveTraceStateObserver(
+      v8::TracingController::TraceStateObserver* observer) override;
+
+  void StartTracing(TraceConfig* trace_config);
+  void StopTracing();
+
+  static const char* GetCategoryGroupName(const uint8_t* category_enabled_flag);
+
+ protected:
+  virtual int64_t CurrentTimestampMicroseconds();
+  virtual int64_t CurrentCpuTimestampMicroseconds();
+
+ private:
+  const uint8_t* GetCategoryGroupEnabledInternal(const char* category_group);
+  void UpdateCategoryGroupEnabledFlag(size_t category_index);
+  void UpdateCategoryGroupEnabledFlags();
+
+  std::unique_ptr<TraceBuffer> trace_buffer_;
+  std::unique_ptr<TraceConfig> trace_config_;
+  std::unique_ptr<base::Mutex> mutex_;
+  std::unordered_set<v8::TracingController::TraceStateObserver*> observers_;
+  Mode mode_ = DISABLED;
+
+  // Disallow copy and assign
+  TracingController(const TracingController&) = delete;
+  void operator=(const TracingController&) = delete;
+};
+
+#undef V8_PLATFORM_NON_EXPORTED_BASE
+
+}  // namespace tracing
+}  // namespace platform
+}  // namespace v8
+
+#endif  // V8_LIBPLATFORM_V8_TRACING_H_