First version of PerformanceObserver

Source/core/timing/PerformanceUserTiming.cpp

 /*
  * 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 63 matching lines @@
     return map;
 }
 
 } // namespace anonymous
 
 UserTiming::UserTiming(PerformanceBase* performance)
     : m_performance(performance)
 {
 }
 
-static void insertPerformanceEntry(PerformanceEntryMap& performanceEntryMap, PerformanceEntry* entry)
+static void insertPerformanceEntry(PerformanceEntryMap& performanceEntryMap, NewPerformanceEntryCallback callback, PerformanceEntry* entry)
 {
+    (*callback)(entry);

[esprehn, 2015/07/18 22:24:17]

This is very unusual for blink code, can you return an iterator instead?

     PerformanceEntryMap::iterator it = performanceEntryMap.find(entry->name());
     if (it != performanceEntryMap.end())
         it->value.append(entry);
     else {
         PerformanceEntryVector vector(1);
         vector[0] = entry;
         performanceEntryMap.set(entry->name(), vector);
     }
 }
 
 static void clearPeformanceEntries(PerformanceEntryMap& performanceEntryMap, const String& name)
 {
     if (name.isNull()) {
         performanceEntryMap.clear();
         return;
     }
 
     if (performanceEntryMap.contains(name))
         performanceEntryMap.remove(name);
 }
 
-void UserTiming::mark(const String& markName, ExceptionState& exceptionState)
+void UserTiming::mark(const String& markName, NewPerformanceEntryCallback callback, ExceptionState& exceptionState)
 {
     if (restrictedKeyMap().contains(markName)) {
         exceptionState.throwDOMException(SyntaxError, "'" + markName + "' is part of the PerformanceTiming interface, and cannot be used as a mark name.");
         return;
     }
 
     TRACE_EVENT_COPY_MARK("blink.user_timing", markName.utf8().data());
     double startTime = m_performance->now();
-    insertPerformanceEntry(m_marksMap, PerformanceMark::create(markName, startTime));
+    insertPerformanceEntry(m_marksMap, callback, PerformanceMark::create(markName, startTime));
     Platform::current()->histogramCustomCounts("PLT.UserTiming_Mark", static_cast<int>(startTime), 0, 600000, 100);
 }
 
 void UserTiming::clearMarks(const String& markName)
 {
     clearPeformanceEntries(m_marksMap, markName);
 }
 
 double UserTiming::findExistingMarkStartTime(const String& markName, ExceptionState& exceptionState)
 {
     if (m_marksMap.contains(markName))
         return m_marksMap.get(markName).last()->startTime();
 
     if (restrictedKeyMap().contains(markName) && m_performance->timing()) {
         double value = static_cast<double>((m_performance->timing()->*(restrictedKeyMap().get(markName)))());
         if (!value) {
             exceptionState.throwDOMException(InvalidAccessError, "'" + markName + "' is empty: either the event hasn't happened yet, or it would provide cross-origin timing information.");
             return 0.0;
         }
         return value - m_performance->timing()->navigationStart();
     }
 
     exceptionState.throwDOMException(SyntaxError, "The mark '" + markName + "' does not exist.");
     return 0.0;
 }
 
-void UserTiming::measure(const String& measureName, const String& startMark, const String& endMark, ExceptionState& exceptionState)
+void UserTiming::measure(const String& measureName, const String& startMark, const String& endMark, NewPerformanceEntryCallback callback, ExceptionState& exceptionState)
 {
     double startTime = 0.0;
     double endTime = 0.0;
 
     if (startMark.isNull())
         endTime = m_performance->now();
     else if (endMark.isNull()) {
         endTime = m_performance->now();
         startTime = findExistingMarkStartTime(startMark, exceptionState);
         if (exceptionState.hadException())
             return;
     } else {
         endTime = findExistingMarkStartTime(endMark, exceptionState);
         if (exceptionState.hadException())
             return;
         startTime = findExistingMarkStartTime(startMark, exceptionState);
         if (exceptionState.hadException())
             return;
     }
 
     // User timing events are stored as integer milliseconds from the start of
     // navigation, whereas trace events accept double seconds based off of
     // CurrentTime::monotonicallyIncreasingTime().
     double startTimeMonotonic = m_performance->timeOrigin() + startTime / 1000.0;
     double endTimeMonotonic = m_performance->timeOrigin() + endTime / 1000.0;
 
     TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP0("blink.user_timing", measureName.utf8().data(), WTF::StringHash::hash(measureName), startTimeMonotonic);
     TRACE_EVENT_COPY_NESTABLE_ASYNC_END_WITH_TIMESTAMP0("blink.user_timing", measureName.utf8().data(), WTF::StringHash::hash(measureName), endTimeMonotonic);
 
-    insertPerformanceEntry(m_measuresMap, PerformanceMeasure::create(measureName, startTime, endTime));
+    insertPerformanceEntry(m_measuresMap, callback, PerformanceMeasure::create(measureName, startTime, endTime));
     if (endTime >= startTime)
         Platform::current()->histogramCustomCounts("PLT.UserTiming_MeasureDuration", static_cast<int>(endTime - startTime), 0, 600000, 100);
 }
 
 void UserTiming::clearMeasures(const String& measureName)
 {
     clearPeformanceEntries(m_measuresMap, measureName);
 }
 
 static PerformanceEntryVector convertToEntrySequence(const PerformanceEntryMap& performanceEntryMap)
@@ skipping 38 matching lines @@
 }
 
 DEFINE_TRACE(UserTiming)
 {
     visitor->trace(m_performance);
     visitor->trace(m_marksMap);
     visitor->trace(m_measuresMap);
 }
 
 } // namespace blink