Use Frame's devtools_frame_token_ when using it in trace events

This token is globally-unqiue and has the same value between browser
and renderer. By using it in trace events, one can match frame attribution
for browser and renderer trace events. This will be used to at least
support OOPIFs in DevTools Performance panel in the future.

Bug: 820250
Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2
Change-Id: I932be92154220731dfdc5998614c281b419dc1aa
Reviewed-on: https://chromium-review.googlesource.com/956522
Commit-Queue: Dmitry Gozman <dgozman@chromium.org>
Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Cr-Commit-Position: refs/heads/master@{#543274}

third_party/WebKit/Source/core/css/StyleEngine.cpp

@@ -553,7 +553,7 @@ void StyleEngine::ClearResolvers() {
 
   if (resolver_) {
     TRACE_EVENT1("blink", "StyleEngine::clearResolver", "frame",
-                 GetDocument().GetFrame());
+                 ToTraceValue(GetDocument().GetFrame()));
     resolver_->Dispose();
     resolver_.Clear();
   }

third_party/WebKit/Source/core/dom/DocumentTiming.cpp

@@ -5,6 +5,7 @@
 #include "core/dom/DocumentTiming.h"
 
 #include "core/dom/Document.h"
+#include "core/frame/LocalFrame.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/InteractiveDetector.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
@@ -29,14 +30,16 @@ void DocumentTiming::NotifyDocumentTimingChanged() {
 void DocumentTiming::MarkDomLoading() {
   dom_loading_ = CurrentTimeTicks();
   TRACE_EVENT_MARK_WITH_TIMESTAMP1("blink.user_timing,rail", "domLoading",
-                                   dom_loading_, "frame", GetFrame());
+                                   dom_loading_, "frame",
+                                   ToTraceValue(GetFrame()));
   NotifyDocumentTimingChanged();
 }
 
 void DocumentTiming::MarkDomInteractive() {
   dom_interactive_ = CurrentTimeTicks();
   TRACE_EVENT_MARK_WITH_TIMESTAMP1("blink.user_timing,rail", "domInteractive",
-                                   dom_interactive_, "frame", GetFrame());
+                                   dom_interactive_, "frame",
+                                   ToTraceValue(GetFrame()));
   NotifyDocumentTimingChanged();
 }
 
@@ -44,7 +47,7 @@ void DocumentTiming::MarkDomContentLoadedEventStart() {
   dom_content_loaded_event_start_ = CurrentTimeTicks();
   TRACE_EVENT_MARK_WITH_TIMESTAMP1(
       "blink.user_timing,rail", "domContentLoadedEventStart",
-      dom_content_loaded_event_start_, "frame", GetFrame());
+      dom_content_loaded_event_start_, "frame", ToTraceValue(GetFrame()));
   NotifyDocumentTimingChanged();
 }
 
@@ -52,7 +55,7 @@ void DocumentTiming::MarkDomContentLoadedEventEnd() {
   dom_content_loaded_event_end_ = CurrentTimeTicks();
   TRACE_EVENT_MARK_WITH_TIMESTAMP1(
       "blink.user_timing,rail", "domContentLoadedEventEnd",
-      dom_content_loaded_event_end_, "frame", GetFrame());
+      dom_content_loaded_event_end_, "frame", ToTraceValue(GetFrame()));
   InteractiveDetector* interactive_detector(
       InteractiveDetector::From(*document_));
   if (interactive_detector) {
@@ -64,14 +67,16 @@ void DocumentTiming::MarkDomContentLoadedEventEnd() {
 void DocumentTiming::MarkDomComplete() {
   dom_complete_ = CurrentTimeTicks();
   TRACE_EVENT_MARK_WITH_TIMESTAMP1("blink.user_timing,rail", "domComplete",
-                                   dom_complete_, "frame", GetFrame());
+                                   dom_complete_, "frame",
+                                   ToTraceValue(GetFrame()));
   NotifyDocumentTimingChanged();
 }
 
 void DocumentTiming::MarkFirstLayout() {
   first_layout_ = CurrentTimeTicks();
   TRACE_EVENT_MARK_WITH_TIMESTAMP1("blink.user_timing,rail", "firstLayout",
-                                   first_layout_, "frame", GetFrame());
+                                   first_layout_, "frame",
+                                   ToTraceValue(GetFrame()));
   NotifyDocumentTimingChanged();
 }
 

