Enable ServerTiming support

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 24 matching lines @@
 #include "core/dom/Document.h"
 #include "core/dom/DocumentTiming.h"
 #include "core/events/Event.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/UseCounter.h"
 #include "core/loader/DocumentLoadTiming.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/timing/PerformanceLongTaskTiming.h"
 #include "core/timing/PerformanceObserver.h"
 #include "core/timing/PerformanceResourceTiming.h"
+#include "core/timing/PerformanceServerTiming.h"
 #include "core/timing/PerformanceUserTiming.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/loader/fetch/ResourceResponse.h"
 #include "platform/loader/fetch/ResourceTimingInfo.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "wtf/CurrentTime.h"
 
 namespace blink {
 
 namespace {
@@ skipping 43 matching lines @@
   // calls this method.
   if (m_navigationTiming)
     entries.push_back(m_navigationTiming);
   entries.appendVector(m_frameTimingBuffer);
 
   if (m_userTiming) {
     entries.appendVector(m_userTiming->getMarks());
     entries.appendVector(m_userTiming->getMeasures());
   }
 
+  entries.appendVector(m_serverTimingBuffer);
+
   std::sort(entries.begin(), entries.end(),
             PerformanceEntry::startTimeCompareLessThan);
   return entries;
 }
 
 PerformanceEntryVector PerformanceBase::getEntriesByType(
     const String& entryType) {
   PerformanceEntryVector entries;
   PerformanceEntry::EntryType type =
       PerformanceEntry::toEntryTypeEnum(entryType);
@@ skipping 18 matching lines @@
       }
       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::Server:
+      entries.appendVector(m_serverTimingBuffer);
+      break;
     // Unsupported for Paint, LongTask, TaskAttribution.
     // Per the spec, these entries can only be accessed via
     // Performance Observer. No separate buffer is maintained.
     case PerformanceEntry::Paint:
       break;
     case PerformanceEntry::LongTask:
       break;
     case PerformanceEntry::TaskAttribution:
       break;
     case PerformanceEntry::Invalid:
@@ skipping 38 matching lines @@
     }
   }
 
   if (m_userTiming) {
     if (entryType.isNull() || type == PerformanceEntry::Mark)
       entries.appendVector(m_userTiming->getMarks(name));
     if (entryType.isNull() || type == PerformanceEntry::Measure)
       entries.appendVector(m_userTiming->getMeasures(name));
   }
 
+  if (entryType.isNull() || type == PerformanceEntry::Server) {
+    // This is inefficient, but because we only buffer until onload, we don't
+    // expect this buffer to be too big.
+    for (const auto& entry : m_serverTimingBuffer) {
+      if (entry->name() == name)
+        entries.push_back(entry);
+    }
+  }
+
   std::sort(entries.begin(), entries.end(),
             PerformanceEntry::startTimeCompareLessThan);
   return entries;
 }
 
 void PerformanceBase::clearResourceTimings() {
   m_resourceTimingBuffer.clear();
 }
 
 void PerformanceBase::setResourceTimingBufferSize(unsigned size) {
@@ skipping 61 matching lines @@
 
   for (const ResourceResponse& response : redirectChain) {
     if (!passesTimingAllowCheck(response, initiatorSecurityOrigin,
                                 AtomicString(), context))
       return false;
   }
 
   return true;
 }
 
+void PerformanceBase::addServerTiming(
+    const ResourceResponse& response,
+    const ShouldAddToBuffer& shouldAddToBuffer) {
+  if (shouldAddToBuffer == ShouldAddToBuffer::Never &&
+      !hasObserverFor(PerformanceEntry::Server)) {
+    return;
+  }
+
+  ExecutionContext* context = getExecutionContext();
+  SecurityOrigin* securityOrigin = getSecurityOrigin(context);
+  if (!securityOrigin) {
+    return;
+  }
+  bool allowTimingDetails = passesTimingAllowCheck(
+      response, *securityOrigin,
+      response.httpHeaderField(HTTPNames::Timing_Allow_Origin), context);
+
+  std::unique_ptr<ServerTimingHeaderVector> headers = parseServerTimingHeader(
+      response.httpHeaderField(HTTPNames::Server_Timing));
+  for (const auto& header : *headers) {
+    PerformanceEntry* entry = PerformanceServerTiming::create(
+        response.url().getString(), header->metric,
+        allowTimingDetails ? header->duration : 0.0,
+        allowTimingDetails ? header->description : "");
+
+    notifyObserversOfEntry(*entry);

[panicker, 2017/04/06 22:42:22]

would be good to make a notifyObserversOfEntries() and queue them all together.
Otherwise if there's many of them we may add unnecessary overhead by delivering
piecemeal (if delivery timer fires)
 

+    if (shouldAddToBuffer == ShouldAddToBuffer::Always) {
+      m_serverTimingBuffer.push_back(*entry);

[panicker, 2017/04/06 22:42:22]

Could we have a max size for this buffer?
On some sites onload fires very late so this could be arbitrarily large.

[cvazac, 2017/04/06 23:58:02]

Sure! Like resource timing
(https://www.w3.org/TR/resource-timing/#extensions-performance-interface),
should I add the analogous `clearServerTimings()`,
`setServerTimingBufferSize()`, and `onservertimingbufferfull` handler? Or were
you thinking something un-configurable?

On 2017/04/06 22:42:22, panicker wrote:

[panicker, 2017/04/07 23:01:32]

Since this API is only exposed on Performance Observer (and not the older
performance timeline) no need to web-expose this.
Just an internal max size would be fine.

+    }
+  }
+}
+
 void PerformanceBase::addResourceTiming(const ResourceTimingInfo& info) {
   if (isResourceTimingBufferFull() &&
       !hasObserverFor(PerformanceEntry::Resource))
     return;
   ExecutionContext* context = getExecutionContext();
   SecurityOrigin* securityOrigin = getSecurityOrigin(context);
   if (!securityOrigin)
     return;
 
   const ResourceResponse& finalResponse = info.finalResponse();
@@ skipping 231 matching lines @@
 
 DOMHighResTimeStamp PerformanceBase::now() const {
   return monotonicTimeToDOMHighResTimeStamp(monotonicallyIncreasingTime());
 }
 
 DEFINE_TRACE(PerformanceBase) {
   visitor->trace(m_frameTimingBuffer);
   visitor->trace(m_resourceTimingBuffer);
   visitor->trace(m_navigationTiming);
   visitor->trace(m_userTiming);
+  visitor->trace(m_serverTimingBuffer);
   visitor->trace(m_observers);
   visitor->trace(m_activeObservers);
   visitor->trace(m_suspendedObservers);
   EventTargetWithInlineData::trace(visitor);
 }
 
 }  // namespace blink