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 "platform/wtf/CurrentTime.h"
 
 namespace blink {
 
 namespace {
 
 SecurityOrigin* GetSecurityOrigin(ExecutionContext* context) {
   if (context)
     return context->GetSecurityOrigin();
   return nullptr;
 }
 
 }  // namespace
 
 using PerformanceObserverVector = HeapVector<Member<PerformanceObserver>>;
 
 static const size_t kDefaultResourceTimingBufferSize = 150;
 static const size_t kDefaultFrameTimingBufferSize = 150;
+static const size_t kServerTimingBufferSize = 150;
 
 PerformanceBase::PerformanceBase(double time_origin,
                                  RefPtr<WebTaskRunner> task_runner)
     : frame_timing_buffer_size_(kDefaultFrameTimingBufferSize),
       resource_timing_buffer_size_(kDefaultResourceTimingBufferSize),
       user_timing_(nullptr),
       time_origin_(time_origin),
       observer_filter_options_(PerformanceEntry::kInvalid),
       deliver_observations_timer_(
           std::move(task_runner),
@@ skipping 20 matching lines @@
   // calls this method.
   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_);
+
   std::sort(entries.begin(), entries.end(),
             PerformanceEntry::StartTimeCompareLessThan);
   return entries;
 }
 
 PerformanceEntryVector PerformanceBase::getEntriesByType(
     const String& entry_type) {
   PerformanceEntryVector entries;
   PerformanceEntry::EntryType type =
       PerformanceEntry::ToEntryTypeEnum(entry_type);
@@ skipping 18 matching lines @@
       }
       break;
     case PerformanceEntry::kMark:
       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.
     // 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:
@@ skipping 38 matching lines @@
     }
   }
 
   if (user_timing_) {
     if (entry_type.IsNull() || type == PerformanceEntry::kMark)
       entries.AppendVector(user_timing_->GetMarks(name));
     if (entry_type.IsNull() || type == PerformanceEntry::kMeasure)
       entries.AppendVector(user_timing_->GetMeasures(name));
   }
 
+  if (entry_type.IsNull() || type == PerformanceEntry::kServer) {
+    // This is inefficient, but this buffer has a max size of
+    // 150 entries (controlled by kServerTimingBufferSize).
+    for (const auto& entry : server_timing_buffer_) {
+      if (entry->name() == name)
+        entries.push_back(entry);
+    }
+  }
+
   std::sort(entries.begin(), entries.end(),
             PerformanceEntry::StartTimeCompareLessThan);
   return entries;
 }
 
 void PerformanceBase::clearResourceTimings() {
   resource_timing_buffer_.clear();
 }
 
 void PerformanceBase::setResourceTimingBufferSize(unsigned size) {
@@ skipping 61 matching lines @@
 
   for (const ResourceResponse& response : redirect_chain) {
     if (!PassesTimingAllowCheck(response, initiator_security_origin,
                                 AtomicString(), context))
       return false;
   }
 
   return true;
 }
 
+void PerformanceBase::AddServerTiming(const ResourceResponse& response,
+                                      ShouldAddToBuffer shouldAddToBuffer) {
+  if (shouldAddToBuffer == ShouldAddToBuffer::Never &&
+      !HasObserverFor(PerformanceEntry::kServer)) {
+    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));
+  if ((*headers).size() == 0) {
+    return;
+  }
+
+  PerformanceEntryVector entries;
+  for (const auto& header : *headers) {
+    PerformanceEntry* entry = PerformanceServerTiming::create(
+        response.Url().GetString(), header->metric,
+        allowTimingDetails ? header->duration : 0.0,
+        allowTimingDetails ? header->description : "");
+    entries.push_back(*entry);
+  }
+
+  NotifyObserversOfEntries(entries);
+  if (shouldAddToBuffer == ShouldAddToBuffer::Always &&
+      server_timing_buffer_.size() + entries.size() <=
+          kServerTimingBufferSize) {
+    server_timing_buffer_.AppendVector(entries);
+  }
+}
+
 void PerformanceBase::AddResourceTiming(const ResourceTimingInfo& info) {
   if (IsResourceTimingBufferFull() &&
       !HasObserverFor(PerformanceEntry::kResource))
     return;
   ExecutionContext* context = GetExecutionContext();
   SecurityOrigin* security_origin = GetSecurityOrigin(context);
   if (!security_origin)
     return;
 
   const ResourceResponse& final_response = info.FinalResponse();
@@ skipping 158 matching lines @@
   UpdateLongTaskInstrumentation();
 }
 
 void PerformanceBase::NotifyObserversOfEntry(PerformanceEntry& entry) {
   for (auto& observer : observers_) {
     if (observer->FilterOptions() & entry.EntryTypeEnum())
       observer->EnqueuePerformanceEntry(entry);
   }
 }
 
+void PerformanceBase::NotifyObserversOfEntries(
+    PerformanceEntryVector& entries) {
+  for (const auto& entry : entries) {
+    NotifyObserversOfEntry(*entry.Get());
+  }
+}
+
 bool PerformanceBase::HasObserverFor(
     PerformanceEntry::EntryType filter_type) const {
   return observer_filter_options_ & filter_type;
 }
 
 void PerformanceBase::ActivateObserver(PerformanceObserver& observer) {
   if (active_observers_.IsEmpty())
     deliver_observations_timer_.StartOneShot(0, BLINK_FROM_HERE);
 
   active_observers_.insert(&observer);
@@ skipping 53 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(observers_);
   visitor->Trace(active_observers_);
   visitor->Trace(suspended_observers_);
   EventTargetWithInlineData::Trace(visitor);
 }
 
 }  // namespace blink