libv8 5.3.332.38.5-universal-darwin-16 → 5.7.492.65.0beta1-universal-darwin-16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 576ee596b5a2a8047354dd9275718fa734e43f80
-  data.tar.gz: 858e168fbe2080fdd1c5b6c2d1d204f79dac4ec1
+  metadata.gz: 3797bb861bcc10e55361808318e35bf1a3e51be7
+  data.tar.gz: ea6cb8701db95cef739277cebed609f474c6890e
 SHA512:
-  metadata.gz: 0b103779d2e5f261789d8ce74568ae1890d1ac2ebc44602b7c61da14d78ee451d1c1be14e6b202a6e2b611ed14bf2759dff0d99f984bdbf1af6e54e4cbb1e42e
-  data.tar.gz: 480cb21364c51d2bf03406566ea77cb8f4198f0b03b950f84d662fac90f3f0b259af06e8440bacbfc7da57d3947b389cf3f0a803c41e167fa5f72b9fc4957e93
+  metadata.gz: 31c7d080bd0c1bb6523dbdb02d34472302ac766c49497b15da19d2ac5526eb904bdc83d0fa1bf43ce8170f539775f10e5c3141cbf835613fefd444c284ddb805
+  data.tar.gz: 76dac8efeb526b3387510c6c5a42b1d95993a22a5b702c4083355af06499100d04bd6a9eb02523e79805408f4252f5b02af6773331ac9089962641dcad31becb

data/ext/libv8/arch.rb

@@ -6,11 +6,11 @@ module Libv8
 
     def libv8_arch
       case Gem::Platform.local.cpu
-      when /^arm(v7.*)*$/     then 'arm'
-      when /^a(rm|arch)64$/   then 'arm64'
-      when /^x86$/            then 'ia32'
-      when /^(x86_64|amd64)$/ then 'x64'
-      when /^universal$/      then 'x64' # OS X
+      when /^arm(v6.*|v7.*)*$/ then 'arm'
+      when /^a(rm|arch)64$/    then 'arm64'
+      when /^x86$/             then 'ia32'
+      when /^(x86_64|amd64)$/  then 'x64'
+      when /^universal$/       then 'x64' # OS X
       else
         warn "Unsupported target: #{Gem::Platform.local.cpu}"
         Gem::Platform.local.cpu

data/lib/libv8/version.rb

@@ -1,3 +1,3 @@
 module Libv8
-  VERSION = "5.3.332.38.5"
+  VERSION = "5.7.492.65.0beta1"
 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

@@ -5,6 +5,8 @@
 #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)
 
 namespace v8 {
@@ -18,8 +20,8 @@ namespace platform {
  * of zero is passed, a suitable default based on the current number of
  * processors online will be chosen.
  */
-v8::Platform* CreateDefaultPlatform(int thread_pool_size = 0);
-
+V8_PLATFORM_EXPORT v8::Platform* CreateDefaultPlatform(
+    int thread_pool_size = 0);
 
 /**
  * Pumps the message loop for the given isolate.
@@ -29,8 +31,28 @@ v8::Platform* CreateDefaultPlatform(int thread_pool_size = 0);
  * not block if no task is pending. The |platform| has to be created using
  * |CreateDefaultPlatform|.
  */
-bool PumpMessageLoop(v8::Platform* platform, v8::Isolate* isolate);
+V8_PLATFORM_EXPORT bool PumpMessageLoop(v8::Platform* platform,
+                                        v8::Isolate* isolate);
 
+/**
+ * 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 |CreateDefaultPlatform|.
+ */
+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 |CreateDefaultPlatform|.
+ */
+V8_PLATFORM_EXPORT void SetTracingController(
+    v8::Platform* platform,
+    v8::platform::tracing::TracingController* tracing_controller);
 
 }  // namespace platform
 }  // namespace v8

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

@@ -0,0 +1,270 @@
+// 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() {}
+  ~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);
+  void UpdateDuration();
+  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() {}
+  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 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() {}
+  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;
+
+  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;
+};
+
+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,
+    // 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();
+  void Initialize(TraceBuffer* trace_buffer);
+  const uint8_t* GetCategoryGroupEnabled(const char* category_group);
+  static const char* GetCategoryGroupName(const uint8_t* category_enabled_flag);
+  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);
+  void UpdateTraceEventDuration(const uint8_t* category_enabled_flag,
+                                const char* name, uint64_t handle);
+
+  void StartTracing(TraceConfig* trace_config);
+  void StopTracing();
+
+  void AddTraceStateObserver(Platform::TraceStateObserver* observer);
+  void RemoveTraceStateObserver(Platform::TraceStateObserver* observer);
+
+ 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<Platform::TraceStateObserver*> observers_;
+  Mode mode_ = DISABLED;
+
+  // 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_

data/vendor/v8/include/v8-debug.h

