Support PerformanceResourceTiming for Service Worker Navigation Preload

third_party/WebKit/Source/platform/loader/fetch/ResourceTimingInfo.h

 /*
  * Copyright (C) 2013 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.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 86 matching lines @@
     transfer_size_ += encoded_data_length;
   }
   long long TransferSize() const { return transfer_size_; }
 
   void ClearLoadTimings() {
     final_response_.SetResourceLoadTiming(nullptr);
     for (ResourceResponse& redirect : redirect_chain_)
       redirect.SetResourceLoadTiming(nullptr);
   }
 
+  // The timestams in PerformanceResourceTiming are measured relative from the

[Kunihiko Sakamoto, 2017/04/28 11:49:00]

timestams -> timestamps

[horo, 2017/04/28 11:56:42]

Done.

+  // time origin. In most cases these timestamps must be positive value, so we
+  // use 0 for invalid negative values. But the timestamps for Service Worker
+  // navigation preload requests may be negative, because these requests may
+  // be started before the service worker started. We set this flag true, to
+  // support such case.
+  void SetNegativeAllowed(bool negative_allowed) {
+    negative_allowed_ = negative_allowed;
+  }
+  bool NegativeAllowed() const { return negative_allowed_; }
+
  private:
   ResourceTimingInfo(const AtomicString& type,
                      const double time,
                      bool is_main_resource)
-      : type_(type),
-        initial_time_(time),
-        transfer_size_(0),
-        is_main_resource_(is_main_resource),
-        has_cross_origin_redirect_(false) {}
+      : type_(type), initial_time_(time), is_main_resource_(is_main_resource) {}
 
   AtomicString type_;
   AtomicString original_timing_allow_origin_;
   double initial_time_;
   double load_finish_time_;
   KURL initial_url_;
   ResourceResponse final_response_;
   Vector<ResourceResponse> redirect_chain_;
-  long long transfer_size_;
+  long long transfer_size_ = 0;
   bool is_main_resource_;
-  bool has_cross_origin_redirect_;
+  bool has_cross_origin_redirect_ = false;
+  bool negative_allowed_ = false;
 };
 
 struct CrossThreadResourceTimingInfoData {
   WTF_MAKE_NONCOPYABLE(CrossThreadResourceTimingInfoData);
   USING_FAST_MALLOC(CrossThreadResourceTimingInfoData);
 
  public:
   CrossThreadResourceTimingInfoData() {}
 
   String type_;
   String original_timing_allow_origin_;
   double initial_time_;
   double load_finish_time_;
   KURL initial_url_;
   std::unique_ptr<CrossThreadResourceResponseData> final_response_;
   Vector<std::unique_ptr<CrossThreadResourceResponseData>> redirect_chain_;
   long long transfer_size_;
   bool is_main_resource_;
+  bool negative_allowed_;
 };
 
 template <>
 struct CrossThreadCopier<ResourceTimingInfo> {
   typedef WTF::PassedWrapper<std::unique_ptr<CrossThreadResourceTimingInfoData>>
       Type;
   static Type Copy(const ResourceTimingInfo& info) {
     return WTF::Passed(info.CopyData());
   }
 };
 
 }  // namespace blink
 
 #endif