libv8 6.3.292.48.1-universal-darwin-16 → 6.7.288.46.1beta0-universal-darwin-16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d28ecf4545077ad2c4941292c733540d428904cd
-  data.tar.gz: 9eafe4cb783e81fc2f7e6e38602db553dec238e9
+SHA256:
+  metadata.gz: 698a668ef749596f8a9cfc1b62d27f973479b45022b834338b7faff3f181f6b3
+  data.tar.gz: eeb2573a2e54455b050cc3b02157e8a25241b9f7d094933274e8772fa6dee9d4
 SHA512:
-  metadata.gz: 3c46040914ccaf47f97b0a2558798eca66a83e3ccd9b79203c848205d7b793e1c0b317b513e9f73d96bfcec74009dc755d67e5eb633c98c9759e238457cda6a0
-  data.tar.gz: b123a926d2222d4ac2c1724857d86ee8630b05a922b1ee44759c283a9355018be780f5636de7e217461d0fcaaab496ff41e6417b8c7945087f99fdc025079cc5
+  metadata.gz: 9bbd973a27b5171b624021ea3588bfb1863b36e1afa6a00c6189b18b4da7cde9a2fb2fb187af5d97bb23dae2e6cff7cb8f12f5f332c7225a3453948055b5a076
+  data.tar.gz: 2f6b7e612e09a9fbafbd07e1f8261c44c26ca894020b738aa72c1b6427ba81ebb6ed4904c81a277505fbff5772897472538014200f2d7cb21dd4b52f87a638d7

data/ext/libv8/paths.rb

@@ -1,6 +1,5 @@
 require 'rbconfig'
 require 'shellwords'
-require File.expand_path '../arch', __FILE__
 
 module Libv8
   module Paths
@@ -11,29 +10,17 @@ module Libv8
     end
 
     def object_paths
-      [:base, :libplatform, :libsampler, :libbase, :snapshot].map do |name|
-        Shellwords.escape libv8_object(name)
-      end
+      [Shellwords.escape(File.join(vendored_source_path,
+                                   'out.gn',
+                                   'libv8',
+                                   'obj',
+                                   "libv8_monolith.#{config['LIBEXT']}"))]
     end
 
     def config
       RbConfig::MAKEFILE_CONFIG
     end
 
-    def libv8_object(name)
-      filename = "#{libv8_profile}/libv8_#{name}.#{config['LIBEXT']}"
-      unless File.exist? filename
-        filename = "#{libv8_profile}/obj.target/tools/gyp/libv8_#{name}.#{config['LIBEXT']}"
-      end
-      return filename
-    end
-
-    def libv8_profile
-      base = "#{vendored_source_path}/out/#{Libv8::Arch.libv8_arch}"
-      debug = "#{base}.debug"
-      File.exist?(debug) ? debug : "#{base}.release"
-    end
-
     def vendored_source_path
       File.expand_path "../../../vendor/v8", __FILE__
     end

data/lib/libv8/version.rb

@@ -1,3 +1,3 @@
 module Libv8
-  VERSION = "6.3.292.48.1"
+  VERSION = "6.7.288.46.1beta0"
 end

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

@@ -8,6 +8,7 @@
 #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 {
