[not for review] Add Draw entries to window Performance Timeline

Source/core/timing/Performance.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 "config.h"
 #include "core/timing/Performance.h"
 
 #include "core/dom/Document.h"
 #include "core/frame/LocalFrame.h"
 #include "core/loader/DocumentLoader.h"
+#include "core/timing/PerformanceResourceTiming.h"
+#include "core/timing/PerformanceSmoothnessTiming.h"
+#include "core/timing/PerformanceUserTiming.h"
 #include "core/timing/ResourceTimingInfo.h"
-#include "core/timing/PerformanceResourceTiming.h"
-#include "core/timing/PerformanceUserTiming.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "wtf/CurrentTime.h"
 
 namespace blink {
 
 static const size_t defaultResourceTimingBufferSize = 150;
+static const size_t defaultSmoothnessTimingBufferSize = 150;
 
 Performance::Performance(LocalFrame* frame)
     : DOMWindowProperty(frame)
     , m_resourceTimingBufferSize(defaultResourceTimingBufferSize)
+    , m_smoothnessTimingBufferSize(defaultSmoothnessTimingBufferSize)
     , m_referenceTime(frame && frame->host() ? frame->document()->loader()->timing()->referenceMonotonicTime() : 0.0)
     , m_userTiming(nullptr)
 {
 }
 
 Performance::~Performance()
 {
 }
 
 const AtomicString& Performance::interfaceName() const
@@ skipping 28 matching lines @@
 
     return m_timing.get();
 }
 
 PerformanceEntryVector Performance::getEntries() const
 {
     PerformanceEntryVector entries;
 
     entries.appendVector(m_resourceTimingBuffer);
 
+    entries.appendVector(m_smoothnessTimingBuffer);
+
     if (m_userTiming) {
         entries.appendVector(m_userTiming->getMarks());
         entries.appendVector(m_userTiming->getMeasures());
     }
 
     std::sort(entries.begin(), entries.end(), PerformanceEntry::startTimeCompareLessThan);
     return entries;
 }
 
 PerformanceEntryVector Performance::getEntriesByType(const String& entryType)
 {
     PerformanceEntryVector entries;
 
     if (equalIgnoringCase(entryType, "resource"))
         for (PerformanceEntryVector::const_iterator resource = m_resourceTimingBuffer.begin(); resource != m_resourceTimingBuffer.end(); ++resource)
             entries.append(*resource);
 
+    if (equalIgnoringCase(entryType, "smoothness"))
+        for (PerformanceEntryVector::const_iterator smoothness = m_smoothnessTimingBuffer.begin(); smoothness != m_smoothnessTimingBuffer.end(); ++smoothness)
+            entries.append(*smoothness);
+
     if (m_userTiming) {
         if (equalIgnoringCase(entryType, "mark"))
             entries.appendVector(m_userTiming->getMarks());
         else if (equalIgnoringCase(entryType, "measure"))
             entries.appendVector(m_userTiming->getMeasures());
     }
 
     std::sort(entries.begin(), entries.end(), PerformanceEntry::startTimeCompareLessThan);
     return entries;
 }
 
 PerformanceEntryVector Performance::getEntriesByName(const String& name, const String& entryType)
 {
     PerformanceEntryVector entries;
 
     if (entryType.isNull() || equalIgnoringCase(entryType, "resource"))
         for (PerformanceEntryVector::const_iterator resource = m_resourceTimingBuffer.begin(); resource != m_resourceTimingBuffer.end(); ++resource)
             if ((*resource)->name() == name)
                 entries.append(*resource);
 
+    if (entryType.isNull() || equalIgnoringCase(entryType, "smoothness")) {
+        for (PerformanceEntryVector::const_iterator smoothness = m_smoothnessTimingBuffer.begin(); smoothness != m_smoothnessTimingBuffer.end(); ++smoothness) {
+            if ((*smoothness)->name() == name)
+                entries.append(*smoothness);
+        }
+    }
+
     if (m_userTiming) {
         if (entryType.isNull() || equalIgnoringCase(entryType, "mark"))
             entries.appendVector(m_userTiming->getMarks(name));
         if (entryType.isNull() || equalIgnoringCase(entryType, "measure"))
             entries.appendVector(m_userTiming->getMeasures(name));
     }
 
     std::sort(entries.begin(), entries.end(), PerformanceEntry::startTimeCompareLessThan);
     return entries;
 }
 
 void Performance::webkitClearResourceTimings()
 {
     m_resourceTimingBuffer.clear();
 }
 
 void Performance::webkitSetResourceTimingBufferSize(unsigned size)
 {
     m_resourceTimingBufferSize = size;
     if (isResourceTimingBufferFull())
         dispatchEvent(Event::create(EventTypeNames::webkitresourcetimingbufferfull));
 }
 
