BASELINE: Update Chromium to 87.0.4280.67

Change-Id: Ib157360be8c2ffb2c73125751a89f60e049c1d54
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

13 files changed, 200 insertions, 83 deletions

diff --git a/chromium/v8/include/cppgc/OWNERS b/chromium/v8/include/cppgc/OWNERS
new file mode 100644
index 00000000000..6ccabf60b15
--- /dev/null
+++ b/chromium/v8/include/cppgc/OWNERS
@@ -0,0 +1,2 @@
+bikineev@chromium.org
+omerkatz@chromium.org
\ No newline at end of file
diff --git a/chromium/v8/include/cppgc/default-platform.h b/chromium/v8/include/cppgc/default-platform.h
index 24b1cd14982..da8129a81b1 100644
--- a/chromium/v8/include/cppgc/default-platform.h
+++ b/chromium/v8/include/cppgc/default-platform.h
@@ -6,7 +6,6 @@
 #define INCLUDE_CPPGC_DEFAULT_PLATFORM_H_
 
 #include <memory>
-#include <thread>  // NOLINT(build/c++11)
 #include <vector>
 
 #include "cppgc/platform.h"
@@ -14,6 +13,10 @@
 
 namespace cppgc {
 
+namespace internal {
+class DefaultJob;
+}  // namespace internal
+
 /**
  * Default task runner implementation. Keep posted tasks in a list that can be
  * processed by calling RunSingleTask() or RunUntilIdle().
@@ -26,8 +29,11 @@ class V8_EXPORT DefaultTaskRunner final : public cppgc::TaskRunner {
   DefaultTaskRunner& operator=(const DefaultTaskRunner&) = delete;
 
   void PostTask(std::unique_ptr<cppgc::Task> task) override;
-  void PostNonNestableTask(std::unique_ptr<cppgc::Task> task) override;
   void PostDelayedTask(std::unique_ptr<cppgc::Task> task, double) override;
+
+  bool NonNestableTasksEnabled() const final { return false; }
+  bool NonNestableDelayedTasksEnabled() const final { return false; }
+  void PostNonNestableTask(std::unique_ptr<cppgc::Task> task) override;
   void PostNonNestableDelayedTask(std::unique_ptr<cppgc::Task> task,
                                   double) override;
 
@@ -58,6 +64,8 @@ class V8_EXPORT DefaultPlatform final : public Platform {
 
   std::shared_ptr<cppgc::TaskRunner> GetForegroundTaskRunner() final;
 
+  // DefaultPlatform does not support job priorities. All jobs would be
+  // assigned the same priority regardless of the cppgc::TaskPriority parameter.
   std::unique_ptr<cppgc::JobHandle> PostJob(
       cppgc::TaskPriority priority,
       std::unique_ptr<cppgc::JobTask> job_task) final;
@@ -68,7 +76,7 @@ class V8_EXPORT DefaultPlatform final : public Platform {
  private:
   std::unique_ptr<PageAllocator> page_allocator_;
   std::shared_ptr<DefaultTaskRunner> foreground_task_runner_;
-  std::vector<std::shared_ptr<std::thread>> job_threads_;
+  std::vector<std::shared_ptr<internal::DefaultJob>> jobs_;
 };
 
 }  // namespace cppgc
diff --git a/chromium/v8/include/cppgc/heap.h b/chromium/v8/include/cppgc/heap.h
index ca0dbeca7ff..029158f4a58 100644
--- a/chromium/v8/include/cppgc/heap.h
+++ b/chromium/v8/include/cppgc/heap.h
@@ -84,7 +84,7 @@ class V8_EXPORT Heap {
     std::vector<std::unique_ptr<CustomSpaceBase>> custom_spaces;
 
     /**
-     * Specifies whether conserative stack scan is supported. When conservative
+     * Specifies whether conservative stack scan is supported. When conservative
      * stack scan is not supported, the collector may try to invoke
      * garbage collections using non-nestable task, which are guaranteed to have
      * no interesting stack, through the provided Platform. If such tasks are
diff --git a/chromium/v8/include/cppgc/internal/prefinalizer-handler.h b/chromium/v8/include/cppgc/internal/prefinalizer-handler.h
index ea0eca02a0e..64b07ec9112 100644
--- a/chromium/v8/include/cppgc/internal/prefinalizer-handler.h
+++ b/chromium/v8/include/cppgc/internal/prefinalizer-handler.h
@@ -18,7 +18,7 @@ class V8_EXPORT PreFinalizerRegistrationDispatcher final {
     void* object;
     PreFinalizerCallback callback;
 
-    bool operator==(const PreFinalizer& other);
+    bool operator==(const PreFinalizer& other) const;
   };
 
   static void RegisterPrefinalizer(PreFinalizer pre_finalizer);
diff --git a/chromium/v8/include/cppgc/member.h b/chromium/v8/include/cppgc/member.h
index 22c1adc0af7..116a2c7e54a 100644
--- a/chromium/v8/include/cppgc/member.h
+++ b/chromium/v8/include/cppgc/member.h
@@ -58,6 +58,7 @@ class BasicMember final : private MemberBase, private CheckingPolicy {
     this->CheckPointer(Get());
   }
   BasicMember(T& raw) : BasicMember(&raw) {}  // NOLINT
+  // Copy ctor.
   BasicMember(const BasicMember& other) : BasicMember(other.Get()) {}
   // Allow heterogeneous construction.
   template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
@@ -67,6 +68,20 @@ class BasicMember final : private MemberBase, private CheckingPolicy {
       const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
                         OtherCheckingPolicy>& other)
       : BasicMember(other.Get()) {}
+  // Move ctor.
+  BasicMember(BasicMember&& other) noexcept : BasicMember(other.Get()) {
+    other.Clear();
+  }
+  // Allow heterogeneous move construction.
+  template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
+            typename OtherCheckingPolicy,
+            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+  BasicMember(  // NOLINT
+      BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
+                  OtherCheckingPolicy>&& other) noexcept
+      : BasicMember(other.Get()) {
+    other.Clear();
+  }
   // Construction from Persistent.
   template <typename U, typename PersistentWeaknessPolicy,
             typename PersistentLocationPolicy,
@@ -78,10 +93,11 @@ class BasicMember final : private MemberBase, private CheckingPolicy {
           p)
       : BasicMember(p.Get()) {}
 
+  // Copy assignment.
   BasicMember& operator=(const BasicMember& other) {
     return operator=(other.Get());
   }
-  // Allow heterogeneous assignment.
+  // Allow heterogeneous copy assignment.
   template <typename U, typename OtherWeaknessTag, typename OtherBarrierPolicy,
             typename OtherCheckingPolicy,
             typename = std::enable_if_t<std::is_base_of<T, U>::value>>
@@ -90,6 +106,22 @@ class BasicMember final : private MemberBase, private CheckingPolicy {
                         OtherCheckingPolicy>& other) {
     return operator=(other.Get());
   }
+  // Move assignment.
+  BasicMember& operator=(BasicMember&& other) noexcept {
+    operator=(other.Get());
+    other.Clear();
+    return *this;
+  }
+  // Heterogeneous move assignment.
+  template <typename U, typename OtherWeaknessTag, typename OtherBarrierPolicy,
+            typename OtherCheckingPolicy,
+            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+  BasicMember& operator=(BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
+                                     OtherCheckingPolicy>&& other) noexcept {
+    operator=(other.Get());
+    other.Clear();
+    return *this;
+  }
   // Assignment from Persistent.
   template <typename U, typename PersistentWeaknessPolicy,
             typename PersistentLocationPolicy,
diff --git a/chromium/v8/include/js_protocol.pdl b/chromium/v8/include/js_protocol.pdl
index 24a957f7fb7..4c1b567404a 100644
--- a/chromium/v8/include/js_protocol.pdl
+++ b/chromium/v8/include/js_protocol.pdl
@@ -863,6 +863,16 @@ domain Profiler
       # Counter value.
       integer value
 
+  # Runtime call counter information.
+  experimental type RuntimeCallCounterInfo extends object
+    properties
+      # Counter name.
+      string name
+      # Counter value.
+      number value
+      # Counter time in seconds.
+      number time
+
   command disable
 
   command enable
@@ -927,6 +937,18 @@ domain Profiler
       # Type profile for all scripts since startTypeProfile() was turned on.
       array of ScriptTypeProfile result
 
+  # Enable counters collection.
+  experimental command enableCounters
+
+  # Disable counters collection.
+  experimental command disableCounters
+
+  # Retrieve counters.
+  experimental command getCounters
+    returns
+      # Collected counters information.
+      array of CounterInfo result
+
   # Enable run time call stats collection.
   experimental command enableRuntimeCallStats
 
@@ -936,8 +958,8 @@ domain Profiler
   # Retrieve run time call stats.
   experimental command getRuntimeCallStats
     returns
-      # Collected counter information.
-      array of CounterInfo result
+      # Collected runtime call counter information.
+      array of RuntimeCallCounterInfo result
 
   event consoleProfileFinished
     parameters
diff --git a/chromium/v8/include/v8-internal.h b/chromium/v8/include/v8-internal.h
index fcc36595ba5..0d9cce82b47 100644
--- a/chromium/v8/include/v8-internal.h
+++ b/chromium/v8/include/v8-internal.h
@@ -414,7 +414,8 @@ void CastCheck<false>::Perform(T* data) {}
 
 template <class T>
 V8_INLINE void PerformCastCheck(T* data) {
-  CastCheck<std::is_base_of<Data, T>::value>::Perform(data);
+  CastCheck<std::is_base_of<Data, T>::value &&
+            !std::is_same<Data, std::remove_cv_t<T>>::value>::Perform(data);
 }
 
 // A base class for backing stores, which is needed due to vagaries of
diff --git a/chromium/v8/include/v8-metrics.h b/chromium/v8/include/v8-metrics.h
index a511c01e5af..9734ac1b36a 100644
--- a/chromium/v8/include/v8-metrics.h
+++ b/chromium/v8/include/v8-metrics.h
@@ -16,7 +16,7 @@ struct WasmModuleDecoded {
   bool success = false;
   size_t module_size_in_bytes = 0;
   size_t function_count = 0;
-  int64_t wall_clock_time_in_us = 0;
+  int64_t wall_clock_time_in_us = -1;
 };
 
 struct WasmModuleCompiled {
@@ -28,20 +28,20 @@ struct WasmModuleCompiled {
   bool success = false;
   size_t code_size_in_bytes = 0;
   size_t liftoff_bailout_count = 0;
-  int64_t wall_clock_time_in_us = 0;
+  int64_t wall_clock_time_in_us = -1;
 };
 
 struct WasmModuleInstantiated {
   bool async = false;
   bool success = false;
   size_t imported_function_count = 0;
-  int64_t wall_clock_time_in_us = 0;
+  int64_t wall_clock_time_in_us = -1;
 };
 
 struct WasmModuleTieredUp {
   bool lazy = false;
   size_t code_size_in_bytes = 0;
-  int64_t wall_clock_time_in_us = 0;
+  int64_t wall_clock_time_in_us = -1;
 };
 
 struct WasmModulesPerIsolate {
diff --git a/chromium/v8/include/v8-platform.h b/chromium/v8/include/v8-platform.h
index aae381b0806..7bb79a18414 100644
--- a/chromium/v8/include/v8-platform.h
+++ b/chromium/v8/include/v8-platform.h
@@ -175,9 +175,15 @@ class JobDelegate {
    * Returns a task_id unique among threads currently running this job, such
    * that GetTaskId() < worker count. To achieve this, the same task_id may be
    * reused by a different thread after a worker_task returns.
+   */
+  virtual uint8_t GetTaskId() = 0;
+
+  /**
+   * Returns true if the current task is called from the thread currently
+   * running JobHandle::Join().
    * TODO(etiennep): Make pure virtual once custom embedders implement it.
    */
-  virtual uint8_t GetTaskId() { return 0; }
+  virtual bool IsJoiningThread() const { return false; }
 };
 
 /**
@@ -212,9 +218,8 @@ class JobHandle {
 
   /**
    * Returns true if there's no work pending and no worker running.
-   * TODO(etiennep): Make pure virtual once custom embedders implement it.
    */