third_party/WebKit/Source/core/exported/WebFrame.cpp

@@ -116,7 +116,8 @@ bool WebFrame::Swap(WebFrame* frame) {
       // This trace event is needed to detect the main frame of the
       // renderer in telemetry metrics. See crbug.com/692112#c11.
       TRACE_EVENT_INSTANT1("loading", "markAsMainFrame",
-                           TRACE_EVENT_SCOPE_THREAD, "frame", &local_frame);
+                           TRACE_EVENT_SCOPE_THREAD, "frame",
+                           ToTraceValue(&local_frame));
     }
   } else {
     ToWebRemoteFrameImpl(frame)->InitializeCoreFrame(*page, owner, name);

third_party/WebKit/Source/core/frame/Frame.cpp

@@ -256,6 +256,13 @@ void Frame::UpdateInertIfPossible() {
   }
 }
 
+const CString& Frame::ToTraceValue() {
+  // token's ToString() is latin1.
+  if (!trace_value_)
+    trace_value_ = CString(devtools_frame_token_.ToString().c_str());
+  return trace_value_.value();
+}
+
 Frame::Frame(FrameClient* client,
              Page& page,
              FrameOwner* owner,

third_party/WebKit/Source/core/frame/Frame.h

@@ -40,6 +40,7 @@
 #include "core/page/FrameTree.h"
 #include "platform/heap/Handle.h"
 #include "platform/wtf/Forward.h"
+#include "platform/wtf/Optional.h"
 #include "third_party/WebKit/public/common/feature_policy/feature_policy.h"
 
 namespace blink {
@@ -199,6 +200,7 @@ class CORE_EXPORT Frame : public GarbageCollectedFinalized<Frame> {
   const base::UnguessableToken& GetDevToolsFrameToken() const {
     return devtools_frame_token_;
   }
+  const CString& ToTraceValue();
 
  protected:
   Frame(FrameClient*, Page&, FrameOwner*, WindowProxyManager*);
@@ -236,6 +238,7 @@ class CORE_EXPORT Frame : public GarbageCollectedFinalized<Frame> {
   // TODO(sashab): Investigate if this can be represented with m_lifecycle.
   bool is_loading_;
   base::UnguessableToken devtools_frame_token_;
+  WTF::Optional<CString> trace_value_;
 };
 
 inline FrameClient* Frame::Client() const {
@@ -254,6 +257,14 @@ inline FrameTree& Frame::Tree() const {
 // interchangeably.
 DEFINE_COMPARISON_OPERATORS_WITH_REFERENCES(Frame)
 
+// This method should be used instead of Frame* pointer
+// in a TRACE_EVENT_XXX macro. Example:
+//
+// TRACE_EVENT1("category", "event_name", "frame", ToTraceValue(GetFrame()));
+static inline CString ToTraceValue(Frame* frame) {
+  return frame ? frame->ToTraceValue() : CString();
+}
+
 }  // namespace blink
 
 #endif  // Frame_h

third_party/WebKit/Source/core/frame/WebLocalFrameImpl.cpp

@@ -1795,7 +1795,7 @@ void WebLocalFrameImpl::InitializeCoreFrame(Page& page,
     // This trace event is needed to detect the main frame of the
     // renderer in telemetry metrics. See crbug.com/692112#c11.
     TRACE_EVENT_INSTANT1("loading", "markAsMainFrame", TRACE_EVENT_SCOPE_THREAD,
-                         "frame", frame_);
+                         "frame", ToTraceValue(frame_));
   }
 }
 

third_party/WebKit/Source/core/inspector/IdentifiersFactory.cpp

@@ -65,7 +65,8 @@ String IdentifiersFactory::SubresourceRequestId(unsigned long identifier) {
 
 // static
 String IdentifiersFactory::FrameId(Frame* frame) {
-  return frame ? IdFromToken(frame->GetDevToolsFrameToken()) : g_empty_string;
+  // Note: this should be equal to ToTraceValue(frame).
+  return String(ToTraceValue(frame).data());
 }
 
 // static

third_party/WebKit/Source/core/loader/DocumentLoadTiming.cpp

@@ -26,6 +26,7 @@
 #include "core/loader/DocumentLoadTiming.h"
 
 #include "base/memory/scoped_refptr.h"
+#include "core/frame/LocalFrame.h"
 #include "core/loader/DocumentLoader.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/weborigin/SecurityOrigin.h"
@@ -100,7 +101,8 @@ void DocumentLoadTiming::MarkNavigationStart() {
   EnsureReferenceTimesSet();
   navigation_start_ = reference_monotonic_time_;
   TRACE_EVENT_MARK_WITH_TIMESTAMP1("blink.user_timing", "navigationStart",
-                                   navigation_start_, "frame", GetFrame());
+                                   navigation_start_, "frame",
+                                   ToTraceValue(GetFrame()));
   NotifyDocumentTimingChanged();
 }
 
@@ -111,7 +113,8 @@ void DocumentLoadTiming::SetNavigationStart(TimeTicks navigation_start) {
   EnsureReferenceTimesSet();
   navigation_start_ = navigation_start;
   TRACE_EVENT_MARK_WITH_TIMESTAMP1("blink.user_timing", "navigationStart",
-                                   navigation_start_, "frame", GetFrame());
+                                   navigation_start_, "frame",
+                                   ToTraceValue(GetFrame()));
 
   // The reference times are adjusted based on the embedder's navigationStart.
   DCHECK(!reference_monotonic_time_.is_null());
@@ -140,28 +143,31 @@ void DocumentLoadTiming::AddRedirect(const KURL& redirecting_url,
 void DocumentLoadTiming::SetRedirectStart(TimeTicks redirect_start) {
   redirect_start_ = redirect_start;
   TRACE_EVENT_MARK_WITH_TIMESTAMP1("blink.user_timing", "redirectStart",
-                                   redirect_start_, "frame", GetFrame());
+                                   redirect_start_, "frame",
+                                   ToTraceValue(GetFrame()));
   NotifyDocumentTimingChanged();
 }
 
 void DocumentLoadTiming::SetRedirectEnd(TimeTicks redirect_end) {
   redirect_end_ = redirect_end;
   TRACE_EVENT_MARK_WITH_TIMESTAMP1("blink.user_timing", "redirectEnd",
-                                   redirect_end_, "frame", GetFrame());
+                                   redirect_end_, "frame",
+                                   ToTraceValue(GetFrame()));
   NotifyDocumentTimingChanged();
 }
 
 void DocumentLoadTiming::MarkUnloadEventStart(TimeTicks start_time) {
   unload_event_start_ = start_time;
   TRACE_EVENT_MARK_WITH_TIMESTAMP1("blink.user_timing", "unloadEventStart",
-                                   start_time, "frame", GetFrame());
+                                   start_time, "frame",
+                                   ToTraceValue(GetFrame()));
   NotifyDocumentTimingChanged();
 }
 
 void DocumentLoadTiming::MarkUnloadEventEnd(TimeTicks end_time) {
   unload_event_end_ = end_time;
   TRACE_EVENT_MARK_WITH_TIMESTAMP1("blink.user_timing", "unloadEventEnd",
-                                   end_time, "frame", GetFrame());
+                                   end_time, "frame", ToTraceValue(GetFrame()));
   NotifyDocumentTimingChanged();
 }
 