@@ -33,12 +34,21 @@ enum class MessageLoopBehavior : bool {
  * If |tracing_controller| is nullptr, the default platform will create a
  * v8::platform::TracingController instance and use it.
  */
-V8_PLATFORM_EXPORT v8::Platform* CreateDefaultPlatform(
+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::kEnabled,
-    v8::TracingController* tracing_controller = nullptr);
+        InProcessStackDumping::kDisabled,
+    std::unique_ptr<v8::TracingController> tracing_controller = {});
+
+V8_PLATFORM_EXPORT V8_DEPRECATE_SOON(
+    "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.
@@ -46,21 +56,23 @@ V8_PLATFORM_EXPORT v8::Platform* CreateDefaultPlatform(
  * 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 |CreateDefaultPlatform|.
+ * pending. The |platform| has to be created using |NewDefaultPlatform|.
  */
 V8_PLATFORM_EXPORT bool PumpMessageLoop(
     v8::Platform* platform, v8::Isolate* isolate,
     MessageLoopBehavior behavior = MessageLoopBehavior::kDoNotWait);
 
-V8_PLATFORM_EXPORT void EnsureEventLoopInitialized(v8::Platform* platform,
-                                                   v8::Isolate* isolate);
+V8_PLATFORM_EXPORT V8_DEPRECATE_SOON(
+    "This function has become obsolete and is essentially a nop",
+    void EnsureEventLoopInitialized(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|.
+ * created using |NewDefaultPlatform|.
  */
 V8_PLATFORM_EXPORT void RunIdleTasks(v8::Platform* platform,
                                      v8::Isolate* isolate,
@@ -69,13 +81,14 @@ V8_PLATFORM_EXPORT void RunIdleTasks(v8::Platform* platform,
 /**
  * Attempts to set the tracing controller for the given platform.
  *
- * The |platform| has to be created using |CreateDefaultPlatform|.
+ * The |platform| has to be created using |NewDefaultPlatform|.
  *
- * DEPRECATED: Will be removed soon.
  */
-V8_PLATFORM_EXPORT void SetTracingController(
-    v8::Platform* platform,
-    v8::platform::tracing::TracingController* tracing_controller);
+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

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

@@ -43,8 +43,8 @@ class V8_PLATFORM_EXPORT TraceObject {
       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();
+      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,
@@ -247,6 +247,13 @@ class V8_PLATFORM_EXPORT TracingController
       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(
@@ -259,6 +266,10 @@ class V8_PLATFORM_EXPORT TracingController
 
   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);

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

@@ -149,8 +149,9 @@ class V8_EXPORT V8InspectorSession {
 
   // Remote objects.
   virtual std::unique_ptr<protocol::Runtime::API::RemoteObject> wrapObject(
-      v8::Local<v8::Context>, v8::Local<v8::Value>,
-      const StringView& groupName) = 0;
+      v8::Local<v8::Context>, v8::Local<v8::Value>, const StringView& groupName,
+      bool generatePreview) = 0;
+
   virtual bool unwrapObject(std::unique_ptr<StringBuffer>* error,
                             const StringView& objectId, v8::Local<v8::Value>*,
                             v8::Local<v8::Context>*,
@@ -215,6 +216,20 @@ class V8_EXPORT V8InspectorClient {
   virtual void maxAsyncCallStackDepthChanged(int depth) {}
 };
 
+// These stack trace ids are intended to be passed between debuggers and be
+// resolved later. This allows to track cross-debugger calls and step between
+// them if a single client connects to multiple debuggers.
+struct V8_EXPORT V8StackTraceId {
+  uintptr_t id;
+  std::pair<int64_t, int64_t> debugger_id;
+
+  V8StackTraceId();
+  V8StackTraceId(uintptr_t id, const std::pair<int64_t, int64_t> debugger_id);
+  ~V8StackTraceId() = default;
+
+  bool IsInvalid() const;
+};
+
 class V8_EXPORT V8Inspector {
  public:
   static std::unique_ptr<V8Inspector> create(v8::Isolate*, V8InspectorClient*);
@@ -237,6 +252,11 @@ class V8_EXPORT V8Inspector {
   virtual void asyncTaskFinished(void* task) = 0;
   virtual void allAsyncTasksCanceled() = 0;
 
+  virtual V8StackTraceId storeCurrentStackTrace(
+      const StringView& description) = 0;
+  virtual void externalAsyncTaskStarted(const V8StackTraceId& parent) = 0;
+  virtual void externalAsyncTaskFinished(const V8StackTraceId& parent) = 0;
+
   // Exceptions instrumentation.
   virtual unsigned exceptionThrown(
       v8::Local<v8::Context>, const StringView& message,

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

@@ -7,9 +7,12 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <stdlib.h>  // For abort.
 #include <memory>
 #include <string>
 
+#include "v8config.h"  // NOLINT(build/include)
+
 namespace v8 {
 
 class Isolate;
@@ -36,6 +39,51 @@ class IdleTask {
   virtual void Run(double deadline_in_seconds) = 0;
 };
 
+/**
+ * A TaskRunner allows scheduling of tasks. The TaskRunner may still be used to
+ * post tasks after the isolate gets destructed, but these tasks may not get
+ * executed anymore. All tasks posted to a given TaskRunner will be invoked in
+ * sequence. Tasks can be posted from any thread.
+ */
+class TaskRunner {
+ public:
+  /**
+   * Schedules a task to be invoked by this TaskRunner. The TaskRunner
+   * implementation takes ownership of |task|.
+   */
+  virtual void PostTask(std::unique_ptr<Task> task) = 0;
+
+  /**
+   * Schedules a task to be invoked by this TaskRunner. The task is scheduled
+   * after the given number of seconds |delay_in_seconds|. The TaskRunner
+   * implementation takes ownership of |task|.
+   */
+  virtual void PostDelayedTask(std::unique_ptr<Task> task,
+                               double delay_in_seconds) = 0;
+
+  /**
+   * Schedules an idle task to be invoked by this TaskRunner. The task is
+   * scheduled when the embedder is idle. Requires that
+   * TaskRunner::SupportsIdleTasks(isolate) is true. Idle tasks may be reordered
+   * relative to other task types and may be starved for an arbitrarily long
+   * time if no idle time is available. The TaskRunner implementation takes
+   * ownership of |task|.
+   */
+  virtual void PostIdleTask(std::unique_ptr<IdleTask> task) = 0;
+
+  /**
+   * Returns true if idle tasks are enabled for this TaskRunner.
+   */
+  virtual bool IdleTasksEnabled() = 0;
+
+  TaskRunner() = default;
+  virtual ~TaskRunner() = default;
+
+ private:
+  TaskRunner(const TaskRunner&) = delete;
+  TaskRunner& operator=(const TaskRunner&) = delete;
+};
+
 /**
  * The interface represents complex arguments to trace events.
  */
@@ -74,11 +122,11 @@ class TracingController {
   }
 
   /**
-   * Adds a trace event to the platform tracing system. This function call is
+   * Adds a trace event to the platform tracing system. These function calls are
    * usually the result of a TRACE_* macro from trace_event_common.h when
    * tracing and the category of the particular trace are enabled. It is not
-   * advisable to call this function on its own; it is really only meant to be
-   * used by the trace macros. The returned handle can be used by
+   * advisable to call these functions on their own; they are really only meant
+   * to be used by the trace macros. The returned handle can be used by
    * UpdateTraceEventDuration to update the duration of COMPLETE events.
    */
   virtual uint64_t AddTraceEvent(
@@ -90,6 +138,15 @@ class TracingController {
       unsigned int flags) {
     return 0;
   }
+  virtual 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<ConvertableToTraceFormat>* arg_convertables,
+      unsigned int flags, int64_t timestamp) {
+    return 0;
+  }
 
   /**
    * Sets the duration field of a COMPLETE trace event. It must be called with
@@ -112,6 +169,74 @@ class TracingController {
   virtual void RemoveTraceStateObserver(TraceStateObserver*) {}
 };
 
+/**
+ * A V8 memory page allocator.
+ *
+ * Can be implemented by an embedder to manage large host OS allocations.
+ */
+class PageAllocator {
+ public:
+  virtual ~PageAllocator() = default;
+
+  /**
+   * Gets the page granularity for AllocatePages and FreePages. Addresses and
+   * lengths for those calls should be multiples of AllocatePageSize().
+   */
+  virtual size_t AllocatePageSize() = 0;
+
+  /**
+   * Gets the page granularity for SetPermissions and ReleasePages. Addresses
+   * and lengths for those calls should be multiples of CommitPageSize().
+   */
+  virtual size_t CommitPageSize() = 0;
+
+  /**
+   * Sets the random seed so that GetRandomMmapAddr() will generate repeatable
+   * sequences of random mmap addresses.
+   */
+  virtual void SetRandomMmapSeed(int64_t seed) = 0;
+
+  /**
+   * Returns a randomized address, suitable for memory allocation under ASLR.
+   * The address will be aligned to AllocatePageSize.
+   */
+  virtual void* GetRandomMmapAddr() = 0;
+
+  /**
+   * Memory permissions.
+   */
+  enum Permission {
+    kNoAccess,
+    kReadWrite,
+    // TODO(hpayer): Remove this flag. Memory should never be rwx.
+    kReadWriteExecute,
+    kReadExecute
+  };
+
+  /**
+   * Allocates memory in range with the given alignment and permission.
+   */
+  virtual void* AllocatePages(void* address, size_t length, size_t alignment,
+                              Permission permissions) = 0;
+
+  /**
+   * Frees memory in a range that was allocated by a call to AllocatePages.
+   */
+  virtual bool FreePages(void* address, size_t length) = 0;
+
+  /**
+   * Releases memory in a range that was allocated by a call to AllocatePages.
+   */
+  virtual bool ReleasePages(void* address, size_t length,
+                            size_t new_length) = 0;
+
+  /**
+   * Sets permissions on pages in an allocated range.
+   */
+  virtual bool SetPermissions(void* address, size_t length,
+                              Permission permissions) = 0;
+};
+
 /**
  * V8 Platform abstraction layer.
  *
@@ -132,6 +257,14 @@ class Platform {
 
   virtual ~Platform() = default;
 
+  /**
+   * Allows the embedder to manage memory page allocations.
+   */
+  virtual PageAllocator* GetPageAllocator() {
+    // TODO(bbudge) Make this abstract after all embedders implement this.
+    return nullptr;
+  }
+
   /**
    * Enables the embedder to respond in cases where V8 can't allocate large
    * blocks of memory. V8 retries the failed allocation once after calling this
@@ -139,16 +272,89 @@ class Platform {
    * error.
    * Embedder overrides of this function must NOT call back into V8.
    */
-  virtual void OnCriticalMemoryPressure() {}
+  virtual void OnCriticalMemoryPressure() {
+    // TODO(bbudge) Remove this when embedders override the following method.
+    // See crbug.com/634547.
+  }
+
+  /**
+   * Enables the embedder to respond in cases where V8 can't allocate large
+   * memory regions. The |length| parameter is the amount of memory needed.
+   * Returns true if memory is now available. Returns false if no memory could
+   * be made available. V8 will retry allocations until this method returns
+   * false.
+   *
+   * Embedder overrides of this function must NOT call back into V8.
+   */
+  virtual bool OnCriticalMemoryPressure(size_t length) { return false; }
+
+  /**
+   * Gets the number of worker threads used by GetWorkerThreadsTaskRunner() and
+   * CallOnWorkerThread(). This can be used to estimate the number of tasks a
+   * work package should be split into. A return value of 0 means that there are
+   * no worker threads available. Note that a value of 0 won't prohibit V8 from
+   * posting tasks using |CallOnWorkerThread|.
+   */
+  virtual int NumberOfWorkerThreads() {
+    return static_cast<int>(NumberOfAvailableBackgroundThreads());
+  }
+
+  /**
+   * Deprecated. Use NumberOfWorkerThreads() instead.
+   * TODO(gab): Remove this when all embedders override
+   * NumberOfWorkerThreads() instead.
+   */
+  V8_DEPRECATE_SOON(
+      "NumberOfAvailableBackgroundThreads() is deprecated, use "
+      "NumberOfAvailableBackgroundThreads() instead.",
+      virtual size_t NumberOfAvailableBackgroundThreads()) {
+    return 0;
+  }
+
+  /**
+   * Returns a TaskRunner which can be used to post a task on the foreground.
+   * This function should only be called from a foreground thread.
+   */
+  virtual std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(
+      Isolate* isolate) {
+    // TODO(ahaas): Make this function abstract after it got implemented on all
+    // platforms.
+    return {};
+  }
+
+  /**
+   * Returns a TaskRunner which can be used to post a task on a background.
+   * This function should only be called from a foreground thread.
+   */
+  V8_DEPRECATE_SOON(
+      "GetBackgroundTaskRunner() is deprecated, use "
+      "GetWorkerThreadsTaskRunner() "
+      "instead.",
+      virtual std::shared_ptr<v8::TaskRunner> GetBackgroundTaskRunner(
+          Isolate* isolate)) {
+    // TODO(gab): Remove this method when all embedders have moved to
+    // GetWorkerThreadsTaskRunner().
+
+    // An implementation needs to be provided here because this is called by the
+    // default GetWorkerThreadsTaskRunner() implementation below. In practice
+    // however, all code either:
+    //  - Overrides GetWorkerThreadsTaskRunner() (thus not making this call) --
+    //    i.e. all v8 code.
+    //  - Overrides this method (thus not making this call) -- i.e. all
+    //    unadapted embedders.
+    abort();
+  }
 
   /**
-   * Gets the number of threads that are used to execute background tasks. Is
-   * used to estimate the number of tasks a work package should be split into.
-   * A return value of 0 means that there are no background threads available.
-   * Note that a value of 0 won't prohibit V8 from posting tasks using
-   * |CallOnBackgroundThread|.
+   * Returns a TaskRunner which can be used to post async tasks on a worker.
+   * This function should only be called from a foreground thread.
    */
-  virtual size_t NumberOfAvailableBackgroundThreads() { return 0; }
+  virtual std::shared_ptr<v8::TaskRunner> GetWorkerThreadsTaskRunner(
+      Isolate* isolate) {
+    // TODO(gab): Make this function abstract after it got implemented on all
+    // platforms.
+    return GetBackgroundTaskRunner(isolate);
+  }
 
   /**
    * Schedules a task to be invoked on a background thread. |expected_runtime|
@@ -157,8 +363,37 @@ class Platform {
    * of tasks wrt order of scheduling, nor is there a guarantee about the
    * thread the task will be run on.
    */
-  virtual void CallOnBackgroundThread(Task* task,
-                                      ExpectedRuntime expected_runtime) = 0;
+  V8_DEPRECATE_SOON(
+      "ExpectedRuntime is deprecated, use CallOnWorkerThread() instead.",
+      virtual void CallOnBackgroundThread(Task* task,
+                                          ExpectedRuntime expected_runtime)) {
+    // An implementation needs to be provided here because this is called by the
+    // default implementation below. In practice however, all code either:
+    //  - Overrides the new method (thus not making this call) -- i.e. all v8
+    //    code.
+    //  - Overrides this method (thus not making this call) -- i.e. all
+    //    unadapted embedders.
+    abort();
+  }
+
+  /**
+   * Schedules a task to be invoked on a worker thread.
+   * TODO(gab): Make pure virtual when all embedders override this instead of
+   * CallOnBackgroundThread().
+   */
+  virtual void CallOnWorkerThread(std::unique_ptr<Task> task) {
+    CallOnBackgroundThread(task.release(), kShortRunningTask);
+  }
+
+  /**
+   * Schedules a task that blocks the main thread to be invoked with
+   * high-priority on a worker thread.
+   */
+  virtual void CallBlockingTaskOnWorkerThread(std::unique_ptr<Task> task) {
+    // Embedders may optionally override this to process these tasks in a high
+    // priority pool.
+    CallOnWorkerThread(std::move(task));
+  }
 
   /**
    * Schedules a task to be invoked on a foreground thread wrt a specific