-  virtual bool IsCompleted() { return true; }
+  virtual bool IsCompleted() = 0;
 
   /**
    * Returns true if associated with a Job and other methods may be called.
@@ -233,23 +238,17 @@ class JobTask {
   virtual void Run(JobDelegate* delegate) = 0;
 
   /**
-   * Controls the maximum number of threads calling Run() concurrently. Run() is
-   * only invoked if the number of threads previously running Run() was less
-   * than the value returned. Since GetMaxConcurrency() is a leaf function, it
-   * must not call back any JobHandle methods.
+   * Controls the maximum number of threads calling Run() concurrently, given
+   * the number of threads currently assigned to this job and executing Run().
+   * Run() is only invoked if the number of threads previously running Run() was
+   * less than the value returned. Since GetMaxConcurrency() is a leaf function,
+   * it must not call back any JobHandle methods.
    */
-  virtual size_t GetMaxConcurrency() const = 0;
+  virtual size_t GetMaxConcurrency(size_t worker_count) const = 0;
 
-  /*
-   * Meant to replace the version above, given the number of threads currently
-   * assigned to this job and executing Run(). This is useful when the result
-   * must include local work items not visible globaly by other workers.
-   * TODO(etiennep): Replace the version above by this once custom embedders are
-   * migrated.
-   */
-  size_t GetMaxConcurrency(size_t worker_count) const {
-    return GetMaxConcurrency();
-  }
+  // TODO(1114823): Clean up once all overrides are removed.
+  V8_DEPRECATED("Use the version that takes |worker_count|.")
+  virtual size_t GetMaxConcurrency() const { return 0; }
 };
 
 /**
diff --git a/chromium/v8/include/v8-profiler.h b/chromium/v8/include/v8-profiler.h
index c3b25e8d6a6..7ec19937343 100644
--- a/chromium/v8/include/v8-profiler.h
+++ b/chromium/v8/include/v8-profiler.h
@@ -6,6 +6,7 @@
 #define V8_V8_PROFILER_H_
 
 #include <limits.h>
+
 #include <memory>
 #include <unordered_set>
 #include <vector>
@@ -268,6 +269,8 @@ class V8_EXPORT CpuProfilingOptions {
    *                             interval, set via SetSamplingInterval(). If
    *                             zero, the sampling interval will be equal to
    *                             the profiler's sampling interval.
+   * \param filter_context Deprecated option to filter by context, currently a
+   *                       no-op.
    */
   CpuProfilingOptions(
       CpuProfilingMode mode = kLeafNodeLineNumbers,
@@ -281,13 +284,9 @@ class V8_EXPORT CpuProfilingOptions {
  private:
   friend class internal::CpuProfile;
 
-  bool has_filter_context() const { return !filter_context_.IsEmpty(); }
-  void* raw_filter_context() const;
-
   CpuProfilingMode mode_;
   unsigned max_samples_;
   int sampling_interval_us_;
-  CopyablePersistentTraits<Context>::CopyablePersistent filter_context_;
 };
 
 /**
@@ -712,6 +711,19 @@ class V8_EXPORT EmbedderGraph {
  public:
   class Node {
    public:
+    /**
+     * Detachedness specifies whether an object is attached or detached from the
+     * main application state. While unkown in general, there may be objects
+     * that specifically know their state. V8 passes this information along in
+     * the snapshot. Users of the snapshot may use it to annotate the object
+     * graph.
+     */
+    enum class Detachedness : uint8_t {
+      kUnknown = 0,
+      kAttached = 1,
+      kDetached = 2,
+    };
+
     Node() = default;
     virtual ~Node() = default;
     virtual const char* Name() = 0;
@@ -736,6 +748,14 @@ class V8_EXPORT EmbedderGraph {
      */
     virtual NativeObject GetNativeObject() { return nullptr; }
 
+    /**
+     * Detachedness state of a given object. While unkown in general, there may
+     * be objects that specifically know their state. V8 passes this information
+     * along in the snapshot. Users of the snapshot may use it to annotate the
+     * object graph.
+     */
+    virtual Detachedness GetDetachedness() { return Detachedness::kUnknown; }
+
     Node(const Node&) = delete;
     Node& operator=(const Node&) = delete;
   };
diff --git a/chromium/v8/include/v8-version.h b/chromium/v8/include/v8-version.h
index 8060900855b..2d6f1cda5e1 100644
--- a/chromium/v8/include/v8-version.h
+++ b/chromium/v8/include/v8-version.h
@@ -9,9 +9,9 @@
 // NOTE these macros are used by some of the tool scripts and the build
 // system so their names cannot be changed without changing the scripts.
 #define V8_MAJOR_VERSION 8
-#define V8_MINOR_VERSION 6
-#define V8_BUILD_NUMBER 395
-#define V8_PATCH_LEVEL 17
+#define V8_MINOR_VERSION 7
+#define V8_BUILD_NUMBER 220
+#define V8_PATCH_LEVEL 25
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)
diff --git a/chromium/v8/include/v8.h b/chromium/v8/include/v8.h
index a839165324c..32687d90b5f 100644
--- a/chromium/v8/include/v8.h
+++ b/chromium/v8/include/v8.h
@@ -19,6 +19,7 @@
 #include <stdint.h>
 #include <stdio.h>
 
