libv8 7.8.279.23.0beta1-x86_64-linux → 8.4.255.0.1-x86_64-linux

data/vendor/v8/include/cppgc/visitor.h

@@ -0,0 +1,137 @@
+// Copyright 2020 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 INCLUDE_CPPGC_VISITOR_H_
+#define INCLUDE_CPPGC_VISITOR_H_
+
+#include "cppgc/garbage-collected.h"
+#include "cppgc/internal/logging.h"
+#include "cppgc/internal/pointer-policies.h"
+#include "cppgc/liveness-broker.h"
+#include "cppgc/member.h"
+#include "cppgc/source-location.h"
+#include "cppgc/trace-trait.h"
+
+namespace cppgc {
+namespace internal {
+class VisitorBase;
+}  // namespace internal
+
+using WeakCallback = void (*)(const LivenessBroker&, const void*);
+
+/**
+ * Visitor passed to trace methods. All managed pointers must have called the
+ * visitor's trace method on them.
+ */
+class Visitor {
+ public:
+  template <typename T>
+  void Trace(const Member<T>& member) {
+    const T* value = member.GetRawAtomic();
+    CPPGC_DCHECK(value != kSentinelPointer);
+    Trace(value);
+  }
+
+  template <typename T>
+  void Trace(const WeakMember<T>& weak_member) {
+    static_assert(sizeof(T), "T must be fully defined");
+    static_assert(internal::IsGarbageCollectedType<T>::value,
+                  "T must be GarabgeCollected or GarbageCollectedMixin type");
+
+    const T* value = weak_member.GetRawAtomic();
+
+    // Bailout assumes that WeakMember emits write barrier.
+    if (!value) {
+      return;
+    }
+
+    // TODO(chromium:1056170): DCHECK (or similar) for deleted values as they
+    // should come in at a different path.
+    VisitWeak(value, TraceTrait<T>::GetTraceDescriptor(value),
+              &HandleWeak<WeakMember<T>>, &weak_member);
+  }
+
+  template <typename Persistent,
+            std::enable_if_t<Persistent::IsStrongPersistent::value>* = nullptr>
+  void TraceRoot(const Persistent& p, const SourceLocation& loc) {
+    using PointeeType = typename Persistent::PointeeType;
+    static_assert(sizeof(PointeeType),
+                  "Persistent's pointee type must be fully defined");
+    static_assert(internal::IsGarbageCollectedType<PointeeType>::value,
+                  "Persisent's pointee type must be GarabgeCollected or "
+                  "GarbageCollectedMixin");
+    if (!p.Get()) {
+      return;
+    }
+    VisitRoot(p.Get(), TraceTrait<PointeeType>::GetTraceDescriptor(p.Get()),
+              loc);
+  }
+
+  template <typename Persistent,
+            std::enable_if_t<!Persistent::IsStrongPersistent::value>* = nullptr>
+  void TraceRoot(const Persistent& p, const SourceLocation& loc) {
+    using PointeeType = typename Persistent::PointeeType;
+    static_assert(sizeof(PointeeType),
+                  "Persistent's pointee type must be fully defined");
+    static_assert(internal::IsGarbageCollectedType<PointeeType>::value,
+                  "Persisent's pointee type must be GarabgeCollected or "
+                  "GarbageCollectedMixin");
+    VisitWeakRoot(&p, &HandleWeak<Persistent>);
+  }
+
+  template <typename T, void (T::*method)(const LivenessBroker&)>
+  void RegisterWeakCallbackMethod(const T* obj) {
+    RegisterWeakCallback(&WeakCallbackMethodDelegate<T, method>, obj);
+  }
+
+  virtual void RegisterWeakCallback(WeakCallback, const void*) {}
+
+ protected:
+  virtual void Visit(const void* self, TraceDescriptor) {}
+  virtual void VisitWeak(const void* self, TraceDescriptor, WeakCallback,
+                         const void* weak_member) {}
+  virtual void VisitRoot(const void*, TraceDescriptor,
+                         const SourceLocation& loc) {}
+  virtual void VisitWeakRoot(const void*, WeakCallback) {}
+
+ private:
+  template <typename T, void (T::*method)(const LivenessBroker&)>
+  static void WeakCallbackMethodDelegate(const LivenessBroker& info,
+                                         const void* self) {
+    // Callback is registered through a potential const Trace method but needs
+    // to be able to modify fields. See HandleWeak.
+    (const_cast<T*>(static_cast<const T*>(self))->*method)(info);
+  }
+
+  template <typename PointerType>
+  static void HandleWeak(const LivenessBroker& info, const void* object) {
+    const PointerType* weak = static_cast<const PointerType*>(object);
+    const auto* raw = weak->Get();
+    if (raw && !info.IsHeapObjectAlive(raw)) {
+      // Object is passed down through the marker as const. Alternatives are
+      // - non-const Trace method;
+      // - mutable pointer in MemberBase;
+      const_cast<PointerType*>(weak)->Clear();
+    }
+  }
+
+  Visitor() = default;
+
+  template <typename T>
+  void Trace(const T* t) {
+    static_assert(sizeof(T), "T must be fully defined");
+    static_assert(internal::IsGarbageCollectedType<T>::value,
+                  "T must be GarabgeCollected or GarbageCollectedMixin type");
+    if (!t) {
+      return;
+    }
+    Visit(t, TraceTrait<T>::GetTraceDescriptor(t));
+  }
+
+  friend class internal::VisitorBase;
+};
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_VISITOR_H_

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

@@ -5,10 +5,12 @@
 #ifndef V8_LIBPLATFORM_LIBPLATFORM_H_
 #define V8_LIBPLATFORM_LIBPLATFORM_H_
 
+#include <memory>
+
 #include "libplatform/libplatform-export.h"
 #include "libplatform/v8-tracing.h"
-#include "v8-platform.h"  // NOLINT(build/include)
-#include "v8config.h"     // NOLINT(build/include)
+#include "v8-platform.h"  // NOLINT(build/include_directory)
+#include "v8config.h"     // NOLINT(build/include_directory)
 
 namespace v8 {
 namespace platform {
@@ -45,9 +47,11 @@ V8_PLATFORM_EXPORT std::unique_ptr<v8::Platform> NewDefaultPlatform(
  * 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|.
+ * Returns true if a task was executed, and false otherwise. If the call to
+ * PumpMessageLoop is nested within another call to PumpMessageLoop, only
+ * nestable tasks may run. Otherwise, any task may run. 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,
@@ -70,11 +74,10 @@ V8_PLATFORM_EXPORT void RunIdleTasks(v8::Platform* 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));
+V8_DEPRECATE_SOON("Access the DefaultPlatform directly")
+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

@@ -12,9 +12,12 @@
 #include <vector>
 
 #include "libplatform/libplatform-export.h"
-#include "v8-platform.h"  // NOLINT(build/include)
+#include "v8-platform.h"  // NOLINT(build/include_directory)
 
 namespace perfetto {
+namespace trace_processor {
+class TraceProcessorStorage;
+}
 class TracingSession;
 }
 
@@ -28,14 +31,13 @@ namespace platform {
 namespace tracing {
 
 class TraceEventListener;
-class JSONTraceEventListener;
 
 const int kTraceMaxNumArgs = 2;
 
 class V8_PLATFORM_EXPORT TraceObject {
  public:
   union ArgValue {
-    bool as_bool;
+    V8_DEPRECATED("use as_uint ? true : false") bool as_bool;
     uint64_t as_uint;
     int64_t as_int;
     double as_double;
@@ -197,6 +199,9 @@ class V8_PLATFORM_EXPORT TraceConfig {
 
   TraceConfig() : enable_systrace_(false), enable_argument_filter_(false) {}
   TraceRecordMode GetTraceRecordMode() const { return record_mode_; }
+  const StringList& GetEnabledCategories() const {
+    return included_categories_;
+  }
   bool IsSystraceEnabled() const { return enable_systrace_; }
   bool IsArgumentFilterEnabled() const { return enable_argument_filter_; }
 
@@ -229,6 +234,17 @@ class V8_PLATFORM_EXPORT TraceConfig {
 class V8_PLATFORM_EXPORT TracingController
     : public V8_PLATFORM_NON_EXPORTED_BASE(v8::TracingController) {
  public:
+  TracingController();
+  ~TracingController() override;
+
+#if defined(V8_USE_PERFETTO)
+  // Must be called before StartTracing() if V8_USE_PERFETTO is true. Provides
+  // the output stream for the JSON trace data.
+  void InitializeForPerfetto(std::ostream* output_stream);
+  // Provide an optional listener for testing that will receive trace events.
+  // Must be called before StartTracing().
+  void SetTraceEventListenerForTesting(TraceEventListener* listener);
+#else   // defined(V8_USE_PERFETTO)
   // The pointer returned from GetCategoryGroupEnabled() 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
@@ -242,19 +258,8 @@ class V8_PLATFORM_EXPORT TracingController
     ENABLED_FOR_ETW_EXPORT = 1 << 3
   };
 
-  TracingController();
-  ~TracingController() override;
-
   // Takes ownership of |trace_buffer|.
   void Initialize(TraceBuffer* trace_buffer);
-#ifdef V8_USE_PERFETTO
-  // Must be called before StartTracing() if V8_USE_PERFETTO is true. Provides
-  // the output stream for the JSON trace data.
-  void InitializeForPerfetto(std::ostream* output_stream);
-  // Provide an optional listener for testing that will receive trace events.
-  // Must be called before StartTracing().
-  void SetTraceEventListenerForTesting(TraceEventListener* listener);
-#endif
 
   // v8::TracingController implementation.
   const uint8_t* GetCategoryGroupEnabled(const char* category_group) override;
@@ -274,6 +279,10 @@ class V8_PLATFORM_EXPORT TracingController
       unsigned int flags, int64_t timestamp) override;
   void UpdateTraceEventDuration(const uint8_t* category_enabled_flag,
                                 const char* name, uint64_t handle) override;
+
+  static const char* GetCategoryGroupName(const uint8_t* category_enabled_flag);
+#endif  // !defined(V8_USE_PERFETTO)
+
   void AddTraceStateObserver(
       v8::TracingController::TraceStateObserver* observer) override;
   void RemoveTraceStateObserver(
@@ -282,27 +291,32 @@ class V8_PLATFORM_EXPORT TracingController
   void StartTracing(TraceConfig* trace_config);
   void StopTracing();
 
-  static const char* GetCategoryGroupName(const uint8_t* category_enabled_flag);
-
  protected:
+#if !defined(V8_USE_PERFETTO)
   virtual int64_t CurrentTimestampMicroseconds();
   virtual int64_t CurrentCpuTimestampMicroseconds();
+#endif  // !defined(V8_USE_PERFETTO)
 
  private:
+#if !defined(V8_USE_PERFETTO)
   void UpdateCategoryGroupEnabledFlag(size_t category_index);
   void UpdateCategoryGroupEnabledFlags();
+#endif  // !defined(V8_USE_PERFETTO)
 
-  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_;
+  std::unique_ptr<TraceConfig> trace_config_;
   std::atomic_bool recording_{false};
-#ifdef V8_USE_PERFETTO
+  std::unordered_set<v8::TracingController::TraceStateObserver*> observers_;
+
+#if defined(V8_USE_PERFETTO)
   std::ostream* output_stream_ = nullptr;
-  std::unique_ptr<JSONTraceEventListener> json_listener_;
+  std::unique_ptr<perfetto::trace_processor::TraceProcessorStorage>
+      trace_processor_;
   TraceEventListener* listener_for_testing_ = nullptr;
   std::unique_ptr<perfetto::TracingSession> tracing_session_;
-#endif
+#else   // !defined(V8_USE_PERFETTO)
+  std::unique_ptr<TraceBuffer> trace_buffer_;
+#endif  // !defined(V8_USE_PERFETTO)
 
   // Disallow copy and assign
   TracingController(const TracingController&) = delete;