@@ -172,35 +178,40 @@ void DocumentLoadTiming::MarkFetchStart() {
 void DocumentLoadTiming::SetFetchStart(TimeTicks fetch_start) {
   fetch_start_ = fetch_start;
   TRACE_EVENT_MARK_WITH_TIMESTAMP1("blink.user_timing", "fetchStart",
-                                   fetch_start_, "frame", GetFrame());
+                                   fetch_start_, "frame",
+                                   ToTraceValue(GetFrame()));
   NotifyDocumentTimingChanged();
 }
 
 void DocumentLoadTiming::SetResponseEnd(TimeTicks response_end) {
   response_end_ = response_end;
   TRACE_EVENT_MARK_WITH_TIMESTAMP1("blink.user_timing", "responseEnd",
-                                   response_end_, "frame", GetFrame());
+                                   response_end_, "frame",
+                                   ToTraceValue(GetFrame()));
   NotifyDocumentTimingChanged();
 }
 
 void DocumentLoadTiming::MarkLoadEventStart() {
   load_event_start_ = CurrentTimeTicks();
   TRACE_EVENT_MARK_WITH_TIMESTAMP1("blink.user_timing", "loadEventStart",
-                                   load_event_start_, "frame", GetFrame());
+                                   load_event_start_, "frame",
+                                   ToTraceValue(GetFrame()));
   NotifyDocumentTimingChanged();
 }
 
 void DocumentLoadTiming::MarkLoadEventEnd() {
   load_event_end_ = CurrentTimeTicks();
   TRACE_EVENT_MARK_WITH_TIMESTAMP1("blink.user_timing", "loadEventEnd",
-                                   load_event_end_, "frame", GetFrame());
+                                   load_event_end_, "frame",
+                                   ToTraceValue(GetFrame()));
   NotifyDocumentTimingChanged();
 }
 
 void DocumentLoadTiming::MarkRedirectEnd() {
   redirect_end_ = CurrentTimeTicks();
   TRACE_EVENT_MARK_WITH_TIMESTAMP1("blink.user_timing", "redirectEnd",
-                                   redirect_end_, "frame", GetFrame());
+                                   redirect_end_, "frame",
+                                   ToTraceValue(GetFrame()));
   NotifyDocumentTimingChanged();
 }
 