+#include <atomic>
 #include <memory>
 #include <string>
 #include <type_traits>
@@ -1318,6 +1319,32 @@ class V8_EXPORT SealHandleScope {
  * The superclass of objects that can reside on V8's heap.
  */
 class V8_EXPORT Data {
+ public:
+  /**
+   * Returns true if this data is a |v8::Value|.
+   */
+  bool IsValue() const;
+
+  /**
+   * Returns true if this data is a |v8::Module|.
+   */
+  bool IsModule() const;
+
+  /**
+   * Returns true if this data is a |v8::Private|.
+   */
+  bool IsPrivate() const;
+
+  /**
+   * Returns true if this data is a |v8::ObjectTemplate|.
+   */
+  bool IsObjectTemplate() const;
+
+  /**
+   * Returns true if this data is a |v8::FunctionTemplate|.
+   */
+  bool IsFunctionTemplate() const;
+
  private:
   Data();
 };
@@ -1629,6 +1656,11 @@ class V8_EXPORT Module : public Data {
       "the latter will crash with a failed CHECK().")
   void SetSyntheticModuleExport(Local<String> export_name,
                                 Local<Value> export_value);
+
+  V8_INLINE static Module* Cast(Data* data);
+
+ private:
+  static void CheckCast(Data* obj);
 };
 
 /**
@@ -2260,14 +2292,6 @@ struct JSEntryStub {
   MemoryRange code;
 };
 
-struct UnwindState {
-  MemoryRange code_range;
-  MemoryRange embedded_code_range;
-  JSEntryStub js_entry_stub;
-  JSEntryStub js_construct_entry_stub;
-  JSEntryStub js_run_microtasks_entry_stub;
-};
-
 struct JSEntryStubs {
   JSEntryStub js_entry_stub;
   JSEntryStub js_construct_entry_stub;
@@ -2932,6 +2956,8 @@ class V8_EXPORT Value : public Data {
   bool FullIsUndefined() const;
   bool FullIsNull() const;
   bool FullIsString() const;
+
+  static void CheckCast(Data* that);
 };
 
 
@@ -3087,11 +3113,19 @@ class V8_EXPORT String : public Name {
   V8_INLINE static Local<String> Empty(Isolate* isolate);
 
   /**
-   * Returns true if the string is external
+   * Returns true if the string is external two-byte.
+   *
    */
