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 58 matching lines @@
 }
 
 const RestrictedKeyMap& restrictedKeyMap()
 {
     AtomicallyInitializedStaticReference(RestrictedKeyMap, map, createRestrictedKeyMap());
     return map;
 }
 
 } // namespace anonymous
 
-UserTiming::UserTiming(PerformanceBase* performance)
-    : m_performance(performance)
+UserTiming::UserTiming(PerformanceBase& performance)
+    : m_performance(&performance)
 {
 }
 
-static void insertPerformanceEntry(PerformanceEntryMap& performanceEntryMap, PerformanceEntry* entry)
+static void insertPerformanceEntry(PerformanceEntryMap& performanceEntryMap, PerformanceEntry& entry)
 {
-    PerformanceEntryMap::iterator it = performanceEntryMap.find(entry->name());
+    PerformanceEntryMap::iterator it = performanceEntryMap.find(entry.name());
     if (it != performanceEntryMap.end()) {
-        it->value.append(entry);
+        it->value.append(&entry);
     } else {
         PerformanceEntryVector vector(1);
-        vector[0] = entry;
-        performanceEntryMap.set(entry->name(), vector);
+        vector[0] = Member<PerformanceEntry>(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)
+PerformanceEntry* UserTiming::mark(const String& markName, 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;
+        return nullptr;
     }
 
     TRACE_EVENT_COPY_MARK("blink.user_timing", markName.utf8().data());
     double startTime = m_performance->now();
-    insertPerformanceEntry(m_marksMap, PerformanceMark::create(markName, startTime));
+    PerformanceEntry* entry = PerformanceMark::create(markName, startTime);
+    insertPerformanceEntry(m_marksMap, *entry);
     Platform::current()->histogramCustomCounts("PLT.UserTiming_Mark", static_cast<int>(startTime), 0, 600000, 100);
+    return entry;
 }
 
 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)
+PerformanceEntry* UserTiming::measure(const String& measureName, const String& startMark, const String& endMark, 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;
+            return nullptr;
     } else {
         endTime = findExistingMarkStartTime(endMark, exceptionState);
         if (exceptionState.hadException())
-            return;
+            return nullptr;
         startTime = findExistingMarkStartTime(startMark, exceptionState);
         if (exceptionState.hadException())
-            return;
+            return nullptr;
     }
 
     // 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));
+    PerformanceEntry* entry = PerformanceMeasure::create(measureName, startTime, endTime);
+    insertPerformanceEntry(m_measuresMap, *entry);
     if (endTime >= startTime)
         Platform::current()->histogramCustomCounts("PLT.UserTiming_MeasureDuration", static_cast<int>(endTime - startTime), 0, 600000, 100);
+    return entry;
 }
 
 void UserTiming::clearMeasures(const String& measureName)
 {
     clearPeformanceEntries(m_measuresMap, measureName);
 }
 
 static PerformanceEntryVector convertToEntrySequence(const PerformanceEntryMap& performanceEntryMap)
 {
     PerformanceEntryVector entries;
@@ skipping 36 matching lines @@
 }
 
 DEFINE_TRACE(UserTiming)
 {
     visitor->trace(m_performance);
     visitor->trace(m_marksMap);
     visitor->trace(m_measuresMap);
 }
 
 } // namespace blink