Create TaskAttributionTiming PerformanceEntry for attribution in...

Create TaskAttributionTiming PerformanceEntry for attribution in PerformanceLongTaskTiming. Move culprit-frame-related fields in there

BUG=676484

Review-Url: https://codereview.chromium.org/2610063006
Cr-Commit-Position: refs/heads/master@{#441814}

third_party/WebKit/LayoutTests/fast/performance/longtasktiming.html

@@ -7,17 +7,27 @@ async_test(function (t) {
     var observer = new PerformanceObserver(
         t.step_func(function (entryList) {
             var entries = entryList.getEntries();
-            /* TODO(panicker): Update after fixing http://crbug.com/651461 */
-            for (var i = 0; i < entries.length; i++) {
-                assert_equals(entries[i].entryType, "longtask",
-                    "entryType expected to be: longtask");
-                assert_equals(entries[i].name, "same-origin-self",
-                    "name expected to be: same-origin-self");
-                assert_greater_than(entries[i].duration, 50,
-                    "duration expected to be greater than 50ms threshold");
-                assert_equals(entries[i].startTime, Math.floor(entries[i].startTime),
-                    "startTime expected to have 1 miilisecond granularity");
-            }
+            assert_equals(entries.length, 1,
+                "Exactly one entry is expected.");
+            var longtask = entries[0];
+            assert_equals(longtask.entryType, "longtask",
+                "entryType expected to be: longtask");
+            assert_equals(longtask.name, "same-origin-self",
+                "name expected to be: same-origin-self");
+            assert_greater_than(longtask.duration, 50,
+                "duration expected to be greater than 50ms threshold");
+            assert_equals(longtask.startTime, Math.floor(longtask.startTime),
+                "startTime expected to have 1 miillisecond granularity");
+
+            // Assert the TaskAttributionTiming entry in attribution.
+            assert_equals(longtask.attribution.length, 1,
+                "Exactly one attribution entry is expected");
+            var attribution = longtask.attribution[0];
+            assert_equals(attribution.entryType, "taskattribution");
+            assert_equals(attribution.name, "frame");
+            assert_equals(attribution.duration, 0);
+            assert_equals(attribution.startTime, 0);
+
             observer.disconnect();
             t.done();
         })

third_party/WebKit/LayoutTests/webexposed/global-interface-listing-expected.txt

@@ -4567,9 +4567,7 @@ interface PerformanceEntry
     method toJSON
 interface PerformanceLongTaskTiming : PerformanceEntry
     attribute @@toStringTag
-    getter culpritFrameId
-    getter culpritFrameName
-    getter culpritFrameSrc
+    getter attribution
     method constructor
 interface PerformanceMark : PerformanceEntry
     attribute @@toStringTag
@@ -6455,6 +6453,12 @@ interface SyncManager
     method constructor
     method getTags
     method register
+interface TaskAttributionTiming : PerformanceEntry
+    attribute @@toStringTag
+    getter frameId
+    getter frameName
+    getter frameSrc
+    method constructor
 interface Text : CharacterData
     attribute @@toStringTag
     getter assignedSlot

third_party/WebKit/Source/core/core_idl_files.gni

@@ -401,6 +401,7 @@ core_idl_files = get_path_info([
                                  "timing/PerformanceObserverEntryList.idl",
                                  "timing/PerformanceResourceTiming.idl",
                                  "timing/PerformanceTiming.idl",
+                                 "timing/TaskAttributionTiming.idl",
                                  "timing/WorkerPerformance.idl",
                                  "workers/SharedWorker.idl",
                                  "workers/Worker.idl",

third_party/WebKit/Source/core/timing/BUILD.gn

@@ -34,6 +34,8 @@ blink_core_sources("timing") {
     "PerformanceUserTiming.cpp",
     "PerformanceUserTiming.h",
     "SharedWorkerPerformance.cpp",
+    "TaskAttributionTiming.cpp",
+    "TaskAttributionTiming.h",
     "WorkerGlobalScopePerformance.cpp",
     "WorkerGlobalScopePerformance.h",
     "WorkerPerformance.cpp",

third_party/WebKit/Source/core/timing/PerformanceBase.cpp

@@ -133,12 +133,6 @@ PerformanceEntryVector PerformanceBase::getEntriesByType(
       PerformanceEntry::toEntryTypeEnum(entryType);
 
   switch (type) {
-    case PerformanceEntry::Invalid:
-      return entries;
-    case PerformanceEntry::LongTask:
-      // Unsupported for LongTask. Per the spec, Long task entries can only be
-      // accessed via Performance Observer. No separate buffer is maintained.
-      return entries;
     case PerformanceEntry::Resource:
       for (const auto& resource : m_resourceTimingBuffer)
         entries.append(resource);
@@ -163,6 +157,15 @@ PerformanceEntryVector PerformanceBase::getEntriesByType(
       if (m_userTiming)
         entries.appendVector(m_userTiming->getMeasures());
       break;
+    // Unsupported for LongTask, TaskAttribution.
+    // Per the spec, these entries can only be accessed via
+    // Performance Observer. No separate buffer is maintained.
+    case PerformanceEntry::LongTask:
+      break;
+    case PerformanceEntry::TaskAttribution:
+      break;
+    case PerformanceEntry::Invalid:
+      break;
   }
 
   std::sort(entries.begin(), entries.end(),
@@ -428,15 +431,15 @@ bool PerformanceBase::isFrameTimingBufferFull() {
 void PerformanceBase::addLongTaskTiming(double startTime,
                                         double endTime,
                                         const String& name,
-                                        const String& culpritFrameSrc,
-                                        const String& culpritFrameId,
-                                        const String& culpritFrameName) {
+                                        const String& frameSrc,
+                                        const String& frameId,
+                                        const String& frameName) {
   if (!hasObserverFor(PerformanceEntry::LongTask))
     return;
   PerformanceEntry* entry = PerformanceLongTaskTiming::create(
       monotonicTimeToDOMHighResTimeStamp(startTime),
-      monotonicTimeToDOMHighResTimeStamp(endTime), name, culpritFrameSrc,
-      culpritFrameId, culpritFrameName);
+      monotonicTimeToDOMHighResTimeStamp(endTime), name, frameSrc, frameId,
+      frameName);
   notifyObserversOfEntry(*entry);
 }
 

third_party/WebKit/Source/core/timing/PerformanceEntry.cpp

@@ -79,6 +79,8 @@ PerformanceEntry::EntryType PerformanceEntry::toEntryTypeEnum(
     return Resource;
   if (entryType == "navigation")
     return Navigation;
+  if (entryType == "taskattribution")
+    return TaskAttribution;
   return Invalid;
 }
 

third_party/WebKit/Source/core/timing/PerformanceEntry.h

@@ -63,6 +63,7 @@ class CORE_EXPORT PerformanceEntry
     Render = 1 << 4,
     Resource = 1 << 5,
     LongTask = 1 << 6,
+    TaskAttribution = 1 << 7,
   };
 
   String name() const;

third_party/WebKit/Source/core/timing/PerformanceLongTaskTiming.cpp

@@ -5,6 +5,7 @@
 #include "core/timing/PerformanceLongTaskTiming.h"
 
 #include "core/frame/DOMWindow.h"
+#include "core/timing/TaskAttributionTiming.h"
 
 namespace blink {
 
@@ -17,6 +18,17 @@ double clampToMillisecond(double timeInMillis) {
 
 }  // namespace
 
+// static
+PerformanceLongTaskTiming* PerformanceLongTaskTiming::create(double startTime,
+                                                             double endTime,
+                                                             String name,
+                                                             String frameSrc,
+                                                             String frameId,
+                                                             String frameName) {
+  return new PerformanceLongTaskTiming(startTime, endTime, name, frameSrc,
+                                       frameId, frameName);
+}
+
 PerformanceLongTaskTiming::PerformanceLongTaskTiming(double startTime,
                                                      double endTime,
                                                      String name,
@@ -26,26 +38,21 @@ PerformanceLongTaskTiming::PerformanceLongTaskTiming(double startTime,
     : PerformanceEntry(name,
                        "longtask",
                        clampToMillisecond(startTime),
-                       clampToMillisecond(endTime)),
-      m_culpritFrameSrc(culpritFrameSrc),
-      m_culpritFrameId(culpritFrameId),
-      m_culpritFrameName(culpritFrameName) {}
-
-PerformanceLongTaskTiming::~PerformanceLongTaskTiming() {}
-
-String PerformanceLongTaskTiming::culpritFrameSrc() const {
-  return m_culpritFrameSrc;
+                       clampToMillisecond(endTime)) {
+  // Only one possible name ("frame") currently.
+  TaskAttributionTiming* attributionEntry = TaskAttributionTiming::create(
+      "frame", culpritFrameSrc, culpritFrameId, culpritFrameName);
+  m_attribution.append(*attributionEntry);
 }
 
-String PerformanceLongTaskTiming::culpritFrameId() const {
-  return m_culpritFrameId;
-}
+PerformanceLongTaskTiming::~PerformanceLongTaskTiming() {}
 
-String PerformanceLongTaskTiming::culpritFrameName() const {
-  return m_culpritFrameName;
+TaskAttributionVector PerformanceLongTaskTiming::attribution() const {
+  return m_attribution;
 }
 
 DEFINE_TRACE(PerformanceLongTaskTiming) {
+  visitor->trace(m_attribution);
   PerformanceEntry::trace(visitor);
 }
 

third_party/WebKit/Source/core/timing/PerformanceLongTaskTiming.h

@@ -12,6 +12,9 @@
 
 namespace blink {
 
+class TaskAttributionTiming;
+using TaskAttributionVector = HeapVector<Member<TaskAttributionTiming>>;
+
 class PerformanceLongTaskTiming final : public PerformanceEntry {
   DEFINE_WRAPPERTYPEINFO();
 
@@ -19,17 +22,11 @@ class PerformanceLongTaskTiming final : public PerformanceEntry {
   static PerformanceLongTaskTiming* create(double startTime,
                                            double endTime,
                                            String name,
-                                           String culpritFrameSrc,
-                                           String culpritFrameId,
-                                           String culpritFrameName) {
-    return new PerformanceLongTaskTiming(startTime, endTime, name,
-                                         culpritFrameSrc, culpritFrameId,
-                                         culpritFrameName);
-  }
-
-  String culpritFrameSrc() const;
-  String culpritFrameId() const;
-  String culpritFrameName() const;
+                                           String frameSrc,
+                                           String frameId,
+                                           String frameName);
+
+  TaskAttributionVector attribution() const;
 
   DECLARE_VIRTUAL_TRACE();
 
@@ -37,14 +34,12 @@ class PerformanceLongTaskTiming final : public PerformanceEntry {
   PerformanceLongTaskTiming(double startTime,
                             double endTime,
                             String name,
-                            String culpritFrameSrc,
-                            String culpritFrameId,
-                            String culpritFrameName);
+                            String frameSrc,
+                            String frameId,
+                            String frameName);
   ~PerformanceLongTaskTiming() override;
 
-  String m_culpritFrameSrc;
-  String m_culpritFrameId;
-  String m_culpritFrameName;
+  TaskAttributionVector m_attribution;
 };
 
 }  // namespace blink

third_party/WebKit/Source/core/timing/PerformanceLongTaskTiming.idl

@@ -2,11 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// https://github.com/spanicker/longtasks
+// https://github.com/wicg/longtasks
 [
     OriginTrialEnabled=LongTaskObserver,
 ] interface PerformanceLongTaskTiming : PerformanceEntry {
-    readonly attribute DOMString culpritFrameSrc;
-    readonly attribute DOMString culpritFrameId;
-    readonly attribute DOMString culpritFrameName;
+    readonly attribute sequence<TaskAttributionTiming> attribution;
 };

third_party/WebKit/Source/core/timing/TaskAttributionTiming.cpp

+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "core/timing/TaskAttributionTiming.h"
+
+#include "core/frame/DOMWindow.h"
+
+namespace blink {
+
+TaskAttributionTiming::TaskAttributionTiming(String name,
+                                             String frameSrc,
+                                             String frameId,
+                                             String frameName)
+    : PerformanceEntry(name, "taskattribution", 0.0, 0.0),
+      m_frameSrc(frameSrc),
+      m_frameId(frameId),
+      m_frameName(frameName) {}
+
+TaskAttributionTiming::~TaskAttributionTiming() {}
+
+String TaskAttributionTiming::frameSrc() const {
+  return m_frameSrc;
+}
+
+String TaskAttributionTiming::frameId() const {
+  return m_frameId;
+}
+
+String TaskAttributionTiming::frameName() const {
+  return m_frameName;
+}
+
+DEFINE_TRACE(TaskAttributionTiming) {
+  PerformanceEntry::trace(visitor);
+}
+
+}  // namespace blink

third_party/WebKit/Source/core/timing/TaskAttributionTiming.h

+// Copyright 2017 The Chromium 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 TaskAttributionTiming_h
+#define TaskAttributionTiming_h
+
+#include "core/timing/PerformanceEntry.h"
+#include "platform/heap/Handle.h"
+#include "wtf/Forward.h"
+#include "wtf/text/WTFString.h"
+
+namespace blink {
+
+class TaskAttributionTiming final : public PerformanceEntry {
+  DEFINE_WRAPPERTYPEINFO();
+
+ public:
+  static TaskAttributionTiming* create(String type,
+                                       String frameSrc,
+                                       String frameId,
+                                       String frameName) {
+    return new TaskAttributionTiming(type, frameSrc, frameId, frameName);
+  }
+
+  String frameSrc() const;
+  String frameId() const;
+  String frameName() const;
+
+  DECLARE_VIRTUAL_TRACE();
+
+  ~TaskAttributionTiming() override;
+
+ private:
+  TaskAttributionTiming(String type,
+                        String frameSrc,
+                        String frameId,
+                        String frameName);
+
+  String m_frameSrc;
+  String m_frameId;
+  String m_frameName;
+};
+
+}  // namespace blink
+
+#endif  // TaskAttributionTiming_h

third_party/WebKit/Source/core/timing/TaskAttributionTiming.idl

+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// https://github.com/wicg/longtasks
+[
+    OriginTrialEnabled=LongTaskObserver,
+] interface TaskAttributionTiming : PerformanceEntry {
+    readonly attribute DOMString frameSrc;
+    readonly attribute DOMString frameId;
+    readonly attribute DOMString frameName;
+};