@@ -16,11 +16,9 @@ namespace v8 {
 enum DebugEvent {
   Break = 1,
   Exception = 2,
-  NewFunction = 3,
-  BeforeCompile = 4,
-  AfterCompile = 5,
-  CompileError = 6,
-  AsyncTaskEvent = 7,
+  AfterCompile = 3,
+  CompileError = 4,
+  AsyncTaskEvent = 5,
 };
 
 class V8_EXPORT Debug {
@@ -87,7 +85,6 @@ class V8_EXPORT Debug {
     virtual ~Message() {}
   };
 
-
   /**
    * An event details object passed to the debug event listener.
    */
@@ -145,7 +142,7 @@ class V8_EXPORT Debug {
    *
    * \param message the debug message handler message object
    *
-   * A MessageHandler2 does not take possession of the message data,
+   * A MessageHandler does not take possession of the message data,
    * and must not rely on the data persisting after the handler returns.
    */
   typedef void (*MessageHandler)(const Message& message);
@@ -157,9 +154,6 @@ class V8_EXPORT Debug {
 
   static bool SetDebugEventListener(Isolate* isolate, EventCallback that,
                                     Local<Value> data = Local<Value>());
-  V8_DEPRECATED("Use version with an Isolate",
-                static bool SetDebugEventListener(
-                    EventCallback that, Local<Value> data = Local<Value>()));
 
   // Schedule a debugger break to happen when JavaScript code is run
   // in the given isolate.
@@ -170,38 +164,37 @@ class V8_EXPORT Debug {
   static void CancelDebugBreak(Isolate* isolate);
 
   // Check if a debugger break is scheduled in the given isolate.
-  static bool CheckDebugBreak(Isolate* isolate);
+  V8_DEPRECATED("No longer supported",
+                static bool CheckDebugBreak(Isolate* isolate));
 
   // Message based interface. The message protocol is JSON.
-  static void SetMessageHandler(Isolate* isolate, MessageHandler handler);
-  V8_DEPRECATED("Use version with an Isolate",
-                static void SetMessageHandler(MessageHandler handler));
-
-  static void SendCommand(Isolate* isolate,
-                          const uint16_t* command, int length,
-                          ClientData* client_data = NULL);
-
- /**
-  * Run a JavaScript function in the debugger.
-  * \param fun the function to call
-  * \param data passed as second argument to the function
-  * With this call the debugger is entered and the function specified is called
-  * with the execution state as the first argument. This makes it possible to
-  * get access to information otherwise not available during normal JavaScript
-  * execution e.g. details on stack frames. Receiver of the function call will
-  * be the debugger context global object, however this is a subject to change.
-  * The following example shows a JavaScript function which when passed to
-  * v8::Debug::Call will return the current line of JavaScript execution.
-  *
-  * \code
-  *   function frame_source_line(exec_state) {
-  *     return exec_state.frame(0).sourceLine();
-  *   }
-  * \endcode
-  */
-  static V8_DEPRECATED("Use maybe version",
-                       Local<Value> Call(v8::Local<v8::Function> fun,
-                                         Local<Value> data = Local<Value>()));
+  V8_DEPRECATED("No longer supported",
+                static void SetMessageHandler(Isolate* isolate,
+                                              MessageHandler handler));
+
+  V8_DEPRECATED("No longer supported",
+                static void SendCommand(Isolate* isolate,
+                                        const uint16_t* command, int length,
+                                        ClientData* client_data = NULL));
+
+  /**
+   * Run a JavaScript function in the debugger.
+   * \param fun the function to call
+   * \param data passed as second argument to the function
+   * With this call the debugger is entered and the function specified is called
+   * with the execution state as the first argument. This makes it possible to
+   * get access to information otherwise not available during normal JavaScript
+   * execution e.g. details on stack frames. Receiver of the function call will
+   * be the debugger context global object, however this is a subject to change.
+   * The following example shows a JavaScript function which when passed to
+   * v8::Debug::Call will return the current line of JavaScript execution.
+   *
+   * \code
+   *   function frame_source_line(exec_state) {
+   *     return exec_state.frame(0).sourceLine();
+   *   }
+   * \endcode
+   */
   // TODO(dcarney): data arg should be a MaybeLocal
   static MaybeLocal<Value> Call(Local<Context> context,
                                 v8::Local<v8::Function> fun,
@@ -210,10 +203,9 @@ class V8_EXPORT Debug {
   /**
    * Returns a mirror object for the given object.
    */
-  static V8_DEPRECATED("Use maybe version",
-                       Local<Value> GetMirror(v8::Local<v8::Value> obj));
-  static MaybeLocal<Value> GetMirror(Local<Context> context,
-                                     v8::Local<v8::Value> obj);
+  V8_DEPRECATED("No longer supported",
+                static MaybeLocal<Value> GetMirror(Local<Context> context,
+                                                   v8::Local<v8::Value> obj));
 
   /**
    * Makes V8 process all pending debug messages.
@@ -246,9 +238,8 @@ class V8_EXPORT Debug {
    * "Evaluate" debug command behavior currently is not specified in scope
    * of this method.
    */
-  static void ProcessDebugMessages(Isolate* isolate);
-  V8_DEPRECATED("Use version with an Isolate",
-                static void ProcessDebugMessages());
+  V8_DEPRECATED("No longer supported",
+                static void ProcessDebugMessages(Isolate* isolate));
 
   /**
    * Debugger is running in its own context which is entered while debugger
@@ -257,15 +248,16 @@ class V8_EXPORT Debug {
    * to change. The Context exists only when the debugger is active, i.e. at
    * least one DebugEventListener or MessageHandler is set.
    */
-  static Local<Context> GetDebugContext(Isolate* isolate);
-  V8_DEPRECATED("Use version with an Isolate",
-                static Local<Context> GetDebugContext());
+  V8_DEPRECATED("Use v8-inspector",
+                static Local<Context> GetDebugContext(Isolate* isolate));
 
   /**
    * While in the debug context, this method returns the top-most non-debug
    * context, if it exists.
    */
-  static MaybeLocal<Context> GetDebuggedContext(Isolate* isolate);
+  V8_DEPRECATED(
+      "No longer supported",
+      static MaybeLocal<Context> GetDebuggedContext(Isolate* isolate));
 
   /**
    * Enable/disable LiveEdit functionality for the given Isolate