Remove buffering from PerformanceLongTaskTiming as it's not in the spec.

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 33 matching lines @@
 #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_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;
 }
 
 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::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;
-    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) {
@@ skipping 48 matching lines @@
 void PerformanceBase::clearFrameTimings() {
   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;
 
@@ skipping 141 matching lines @@
 }
 
 bool PerformanceBase::isFrameTimingBufferFull() {
   return m_frameTimingBuffer.size() >= m_frameTimingBufferSize;
 }
 
 void PerformanceBase::addLongTaskTiming(double startTime,
                                         double endTime,
                                         const String& name,
                                         DOMWindow* culpritWindow) {
-  if (isLongTaskTimingBufferFull() ||
-      !hasObserverFor(PerformanceEntry::LongTask))
+  if (!hasObserverFor(PerformanceEntry::LongTask))
     return;
   PerformanceEntry* entry = PerformanceLongTaskTiming::create(
       monotonicTimeToDOMHighResTimeStampInMillis(startTime),
       monotonicTimeToDOMHighResTimeStampInMillis(endTime), name, culpritWindow);
   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);
 }
 
@@ skipping 117 matching lines @@
   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