+void Performance::webkitClearSmoothnessTimings()
+{
+    m_smoothnessTimingBuffer.clear();
+}
+
+void Performance::webkitSetSmoothnessTimingBufferSize(unsigned size)
+{
+    m_smoothnessTimingBufferSize = size;
+    if (isSmoothnessTimingBufferFull())
+        dispatchEvent(Event::create(EventTypeNames::webkitsmoothnesstimingbufferfull));
+}
+
 static bool passesTimingAllowCheck(const ResourceResponse& response, Document* requestingDocument, const AtomicString& originalTimingAllowOrigin)
 {
     AtomicallyInitializedStatic(AtomicString&, timingAllowOrigin = *new AtomicString("timing-allow-origin"));
 
     RefPtr<SecurityOrigin> resourceOrigin = SecurityOrigin::create(response.url());
     if (resourceOrigin->isSameSchemeHostPort(requestingDocument->securityOrigin()))
         return true;
 
     const AtomicString& timingAllowOriginString = originalTimingAllowOrigin.isEmpty() ? response.httpHeaderField(timingAllowOrigin) : originalTimingAllowOrigin;
     if (timingAllowOriginString.isEmpty() || equalIgnoringCase(timingAllowOriginString, "null"))
@@ skipping 67 matching lines @@
 
     if (isResourceTimingBufferFull())
         dispatchEvent(Event::create(EventTypeNames::webkitresourcetimingbufferfull));
 }
 
 bool Performance::isResourceTimingBufferFull()
 {
     return m_resourceTimingBuffer.size() >= m_resourceTimingBufferSize;
 }
 
+void Performance::addSmoothnessTiming(const String& name, Document* initiatorDocument, unsigned sourceFrame, double startTime)
+{
+    if (isSmoothnessTimingBufferFull())
+        return;
+
+    RefPtrWillBeRawPtr<PerformanceEntry> entry = PerformanceSmoothnessTiming::create(name, initiatorDocument, sourceFrame, startTime);
+    addSmoothnessTimingBuffer(entry);
+}
+
+void Performance::addSmoothnessTimingBuffer(PassRefPtrWillBeRawPtr<PerformanceEntry> entry)
+{
+    m_smoothnessTimingBuffer.append(entry);
+
+    if (isSmoothnessTimingBufferFull())
+        dispatchEvent(Event::create(EventTypeNames::webkitsmoothnesstimingbufferfull));
+}
+
+bool Performance::isSmoothnessTimingBufferFull()
+{
+    return m_smoothnessTimingBuffer.size() >= m_smoothnessTimingBufferSize;
+}
+
 void Performance::mark(const String& markName, ExceptionState& exceptionState)
 {
     if (!m_userTiming)
         m_userTiming = UserTiming::create(this);
     m_userTiming->mark(markName, exceptionState);
 }
 
 void Performance::clearMarks(const String& markName)
 {
     if (!m_userTiming)
@@ skipping 18 matching lines @@
 double Performance::now() const
 {
     return 1000.0 * (monotonicallyIncreasingTime() - m_referenceTime);
 }
 
 void Performance::trace(Visitor* visitor)
 {
     visitor->trace(m_navigation);
     visitor->trace(m_timing);
     visitor->trace(m_resourceTimingBuffer);
+    visitor->trace(m_smoothnessTimingBuffer);
     visitor->trace(m_userTiming);
     EventTargetWithInlineData::trace(visitor);
     DOMWindowProperty::trace(visitor);
 }
 
 } // namespace blink