third_party/WebKit/Source/core/loader/FrameLoader.cpp

@@ -60,6 +60,7 @@
 #include "core/html_names.h"
 #include "core/input/EventHandler.h"
 #include "core/inspector/ConsoleMessage.h"
+#include "core/inspector/IdentifiersFactory.h"
 #include "core/loader/DocumentLoadTiming.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FormSubmission.h"
@@ -1802,10 +1803,7 @@ void FrameLoader::RecordLatestRequiredCSP() {
 std::unique_ptr<TracedValue> FrameLoader::ToTracedValue() const {
   std::unique_ptr<TracedValue> traced_value = TracedValue::Create();
   traced_value->BeginDictionary("frame");
-  traced_value->SetString(
-      "id_ref", String::Format("0x%" PRIx64,
-                               static_cast<uint64_t>(
-                                   reinterpret_cast<uintptr_t>(frame_.Get()))));
+  traced_value->SetString("id_ref", IdentifiersFactory::FrameId(frame_.Get()));
   traced_value->EndDictionary();
   traced_value->SetBoolean("isLoadingMainFrame", IsLoadingMainFrame());
   traced_value->SetString("stateMachine", state_machine_.ToString());

third_party/WebKit/Source/core/loader/InteractiveDetector.cpp

@@ -5,6 +5,7 @@
 #include "core/loader/InteractiveDetector.h"
 
 #include "core/dom/Document.h"
+#include "core/frame/LocalFrame.h"
 #include "core/loader/DocumentLoader.h"
 #include "platform/Histogram.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
@@ -458,8 +459,8 @@ void InteractiveDetector::OnTimeToInteractiveDetected() {
   // with whether that happened.
   TRACE_EVENT_MARK_WITH_TIMESTAMP2(
       "loading,rail", "InteractiveTime", interactive_time_, "frame",
-      GetSupplementable()->GetFrame(), "had_user_input_before_interactive",
-      had_user_input_before_interactive);
+      ToTraceValue(GetSupplementable()->GetFrame()),
+      "had_user_input_before_interactive", had_user_input_before_interactive);
 
   // We only send TTI to Performance Timing Observers if FMP was not invalidated
   // by input.

third_party/WebKit/Source/core/paint/PaintTiming.cpp

@@ -105,9 +105,9 @@ void PaintTiming::SetFirstMeaningfulPaint(
   DCHECK(!stamp.is_null());
   DCHECK(!swap_stamp.is_null());
 
-  TRACE_EVENT_MARK_WITH_TIMESTAMP2("loading,rail,devtools.timeline",
-                                   "firstMeaningfulPaint", swap_stamp, "frame",
-                                   GetFrame(), "afterUserInput", had_input);
+  TRACE_EVENT_MARK_WITH_TIMESTAMP2(
+      "loading,rail,devtools.timeline", "firstMeaningfulPaint", swap_stamp,
+      "frame", ToTraceValue(GetFrame()), "afterUserInput", had_input);
 
   InteractiveDetector* interactive_detector(
       InteractiveDetector::From(*GetSupplementable()));