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

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 17 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/timing/PerformanceBase.h"
 
 #include "core/dom/Document.h"
 #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"
 #include "core/timing/PerformanceUserTiming.h"
 #include "platform/network/ResourceTimingInfo.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "wtf/CurrentTime.h"
 #include <algorithm>
 
 namespace blink {
 
 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_longTaskTimingBufferSize(defaultLongTaskTimingBufferSize)
+    , m_userTiming(nullptr)
     , m_timeOrigin(timeOrigin)
-    , m_userTiming(nullptr)
     , m_observerFilterOptions(PerformanceEntry::Invalid)
     , m_deliverObservationsTimer(this, &PerformanceBase::deliverObservationsTimerFired)
 {
 }
 
 PerformanceBase::~PerformanceBase()
 {
 }
 
 const AtomicString& PerformanceBase::interfaceName() const
 {
     return EventTargetNames::Performance;
 }
 
 PerformanceTiming* PerformanceBase::timing() const
 {
     return nullptr;
 }
 
 PerformanceEntryVector PerformanceBase::getEntries() const
 {
     PerformanceEntryVector entries;
 
     entries.appendVector(m_resourceTimingBuffer);
     entries.appendVector(m_frameTimingBuffer);
+    entries.appendVector(m_longTaskTimingBuffer);
 
     if (m_userTiming) {
         entries.appendVector(m_userTiming->getMarks());
         entries.appendVector(m_userTiming->getMeasures());
     }
 
     std::sort(entries.begin(), entries.end(), PerformanceEntry::startTimeCompareLessThan);
     return entries;
 }
 
@@ skipping 18 matching lines @@
         }
         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;
+    case PerformanceEntry::LongTask:
+        for (const auto& longTask : m_longTaskTimingBuffer)
+            entries.append(longTask);
+        break;
     }
 
     std::sort(entries.begin(), entries.end(), PerformanceEntry::startTimeCompareLessThan);
     return entries;
 }
 
 PerformanceEntryVector PerformanceBase::getEntriesByName(const String& name, const String& entryType)
 {
     PerformanceEntryVector entries;
     PerformanceEntry::EntryType type = PerformanceEntry::toEntryTypeEnum(entryType);
@@ skipping 47 matching lines @@
     m_frameTimingBuffer.clear();
 }
 
 void PerformanceBase::setFrameTimingBufferSize(unsigned size)
 {
     m_frameTimingBufferSize = size;
     if (isFrameTimingBufferFull())
         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());
     if (resourceOrigin->isSameSchemeHostPort(&initiatorSecurityOrigin))
         return true;
 
     const AtomicString& timingAllowOriginString = originalTimingAllowOrigin.isEmpty() ? response.httpHeaderField(HTTPNames::Timing_Allow_Origin) : originalTimingAllowOrigin;
     if (timingAllowOriginString.isEmpty() || equalIgnoringCase(timingAllowOriginString, "null"))
         return false;
 
@@ skipping 116 matching lines @@
 
     if (isFrameTimingBufferFull())
         dispatchEvent(Event::create(EventTypeNames::frametimingbufferfull));
 }
 
 bool PerformanceBase::isFrameTimingBufferFull()
 {
     return m_frameTimingBuffer.size() >= m_frameTimingBufferSize;
 }
 
+void PerformanceBase::addLongTaskTiming(double startTime, double endTime, const String& frameContextUrl)
+{
+    if (isLongTaskTimingBufferFull() || !hasObserverFor(PerformanceEntry::LongTask))
+        return;
+    PerformanceEntry* entry = PerformanceLongTaskTiming::create(
+        monotonicTimeToDOMHighResTimeStampInMillis(startTime),
+        monotonicTimeToDOMHighResTimeStampInMillis(endTime),
+        frameContextUrl);
+    notifyObserversOfEntry(*entry);
+    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)
         m_userTiming = UserTiming::create(*this);
     if (PerformanceEntry* entry = m_userTiming->mark(markName, exceptionState))
         notifyObserversOfEntry(*entry);
 }
 
 void PerformanceBase::clearMarks(const String& markName)
 {
@@ skipping 103 matching lines @@
 DOMHighResTimeStamp PerformanceBase::monotonicTimeToDOMHighResTimeStamp(double monotonicTime) const
 {
     // Avoid exposing raw platform timestamps.
     if (m_timeOrigin == 0.0)
         return 0.0;
 
     double timeInSeconds = monotonicTime - m_timeOrigin;
     return convertSecondsToDOMHighResTimeStamp(clampTimeResolution(timeInSeconds));
 }
 
+double PerformanceBase::monotonicTimeToDOMHighResTimeStampInMillis(
+    DOMHighResTimeStamp monotonicTime) const
+{
+    return monotonicTimeToDOMHighResTimeStamp(monotonicTime) * 1000;
+}
+
 DOMHighResTimeStamp PerformanceBase::now() const
 {
     return monotonicTimeToDOMHighResTimeStamp(monotonicallyIncreasingTime());
 }
 
 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);
     visitor->trace(m_suspendedObservers);
     EventTargetWithInlineData::trace(visitor);
 }
 
 } // namespace blink