buffer paint entries so they can queried with getEntries

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 90 matching lines @@
   if (navigation_timing_)
     entries.push_back(navigation_timing_);
   entries.AppendVector(frame_timing_buffer_);
 
   if (user_timing_) {
     entries.AppendVector(user_timing_->GetMarks());
     entries.AppendVector(user_timing_->GetMeasures());
   }
 
   entries.AppendVector(server_timing_buffer_);
+  if (first_paint_timing_)
+    entries.push_back(first_paint_timing_);
+  if (first_contentful_paint_timing_)
+    entries.push_back(first_contentful_paint_timing_);
 
   std::sort(entries.begin(), entries.end(),
             PerformanceEntry::StartTimeCompareLessThan);
   return entries;
 }
 
 PerformanceEntryVector PerformanceBase::getEntriesByType(
     const String& entry_type) {
   PerformanceEntryVector entries;
   PerformanceEntry::EntryType type =
@@ skipping 22 matching lines @@
       if (user_timing_)
         entries.AppendVector(user_timing_->GetMarks());
       break;
     case PerformanceEntry::kMeasure:
       if (user_timing_)
         entries.AppendVector(user_timing_->GetMeasures());
       break;
     case PerformanceEntry::kServer:
       entries.AppendVector(server_timing_buffer_);
       break;
-    // Unsupported for Paint, LongTask, TaskAttribution.
+    case PerformanceEntry::kPaint:
+      if (first_paint_timing_)
+        entries.push_back(first_paint_timing_);
+      if (first_contentful_paint_timing_)
+        entries.push_back(first_contentful_paint_timing_);
+      break;
+    // Unsupported for LongTask, TaskAttribution.
     // Per the spec, these entries can only be accessed via
     // Performance Observer. No separate buffer is maintained.
-    case PerformanceEntry::kPaint:
-      break;
     case PerformanceEntry::kLongTask:
       break;
     case PerformanceEntry::kTaskAttribution:
       break;
     case PerformanceEntry::kInvalid:
       break;
   }
 
   std::sort(entries.begin(), entries.end(),
             PerformanceEntry::StartTimeCompareLessThan);
@@ skipping 231 matching lines @@
 
 void PerformanceBase::AddFirstContentfulPaintTiming(double start_time) {
   AddPaintTiming(PerformancePaintTiming::PaintType::kFirstContentfulPaint,
                  start_time);
 }
 
 void PerformanceBase::AddPaintTiming(PerformancePaintTiming::PaintType type,
                                      double start_time) {
   if (!RuntimeEnabledFeatures::performancePaintTimingEnabled())
     return;
+
   PerformanceEntry* entry = new PerformancePaintTiming(
       type, MonotonicTimeToDOMHighResTimeStamp(start_time));
+  // Always buffer First Paint & First Contentful Paint.
+  if (type == PerformancePaintTiming::PaintType::kFirstPaint)
+    first_paint_timing_ = entry;
+  else if (type == PerformancePaintTiming::PaintType::kFirstContentfulPaint)
+    first_contentful_paint_timing_ = entry;
   NotifyObserversOfEntry(*entry);
 }
 
 void PerformanceBase::AddResourceTimingBuffer(PerformanceEntry& entry) {
   resource_timing_buffer_.push_back(&entry);
 
   if (IsResourceTimingBufferFull())
     DispatchEvent(Event::Create(EventTypeNames::resourcetimingbufferfull));
 }
 
@@ skipping 171 matching lines @@
 DOMHighResTimeStamp PerformanceBase::now() const {
   return MonotonicTimeToDOMHighResTimeStamp(MonotonicallyIncreasingTime());
 }
 
 DEFINE_TRACE(PerformanceBase) {
   visitor->Trace(frame_timing_buffer_);
   visitor->Trace(resource_timing_buffer_);
   visitor->Trace(navigation_timing_);
   visitor->Trace(user_timing_);
   visitor->Trace(server_timing_buffer_);
+  visitor->Trace(first_paint_timing_);
+  visitor->Trace(first_contentful_paint_timing_);
   visitor->Trace(observers_);
   visitor->Trace(active_observers_);
   visitor->Trace(suspended_observers_);
   EventTargetWithInlineData::Trace(visitor);
 }
 
 }  // namespace blink