LongTaskTiming: add idl, Experiment flag, PerformanceEntry and basic implementation

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

Index: third_party/WebKit/Source/core/timing/PerformanceBase.cpp
diff --git a/third_party/WebKit/Source/core/timing/PerformanceBase.cpp b/third_party/WebKit/Source/core/timing/PerformanceBase.cpp
index 2ebfe14288d3c697beb95b292b619a925edd2f0c..33d3ffb9ad98589f2ce184187d97c6633f710ce3 100644
--- a/third_party/WebKit/Source/core/timing/PerformanceBase.cpp
+++ b/third_party/WebKit/Source/core/timing/PerformanceBase.cpp
@@ -35,6 +35,7 @@
 #include "core/events/Event.h"
 #include "core/frame/UseCounter.h"
 #include "core/timing/PerformanceCompositeTiming.h"
+#include "core/timing/PerformanceLongTaskTiming.h"
 #include "core/timing/PerformanceObserver.h"
 #include "core/timing/PerformanceRenderTiming.h"
 #include "core/timing/PerformanceResourceTiming.h"
@@ -50,12 +51,14 @@ using PerformanceObserverVector = HeapVector<Member<PerformanceObserver>>;
 
 static const size_t defaultResourceTimingBufferSize = 150;
 static const size_t defaultFrameTimingBufferSize = 150;
+static const size_t defaultLongTaskTimingBufferSize = 150;
 
 PerformanceBase::PerformanceBase(double timeOrigin)
     : m_frameTimingBufferSize(defaultFrameTimingBufferSize)
     , m_resourceTimingBufferSize(defaultResourceTimingBufferSize)
-    , m_timeOrigin(timeOrigin)
+    , m_longTaskTimingBufferSize(defaultLongTaskTimingBufferSize)
     , m_userTiming(nullptr)
+    , m_timeOrigin(timeOrigin)
     , m_observerFilterOptions(PerformanceEntry::Invalid)
     , m_deliverObservationsTimer(this, &PerformanceBase::deliverObservationsTimerFired)
 {
@@ -81,6 +84,7 @@ PerformanceEntryVector PerformanceBase::getEntries() const
 
     entries.appendVector(m_resourceTimingBuffer);
     entries.appendVector(m_frameTimingBuffer);
+    entries.appendVector(m_longTaskTimingBuffer);
 
     if (m_userTiming) {
         entries.appendVector(m_userTiming->getMarks());
@@ -119,6 +123,10 @@ PerformanceEntryVector PerformanceBase::getEntriesByType(const String& entryType
         if (m_userTiming)
             entries.appendVector(m_userTiming->getMeasures());
         break;
+    case PerformanceEntry::LongTask:
+        for (const auto& longTask : m_longTaskTimingBuffer)
+            entries.append(longTask);
+        break;
     }
 
     std::sort(entries.begin(), entries.end(), PerformanceEntry::startTimeCompareLessThan);
@@ -186,6 +194,18 @@ void PerformanceBase::setFrameTimingBufferSize(unsigned size)
         dispatchEvent(Event::create(EventTypeNames::frametimingbufferfull));
 }
 
+void PerformanceBase::clearLongTaskTimings()
+{
+    m_longTaskTimingBuffer.clear();
+}
+
+void PerformanceBase::setLongTaskTimingBufferSize(unsigned size)
+{
+    m_longTaskTimingBufferSize = size;
+    if (isLongTaskTimingBufferFull())
+        dispatchEvent(Event::create(EventTypeNames::longtasktimingbufferfull));
+}
+
 static bool passesTimingAllowCheck(const ResourceResponse& response, const SecurityOrigin& initiatorSecurityOrigin, const AtomicString& originalTimingAllowOrigin, ExecutionContext* context)
 {
     RefPtr<SecurityOrigin> resourceOrigin = SecurityOrigin::create(response.url());
@@ -322,6 +342,31 @@ bool PerformanceBase::isFrameTimingBufferFull()
     return m_frameTimingBuffer.size() >= m_frameTimingBufferSize;
 }
 
+void PerformanceBase::addLongTaskTiming(double startTime, double endTime, const String& frameContextUrl)
+{
+    if (isLongTaskTimingBufferFull() || !hasObserverFor(PerformanceEntry::LongTask))

[haraken, 2016/08/17 01:15:48]

Don't we need to dispatch a longtasktimingbufferfull event when
isLongTaskTimingBufferFull() returns false?

[panicker, 2016/08/17 19:00:09]

This is happening at line 362 below.
Basically after adding each item, we check if full and if so dispatch the event
right away.
(Meanwhile if more entries are attempted to be added -- I don't think we need to
keep dispatching the event)

+        return;
+    PerformanceEntry* entry = PerformanceLongTaskTiming::create(
+        monotonicTimeToDOMHighResTimeStampInMillis(startTime),
+        monotonicTimeToDOMHighResTimeStampInMillis(endTime),
+        frameContextUrl);
+    notifyObserversOfEntry(*entry);
+    if (!isLongTaskTimingBufferFull())

[haraken, 2016/08/17 01:15:48]

This check won't be needed since you've already checked it at line 347.

[panicker, 2016/08/17 19:00:09]

Done.

+        addLongTaskTimingBuffer(*entry);
+}
+
+void PerformanceBase::addLongTaskTimingBuffer(PerformanceEntry& entry)
+{
+    m_longTaskTimingBuffer.append(&entry);
+    if (isLongTaskTimingBufferFull())
+        dispatchEvent(Event::create(EventTypeNames::longtasktimingbufferfull));
+}
+
+bool PerformanceBase::isLongTaskTimingBufferFull()
+{
+    return m_longTaskTimingBuffer.size() >= m_longTaskTimingBufferSize;
+}
+
 void PerformanceBase::mark(const String& markName, ExceptionState& exceptionState)
 {
     if (!m_userTiming)
@@ -445,6 +490,12 @@ DOMHighResTimeStamp PerformanceBase::monotonicTimeToDOMHighResTimeStamp(double m
     return convertSecondsToDOMHighResTimeStamp(clampTimeResolution(timeInSeconds));
 }
 
+double PerformanceBase::monotonicTimeToDOMHighResTimeStampInMillis(
+    DOMHighResTimeStamp monotonicTime) const
+{
+    return monotonicTimeToDOMHighResTimeStamp(monotonicTime) * 1000;
+}
+
 DOMHighResTimeStamp PerformanceBase::now() const
 {
     return monotonicTimeToDOMHighResTimeStamp(monotonicallyIncreasingTime());
@@ -454,6 +505,7 @@ DEFINE_TRACE(PerformanceBase)
 {
     visitor->trace(m_frameTimingBuffer);
     visitor->trace(m_resourceTimingBuffer);
+    visitor->trace(m_longTaskTimingBuffer);
     visitor->trace(m_userTiming);
     visitor->trace(m_observers);
     visitor->trace(m_activeObservers);