Create TaskAttributionTiming PerformanceEntry for attribution in PerformanceLongTaskTiming. Move cu…

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

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2012 Intel Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 115 matching lines @@
   return entries;
 }
 
 PerformanceEntryVector PerformanceBase::getEntriesByType(
     const String& entryType) {
   PerformanceEntryVector entries;
   PerformanceEntry::EntryType type =
       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);
       break;
     case PerformanceEntry::Navigation:
       if (m_navigationTiming)
         entries.append(m_navigationTiming);
       break;
     case PerformanceEntry::Composite:
     case PerformanceEntry::Render:
       for (const auto& frame : m_frameTimingBuffer) {
         if (type == frame->entryTypeEnum()) {
           entries.append(frame);
         }
       }
       break;
     case PerformanceEntry::Mark:
       if (m_userTiming)
         entries.appendVector(m_userTiming->getMarks());
       break;
     case PerformanceEntry::Measure:
       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;

[Yoav Weiss, 2017/01/06 10:13:05]

Hmm, this is according to spec:
https://w3c.github.io/performance-timeline/#filter-performance-entry-buffer-b...

On top of that "PerformanceObserverInit.entryTypes is a list of valid entryType
names to be observed. The list must not be empty and types not recognized by the
user agent must be ignored."

Both mean that there's no way for developers to detect lack of support for new
entry types and create their own fallbacks for cases it is needed.

Again, not an implementation issue, but IMO a significant spec one. I'll file a
spec bug.  

   }
 
   std::sort(entries.begin(), entries.end(),
             PerformanceEntry::startTimeCompareLessThan);
   return entries;
 }
 
 PerformanceEntryVector PerformanceBase::getEntriesByName(
     const String& name,
     const String& entryType) {
@@ skipping 245 matching lines @@
     dispatchEvent(Event::create(EventTypeNames::frametimingbufferfull));
 }
 
 bool PerformanceBase::isFrameTimingBufferFull() {
   return m_frameTimingBuffer.size() >= m_frameTimingBufferSize;
 }
 
 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);
 }
 
 void PerformanceBase::mark(const String& markName,
                            ExceptionState& exceptionState) {
   if (!m_userTiming)
     m_userTiming = UserTiming::create(*this);
   if (PerformanceEntry* entry = m_userTiming->mark(markName, exceptionState))
     notifyObserversOfEntry(*entry);
 }
@@ skipping 122 matching lines @@
   visitor->trace(m_resourceTimingBuffer);
   visitor->trace(m_navigationTiming);
   visitor->trace(m_userTiming);
   visitor->trace(m_observers);
   visitor->trace(m_activeObservers);
   visitor->trace(m_suspendedObservers);
   EventTargetWithInlineData::trace(visitor);
 }
 
 }  // namespace blink