+  V8_DEPRECATE_SOON(
+      "Use String::IsExternalTwoByte() or String::IsExternalOneByte()")
   bool IsExternal() const;
 
   /**
+   * Returns true if the string is both external and two-byte.
+   */
+  bool IsExternalTwoByte() const;
+
+  /**
    * Returns true if the string is both external and one-byte.
    */
   bool IsExternalOneByte() const;
@@ -9326,13 +9360,6 @@ class V8_EXPORT Isolate {
   void GetCodeRange(void** start, size_t* length_in_bytes);
 
   /**
-   * Returns the UnwindState necessary for use with the Unwinder API.
-   */
-  // TODO(petermarshall): Remove this API.
-  V8_DEPRECATED("Use entry_stubs + code_pages version.")
-  UnwindState GetUnwindState();
-
-  /**
    * Returns the JSEntryStubs necessary for use with the Unwinder API.
    */
   JSEntryStubs GetJSEntryStubs();
@@ -10689,12 +10716,14 @@ class V8_EXPORT Unwinder {
    *
    * The unwinder also needs the virtual memory range of all possible V8 code
    * objects. There are two ranges required - the heap code range and the range
-   * for code embedded in the binary. The V8 API provides all required inputs
-   * via an UnwindState object through the Isolate::GetUnwindState() API. These
-   * values will not change after Isolate initialization, so the same
-   * |unwind_state| can be used for multiple calls.
+   * for code embedded in the binary.
    *
-   * \param unwind_state Input state for the Isolate that the stack comes from.
+   * Available on x64, ARM64 and ARM32.
+   *
+   * \param code_pages A list of all of the ranges in which V8 has allocated
+   * executable code. The caller should obtain this list by calling
+   * Isolate::CopyCodePages() during the same interrupt/thread suspension that
+   * captures the stack.
    * \param register_state The current registers. This is an in-out param that
    * will be overwritten with the register values after unwinding, on success.
    * \param stack_base The resulting stack pointer and frame pointer values are
@@ -10705,20 +10734,6 @@ class V8_EXPORT Unwinder {
    *
    * \return True on success.
    */
-  // TODO(petermarshall): Remove this API
-  V8_DEPRECATED("Use entry_stubs + code_pages version.")
-  static bool TryUnwindV8Frames(const UnwindState& unwind_state,
-                                RegisterState* register_state,
-                                const void* stack_base);
-
-  /**
-   * The same as above, but is available on x64, ARM64 and ARM32.
-   *
-   * \param code_pages A list of all of the ranges in which V8 has allocated
-   * executable code. The caller should obtain this list by calling
-   * Isolate::CopyCodePages() during the same interrupt/thread suspension that
-   * captures the stack.
-   */
   static bool TryUnwindV8Frames(const JSEntryStubs& entry_stubs,
                                 size_t code_pages_length,
                                 const MemoryRange* code_pages,
@@ -10726,20 +10741,13 @@ class V8_EXPORT Unwinder {
                                 const void* stack_base);
 
   /**
-   * Whether the PC is within the V8 code range represented by code_range or
-   * embedded_code_range in |unwind_state|.
+   * Whether the PC is within the V8 code range represented by code_pages.
    *
    * If this returns false, then calling UnwindV8Frames() with the same PC
    * and unwind_state will always fail. If it returns true, then unwinding may
    * (but not necessarily) be successful.
-   */
-  // TODO(petermarshall): Remove this API
-  V8_DEPRECATED("Use code_pages version.")
-  static bool PCIsInV8(const UnwindState& unwind_state, void* pc);
-
-  /**
-   * The same as above, but is available on x64, ARM64 and ARM32. See the
-   * comment on TryUnwindV8Frames.
+   *
+   * Available on x64, ARM64 and ARM32
    */
   static bool PCIsInV8(size_t code_pages_length, const MemoryRange* code_pages,
                        void* pc);
@@ -11578,6 +11586,13 @@ template <class T> Value* Value::Cast(T* value) {
   return static_cast<Value*>(value);
 }
 
+template <>
+V8_INLINE Value* Value::Cast(Data* value) {
+#ifdef V8_ENABLE_CHECKS
+  CheckCast(value);
+#endif
+  return static_cast<Value*>(value);
+}
 
 Boolean* Boolean::Cast(v8::Value* value) {
 #ifdef V8_ENABLE_CHECKS
@@ -11610,6 +11625,12 @@ Private* Private::Cast(Data* data) {
   return reinterpret_cast<Private*>(data);
 }
 
+Module* Module::Cast(Data* data) {
+#ifdef V8_ENABLE_CHECKS
+  CheckCast(data);
+#endif
+  return reinterpret_cast<Module*>(data);
+}
 
 Number* Number::Cast(v8::Value* value) {
 #ifdef V8_ENABLE_CHECKS
diff --git a/chromium/v8/include/v8config.h b/chromium/v8/include/v8config.h
index bbd1d6ce978..a047874c406 100644
--- a/chromium/v8/include/v8config.h
+++ b/chromium/v8/include/v8config.h
@@ -70,6 +70,7 @@
 //  V8_OS_POSIX         - POSIX compatible (mostly everything except Windows)
 //  V8_OS_QNX           - QNX Neutrino
 //  V8_OS_SOLARIS       - Sun Solaris and OpenSolaris
+//  V8_OS_STARBOARD     - Starboard (platform abstraction for Cobalt)
 //  V8_OS_AIX           - AIX
 //  V8_OS_WIN           - Microsoft Windows
 
@@ -93,6 +94,8 @@
 #elif defined(__sun)
 # define V8_OS_POSIX 1
 # define V8_OS_SOLARIS 1
+#elif defined(STARBOARD)
+# define V8_OS_STARBOARD 1
 #elif defined(_AIX)
 #define V8_OS_POSIX 1
 #define V8_OS_AIX 1
@@ -479,6 +482,15 @@ V8 shared library set USING_V8_SHARED.
 
 #endif  // V8_OS_WIN
 
+// Support for floating point parameters in calls to C.
+// It's currently enabled only for the platforms listed below. We don't plan
+// to add support for IA32, because it has a totally different approach
+// (using FP stack). As support is added to more platforms, please make sure
+// to list them here in order to enable tests of this functionality.
+#if defined(V8_TARGET_ARCH_X64)
+#define V8_ENABLE_FP_PARAMS_IN_C_LINKAGE
+#endif
+
 // clang-format on
 
 #endif  // V8CONFIG_H_