Updates to Server-Timing in accordance with with spec changes

third_party/WebKit/Source/core/timing/PerformanceResourceTiming.cpp

 /*
  * Copyright (C) 2012 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 27 matching lines @@
 #include "platform/loader/fetch/ResourceTimingInfo.h"
 
 namespace blink {
 
 PerformanceResourceTiming::PerformanceResourceTiming(
     const ResourceTimingInfo& info,
     double time_origin,
     double start_time,
     double last_redirect_end_time,
     bool allow_timing_details,
-    bool allow_redirect_details)
+    bool allow_redirect_details,
+    PerformanceServerTimingVector& serverTiming)
     : PerformanceEntry(info.InitialURL().GetString(),
                        "resource",
                        PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(
                            time_origin,
                            start_time,
                            info.NegativeAllowed()),
                        PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(
                            time_origin,
                            info.LoadFinishTime(),
                            info.NegativeAllowed())),
       initiator_type_(info.InitiatorType()),
       alpn_negotiated_protocol_(info.FinalResponse().AlpnNegotiatedProtocol()),
       connection_info_(info.FinalResponse().ConnectionInfoString()),
       time_origin_(time_origin),
       timing_(info.FinalResponse().GetResourceLoadTiming()),
       last_redirect_end_time_(last_redirect_end_time),
       finish_time_(info.LoadFinishTime()),
       transfer_size_(info.TransferSize()),
       encoded_body_size_(info.FinalResponse().EncodedBodyLength()),
       decoded_body_size_(info.FinalResponse().DecodedBodyLength()),
       did_reuse_connection_(info.FinalResponse().ConnectionReused()),
       allow_timing_details_(allow_timing_details),
       allow_redirect_details_(allow_redirect_details),
-      allow_negative_value_(info.NegativeAllowed()) {}
+      allow_negative_value_(info.NegativeAllowed()),
+      serverTiming_(serverTiming) {}
 
 // This constructor is for PerformanceNavigationTiming.
-PerformanceResourceTiming::PerformanceResourceTiming(const String& name,
-                                                     const String& entry_type,
-                                                     double start_time,
-                                                     double duration)
-    : PerformanceEntry(name, entry_type, start_time, duration) {}
+PerformanceResourceTiming::PerformanceResourceTiming(
+    const String& name,
+    const String& entry_type,
+    double start_time,
+    double duration,
+    PerformanceServerTimingVector& serverTiming)
+    : PerformanceEntry(name, entry_type, start_time, duration),
+      serverTiming_(serverTiming) {}
 
 PerformanceResourceTiming::~PerformanceResourceTiming() {}
 
 ResourceLoadTiming* PerformanceResourceTiming::GetResourceLoadTiming() const {
   return timing_.Get();
 }
 
 bool PerformanceResourceTiming::AllowTimingDetails() const {
   return allow_timing_details_;
 }
@@ skipping 210 matching lines @@
   return GetEncodedBodySize();
 }
 
 unsigned long long PerformanceResourceTiming::decodedBodySize() const {
   if (!AllowTimingDetails())
     return 0;
 
   return GetDecodedBodySize();
 }
 
-void PerformanceResourceTiming::BuildJSONValue(V8ObjectBuilder& builder) const {
-  PerformanceEntry::BuildJSONValue(builder);
+PerformanceServerTimingVector PerformanceResourceTiming::serverTiming() const {
+  return serverTiming_;
+}
+
+void PerformanceResourceTiming::BuildJSONValue(ScriptState* script_state,
+                                               V8ObjectBuilder& builder) const {
+  PerformanceEntry::BuildJSONValue(script_state, builder);
   builder.AddString("initiatorType", initiatorType());
   builder.AddString("nextHopProtocol", nextHopProtocol());
   builder.AddNumber("workerStart", workerStart());
   builder.AddNumber("redirectStart", redirectStart());
   builder.AddNumber("redirectEnd", redirectEnd());
   builder.AddNumber("fetchStart", fetchStart());
   builder.AddNumber("domainLookupStart", domainLookupStart());
   builder.AddNumber("domainLookupEnd", domainLookupEnd());
   builder.AddNumber("connectStart", connectStart());
   builder.AddNumber("connectEnd", connectEnd());
   builder.AddNumber("secureConnectionStart", secureConnectionStart());
   builder.AddNumber("requestStart", requestStart());
   builder.AddNumber("responseStart", responseStart());
   builder.AddNumber("responseEnd", responseEnd());
   builder.AddNumber("transferSize", transferSize());
   builder.AddNumber("encodedBodySize", encodedBodySize());
   builder.AddNumber("decodedBodySize", decodedBodySize());
+
+  Vector<ScriptValue> serverTiming;
+  for (unsigned i = 0; i < serverTiming_.size(); i++) {
+    serverTiming.push_back(serverTiming_[i]->toJSONForBinding(script_state));
+  }
+  builder.Add("serverTiming", serverTiming);
+}
+
+DEFINE_TRACE(PerformanceResourceTiming) {
+  visitor->Trace(serverTiming_);
+  PerformanceEntry::Trace(visitor);
 }
 
 }  // namespace blink