Tencent · etkmao · Jun 8, 2023 · Jun 8, 2023 · Jun 8, 2023 · Jun 9, 2023
@@ -28,6 +28,8 @@
 #include "footstone/string_view.h"
 #include "driver/performance/performance_entry.h"
 #include "driver/performance/performance_resource_timing.h"
+#include "driver/performance/performance_navigation_timing.h"
+#include "driver/performance/performance_paint_timing.h"
 
 namespace hippy {
 inline namespace driver {
@@ -54,6 +56,10 @@ class Performance {
     return time_origin_;
   }
 
+  std::shared_ptr<PerformanceNavigationTiming> PerformanceNavigation(const string_view& name);
+  std::shared_ptr<PerformancePaintTiming> PerformancePaint(const PerformancePaintTiming::Type& type);
+  std::shared_ptr<PerformanceResourceTiming> PerformanceResource(const string_view& name);
+
   void Mark(const string_view& name);
   void ClearMarks(const string_view& name);
   void ClearMarks();
@@ -67,8 +73,8 @@ class Performance {
   void ClearResourceTimings();
   std::vector<std::shared_ptr<PerformanceEntry>> GetEntries(const PerformanceEntryFilterOptions& options);
   std::vector<std::shared_ptr<PerformanceEntry>> GetEntries();
-  std::shared_ptr<PerformanceEntry> GetEntriesByName(const string_view& name);
-  std::shared_ptr<PerformanceEntry> GetEntriesByName(const string_view& name, PerformanceEntry::Type type);
+  std::vector<std::shared_ptr<PerformanceEntry>> GetEntriesByName(const string_view& name);
+  std::vector<std::shared_ptr<PerformanceEntry>> GetEntriesByName(const string_view& name, PerformanceEntry::Type type);
   std::vector<std::shared_ptr<PerformanceEntry>> GetEntriesByType(PerformanceEntry::Type type);
   string_view ToJSON();
 

@@ -55,6 +55,12 @@ class PerformanceEntry {
                                          start_time_(start_time),
                                          duration_(duration) {}
 
+  PerformanceEntry(const string_view& name,
+                   SubType sub_type,
+                   Type type) : name_(name),
+                                sub_type_(sub_type),
+                                type_(type) {}
+
   virtual ~PerformanceEntry() = default;
 
   inline auto GetName() const {

@@ -33,62 +33,48 @@ inline namespace performance {
 class PerformanceNavigationTiming : public PerformanceEntry {
  public:
   struct BundleInfo {
-    string_view bundle_url;
-    TimePoint start;
-    TimePoint end;
+    string_view url_;
+    TimePoint execute_source_start_;
+    TimePoint execute_source_end_;
   };
 
-  PerformanceNavigationTiming(const string_view& name, const TimePoint& start,
-                              const TimePoint& engine_initialization_start, const TimePoint& engine_initialization_end,
-                              std::vector<BundleInfo> bundle_info,
-                              const TimePoint& load_instance_start, const TimePoint& load_instance_end,
-                              const TimePoint& first_frame);
+  PerformanceNavigationTiming(const string_view& name);
 
-  inline auto GetEngineInitializationStart() const {
-    return engine_initialization_start_;
+#define DEFINE_SET_AND_GET_METHOD(method_name, member_type, member) \
+  void Set##method_name(member_type t) { \
+    member = t; \
+  } \
+  inline auto Get##method_name() const { \
+    return member; \
   }
+  DEFINE_SET_AND_GET_METHOD(HippyNativeInitStart, TimePoint, hippy_native_init_start_)
+  DEFINE_SET_AND_GET_METHOD(HippyNativeInitEnd, TimePoint, hippy_native_init_end_)
+  DEFINE_SET_AND_GET_METHOD(HippyJsEngineInitStart, TimePoint, hippy_js_engine_init_start_)
+  DEFINE_SET_AND_GET_METHOD(HippyJsEngineInitEnd, TimePoint, hippy_js_engine_init_end_)
+  DEFINE_SET_AND_GET_METHOD(HippyRunApplicationStart, TimePoint, hippy_run_application_start_)
+  DEFINE_SET_AND_GET_METHOD(HippyRunApplicationEnd, TimePoint, hippy_run_application_end_)
+  DEFINE_SET_AND_GET_METHOD(HippyFirstFrameStart, TimePoint, hippy_first_frame_start_)
+  DEFINE_SET_AND_GET_METHOD(HippyFirstFrameEnd, TimePoint, hippy_first_frame_end_)
+#undef DEFINE_SET_AND_GET_METHOD
 
-  inline auto GetEngineInitializationEnd() const {
-    return engine_initialization_end_;
+  inline const std::vector<BundleInfo>& GetBundleInfoArray() const {
+    return bundle_info_array_;
   }
 
-  inline auto GetBundleInfo() const {
-    return bundle_info_;
-  }
-
-  inline auto GetLoadInstanceStart() const {
-    return load_instance_start_;
-  }
-
-  inline auto GetLoadInstanceEnd() const {
-    return load_instance_end_;
-  }
-
-  inline auto GetFirstFrame() const {
-    return first_frame_;
-  }
+  BundleInfo& BundleInfoOfUrl(const string_view& url);
 
   virtual string_view ToJSON() override;
 
  private:
-//  TimePoint dom_complete_;
-//  TimePoint dom_content_loaded_event_end_;
-//  TimePoint dom_content_loaded_event_start_;
-//  TimePoint dom_interactive_;
-//  TimePoint load_event_end_;
-//  TimePoint load_event_start_;
-//  uint32_t redirect_count_;
-//  TimePoint request_start_;
-//  TimePoint response_start_;
-//  string_view type_; // navigate, reload, back_forward or prerender
-//  TimePoint unload_event_end_;
-//  TimePoint unload_event_start_;
-    TimePoint engine_initialization_start_;
-    TimePoint engine_initialization_end_;
-    std::vector<BundleInfo> bundle_info_;
-    TimePoint load_instance_start_;
-    TimePoint load_instance_end_;
-    TimePoint first_frame_;
+  TimePoint hippy_native_init_start_;
+  TimePoint hippy_native_init_end_;
+  TimePoint hippy_js_engine_init_start_;
+  TimePoint hippy_js_engine_init_end_;
+  std::vector<BundleInfo> bundle_info_array_;
+  TimePoint hippy_run_application_start_;
+  TimePoint hippy_run_application_end_;
+  TimePoint hippy_first_frame_start_;
+  TimePoint hippy_first_frame_end_;
 };
 
 }

@@ -36,6 +36,7 @@ class PerformancePaintTiming : public PerformanceEntry {
   };
 
   PerformancePaintTiming(Type type, const TimePoint& start_time);
+  PerformancePaintTiming(Type type);
 
   virtual string_view ToJSON() override;
 

@@ -31,109 +31,32 @@ inline namespace performance {
 class PerformanceResourceTiming: public PerformanceEntry {
  public:
   enum class InitiatorType {
-    AUDIO, BEACON, BODY, CSS, EARLY_HINT, EMBED, FETCH, FRAME, IFRAME, ICON, IMAGE, IMG, INPUT, LINK, NAVIGATION, OBJECT,
+    OTHER, AUDIO, BEACON, BODY, CSS, EARLY_HINT, EMBED, FETCH, FRAME, IFRAME, ICON, IMAGE, IMG, INPUT, LINK, NAVIGATION, OBJECT,
     PING, SCRIPT, TRACK, VIDEO, XMLHTTPREQUEST
   };
 
-  PerformanceResourceTiming(const string_view& name, TimePoint start_time, TimeDelta duration,
-                            const InitiatorType& initiator_type, const string_view& next_hop_protocol, TimePoint worker_start,
-                            TimePoint redirect_start, TimePoint redirect_end, TimePoint fetch_start,
-                            TimePoint domain_lookup_start, TimePoint domain_lookup_end, TimePoint connect_start,
-                            TimePoint connect_end, TimePoint secure_connection_start, TimePoint request_start_,
-                            TimePoint response_start, TimePoint response_end,  uint64_t transfer_size,
-                            uint64_t encoded_body_size, uint64_t decoded_body_size);
+  PerformanceResourceTiming(const string_view& name);
 
-  inline InitiatorType GetInitiatorType() {
-    return initiator_type_;
-  }
-
-  inline string_view GetNextHopProtocol() {
-    return next_hop_protocol_;
-  }
-
-  inline TimePoint GetWorkerStart() {
-    return worker_start_;
-  }
-
-  inline TimePoint GetRedirectStart() {
-    return redirect_start_;
-  }
-
-  inline TimePoint GetRedirectEnd() {
-    return redirect_end_;
-  }
-
-  inline TimePoint GetFetchStart() {
-    return fetch_start_;
-  }
-
-  inline TimePoint GetDomainLookupStart() {
-    return domain_lookup_start_;
-  }
-
-  inline TimePoint GetDomainLookupEnd() {
-    return domain_lookup_end_;
-  }
-
-  inline TimePoint GetConnectStart() {
-    return connect_start_;
-  }
-
-  inline TimePoint GetConnectEnd() {
-    return connect_end_;
-  }
-
-  inline TimePoint GetSecureConnectionStart() {
-    return secure_connection_start_;
-  }
-
-  inline TimePoint GetRequestStart() {
-    return request_start_;
-  }
-
-  inline TimePoint GetResponseStart() {
-    return response_start_;
-  }
-
-  inline TimePoint GetResponseEnd() {
-    return response_end_;
-  }
-
-  inline uint64_t GetTransferSize() {
-    return transfer_size_;
-  }
-
-  inline uint64_t GetEncodedBodySize() {
-    return encoded_body_size_;
-  }
-
-  inline uint64_t GetDecodedBodySize() {
-    return decoded_body_size_;
+#define DEFINE_SET_AND_GET_METHOD(method_name, member_type, member) \
+  void Set##method_name(member_type t) { \
+    member = t; \
+  } \
+  inline auto Get##method_name() const { \
+    return member; \
   }
+  DEFINE_SET_AND_GET_METHOD(InitiatorType, InitiatorType, initiator_type_)
+  DEFINE_SET_AND_GET_METHOD(LoadSourceStart, TimePoint, load_source_start_)
+  DEFINE_SET_AND_GET_METHOD(LoadSourceEnd, TimePoint, load_source_end_)
+#undef DEFINE_SET_AND_GET_METHOD
 
   virtual string_view ToJSON() override;
 
   static string_view GetInitiatorString(InitiatorType type);
 
  private:
-  InitiatorType initiator_type_;
-  string_view next_hop_protocol_;
-  TimePoint worker_start_;
-  TimePoint redirect_start_;
-  TimePoint redirect_end_;
-  TimePoint fetch_start_;
-  TimePoint domain_lookup_start_;
-  TimePoint domain_lookup_end_;
-  TimePoint connect_start_;
-  TimePoint connect_end_;
-  TimePoint secure_connection_start_;
-  TimePoint request_start_;
-  TimePoint response_start_;
-  TimePoint response_end_;
-  uint64_t transfer_size_;
-  uint64_t encoded_body_size_;
-  uint64_t decoded_body_size_;
-  // std::vector<> server_timing_{};
+  InitiatorType initiator_type_ = InitiatorType::OTHER;
+  TimePoint load_source_start_;
+  TimePoint load_source_end_;
 };
 
 }

@@ -136,6 +136,7 @@ class Scope : public std::enable_shared_from_this<Scope> {
   using Encoding = hippy::napi::Encoding;
   using TaskRunner = footstone::runner::TaskRunner;
   using Task = footstone::Task;
+  using TimePoint = footstone::TimePoint;
 
 #ifdef ENABLE_INSPECTOR
   using DevtoolsDataSource = hippy::devtools::DevtoolsDataSource;
@@ -241,6 +242,7 @@ class Scope : public std::enable_shared_from_this<Scope> {
   uint64_t GetListenerId(const EventListenerInfo& event_listener_info);
 
   void RunJS(const string_view& js,
+             const string_view& uri,
              const string_view& name,
              bool is_copy = true);
 
@@ -270,6 +272,22 @@ class Scope : public std::enable_shared_from_this<Scope> {
 
   inline void SetUriLoader(std::weak_ptr<UriLoader> loader) {
     loader_ = loader;
+    auto the_loader = loader_.lock();
+    if (the_loader) {
+      the_loader->SetRequestTimePerformanceCallback([WEAK_THIS](const string_view& uri, const TimePoint& start, const TimePoint& end) {
+        DEFINE_AND_CHECK_SELF(Scope)
+        auto runner = self->GetTaskRunner();
+        if (runner) {
+          auto task = [weak_this, uri, start, end]() {
+            DEFINE_AND_CHECK_SELF(Scope)
+            auto entry = self->GetPerformance()->PerformanceResource(uri);
+            entry->SetLoadSourceStart(start);
+            entry->SetLoadSourceEnd(end);
+          };
+          runner->PostTask(std::move(task));
+        }
+      });
+    }
   }
 
   inline std::weak_ptr<UriLoader> GetUriLoader() { return loader_; }

@@ -320,6 +320,11 @@ bool JsDriverUtils::RunScript(const std::shared_ptr<Scope>& scope,
                            << ", script content empty, uri = " << uri;
     return false;
   }
+
+  // perfromance start time
+  auto entry = scope->GetPerformance()->PerformanceNavigation("hippyInit");
+  entry->BundleInfoOfUrl(uri).execute_source_start_ = footstone::TimePoint::SystemNow();
+
 #ifdef JS_V8
   auto ret = std::static_pointer_cast<V8Ctx>(scope->GetContext())->RunScript(
       script_content, file_name, is_use_code_cache,&code_cache_content, true);
@@ -357,8 +362,12 @@ bool JsDriverUtils::RunScript(const std::shared_ptr<Scope>& scope,
   auto ret = scope->GetContext()->RunScript(script_content, file_name);
 #endif
 
+  // perfromance end time
+  entry->BundleInfoOfUrl(uri).execute_source_end_ = footstone::TimePoint::SystemNow();
+
   auto flag = (ret != nullptr);
   FOOTSTONE_LOG(INFO) << "runScript end, flag = " << flag;
+
   return flag;
 }
 

@@ -175,7 +175,7 @@ void ContextifyModule::LoadUntrustedContent(CallbackInfo& info, void* data) {
         auto try_catch = CreateTryCatchScope(true, scope->GetContext());
         try_catch->SetVerbose(true);
         string_view view_code(reinterpret_cast<const string_view::char8_t_ *>(move_code.c_str()), move_code.length());
-        scope->RunJS(view_code, file_name);
+        scope->RunJS(view_code, uri, file_name);
         ctx->SetProperty(global_object, cur_dir_key, last_dir_str_obj, hippy::napi::PropertyAttribute::ReadOnly);
         if (try_catch->HasCaught()) {
           error = try_catch->Exception();

@@ -63,12 +63,12 @@ std::shared_ptr<ClassTemplate<PerformanceEntry>> RegisterPerformanceEntry(const
       return nullptr;
     }
 
-    auto entry = scope->GetPerformance()->GetEntriesByName(name, static_cast<PerformanceEntry::Type>(type));
-    if (!entry) {
+    auto entries = scope->GetPerformance()->GetEntriesByName(name, static_cast<PerformanceEntry::Type>(type));
+    if (entries.empty()) {
       exception = context->CreateException("entry not found");
       return nullptr;
     }
-    return entry;
+    return entries.back();
   };
   return std::make_shared<ClassTemplate<PerformanceEntry>>(std::move(class_template));
 }

@@ -63,12 +63,12 @@ std::shared_ptr<ClassTemplate<PerformanceFrameTiming>> RegisterPerformanceFrameT
       return nullptr;
     }
 
-    auto entry = scope->GetPerformance()->GetEntriesByName(name, static_cast<PerformanceEntry::Type>(type));
-    if (!entry) {
+    auto entries = scope->GetPerformance()->GetEntriesByName(name, static_cast<PerformanceEntry::Type>(type));
+    if (entries.empty()) {
       exception = context->CreateException("entry not found");
       return nullptr;
     }
-    return std::static_pointer_cast<PerformanceFrameTiming>(entry);
+    return std::static_pointer_cast<PerformanceFrameTiming>(entries.back());
   };
 
   return std::make_shared<ClassTemplate<PerformanceFrameTiming>>(std::move(class_template));