Updates to Server-Timing in accordance with with spec changes

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_);
   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;
 }
 
@@ skipping 23 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;
     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::kLongTask:
@@ skipping 42 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;
+PerformanceServerTimingVector PerformanceBase::ParseServerTiming(

[Yoav Weiss, 2017/06/29 06:57:33]

I think it'd make more sense to move this function to be static on
PerformanceServerTiming

+    const ResourceTimingInfo& info,
+    bool allowTimingDetails) {
+  PerformanceServerTimingVector entries;
+  if (RuntimeEnabledFeatures::ServerTimingEnabled()) {
+    const ResourceResponse& response = info.FinalResponse();
+    std::unique_ptr<ServerTimingHeaderVector> headers = ParseServerTimingHeader(
+        response.HttpHeaderField(HTTPNames::Server_Timing));
+    for (const auto& header : *headers) {
+      entries.push_back(
+          new PerformanceServerTiming(header->metric, header->value,
+                                      header->description, allowTimingDetails));
+    }
   }
-
-  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);
-  }
+  return 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();
   bool allow_timing_details =
       PassesTimingAllowCheck(final_response, *security_origin,
                              info.OriginalTimingAllowOrigin(), context);
   double start_time = info.InitialTime();
 
+  PerformanceServerTimingVector serverTiming =
+      ParseServerTiming(info, allow_timing_details);
+
   if (info.RedirectChain().IsEmpty()) {
     PerformanceEntry* entry = PerformanceResourceTiming::Create(
-        info, TimeOrigin(), start_time, allow_timing_details);
+        info, TimeOrigin(), start_time, allow_timing_details, serverTiming);
     NotifyObserversOfEntry(*entry);
     if (!IsResourceTimingBufferFull())
       AddResourceTimingBuffer(*entry);
     return;
   }
 
   const Vector<ResourceResponse>& redirect_chain = info.RedirectChain();
   bool allow_redirect_details = AllowsTimingRedirect(
       redirect_chain, final_response, *security_origin, context);
 
   if (!allow_redirect_details) {
     ResourceLoadTiming* final_timing = final_response.GetResourceLoadTiming();
     DCHECK(final_timing);
     if (final_timing)
       start_time = final_timing->RequestTime();
   }
 
   ResourceLoadTiming* last_redirect_timing =
       redirect_chain.back().GetResourceLoadTiming();
   DCHECK(last_redirect_timing);
   double last_redirect_end_time = last_redirect_timing->ReceiveHeadersEnd();
 
   PerformanceEntry* entry = PerformanceResourceTiming::Create(
       info, TimeOrigin(), start_time, last_redirect_end_time,
-      allow_timing_details, allow_redirect_details);
+      allow_timing_details, allow_redirect_details, serverTiming);
   NotifyObserversOfEntry(*entry);
   if (!IsResourceTimingBufferFull())
     AddResourceTimingBuffer(*entry);
 }
 
 // Called after loadEventEnd happens.
 void PerformanceBase::NotifyNavigationTimingToObservers() {
   if (!navigation_timing_)
     navigation_timing_ = CreateNavigationTimingInstance();
   if (navigation_timing_)
@@ skipping 204 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