[CacheStorage] [DevTools] Added "Time Received" column to cache storage data grid

third_party/WebKit/Source/modules/cachestorage/InspectorCacheStorageAgent.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/cachestorage/InspectorCacheStorageAgent.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 #include "platform/heap/Handle.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/wtf/Noncopyable.h"
 #include "platform/wtf/PassRefPtr.h"
 #include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/RefCounted.h"
 #include "platform/wtf/RefPtr.h"
+#include "platform/wtf/Time.h"
 #include "platform/wtf/Vector.h"
 #include "platform/wtf/text/StringBuilder.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebSecurityOrigin.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebVector.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerCache.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerCacheError.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerCacheStorage.h"
@@ skipping 130 matching lines @@
   int skip_count;
   int page_size;
 };
 
 struct RequestResponse {
   RequestResponse() {}
   RequestResponse(const String& request, const String& response)
       : request(request), response(response) {}
   String request;
   String response;
+  int64_t responseTime;
 };
 
 class ResponsesAccumulator : public RefCounted<ResponsesAccumulator> {
   WTF_MAKE_NONCOPYABLE(ResponsesAccumulator);
 
  public:
   ResponsesAccumulator(int num_responses,
                        const DataRequestParams& params,
                        std::unique_ptr<RequestEntriesCallback> callback)
       : params_(params),
         num_responses_left_(num_responses),
         responses_(static_cast<size_t>(num_responses)),
         callback_(std::move(callback)) {}
 
   void AddRequestResponsePair(const WebServiceWorkerRequest& request,
                               const WebServiceWorkerResponse& response) {
     DCHECK_GT(num_responses_left_, 0);
     RequestResponse& request_response =
         responses_.at(responses_.size() - num_responses_left_);
     request_response.request = request.Url().GetString();
     request_response.response = response.StatusText();
+    request_response.responseTime =
+        WTF::Time::FromInternalValue(response.ResponseTime()).ToTimeT();
 
     if (--num_responses_left_ != 0)
       return;
 
     std::sort(responses_.begin(), responses_.end(),
               [](const RequestResponse& a, const RequestResponse& b) {
                 return WTF::CodePointCompareLessThan(a.request, b.request);
               });
     if (params_.skip_count > 0)
       responses_.erase(0, params_.skip_count);
     bool has_more = false;
     if (static_cast<size_t>(params_.page_size) < responses_.size()) {
       responses_.erase(params_.page_size,
                        responses_.size() - params_.page_size);
       has_more = true;
     }
     std::unique_ptr<Array<DataEntry>> array = Array<DataEntry>::create();
     for (const auto& request_response : responses_) {
       std::unique_ptr<DataEntry> entry =
           DataEntry::create()
               .setRequest(request_response.request)
               .setResponse(request_response.response)
+              .setResponseTime(request_response.responseTime)

[dgozman, 2017/06/07 21:32:06]

We usually send a double which means "Number of seconds since epoch".

[kristipark, 2017/06/07 22:42:37]

Done.

               .build();
       array->addItem(std::move(entry));
     }
     callback_->sendSuccess(std::move(array), has_more);
   }
 
   void SendFailure(const Response& error) { callback_->sendFailure(error); }
 
  private:
   DataRequestParams params_;
@@ skipping 265 matching lines @@
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
   }
   cache->DispatchOpen(WTF::MakeUnique<GetCacheForDeleteEntry>(
                           request, cache_name, std::move(callback)),
                       WebString(cache_name));
 }
 
 }  // namespace blink