Introduce ServiceWorker.EventDispatchingDelay UMA

content/browser/service_worker/service_worker_url_request_job_unittest.cc

 // 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 "content/browser/service_worker/service_worker_url_request_job.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/time/time.h"
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
 #include "content/browser/fileapi/mock_url_request_delegate.h"
 #include "content/browser/resource_context_impl.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_provider_host.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_response_info.h"
 #include "content/browser/service_worker/service_worker_test_utils.h"
@@ skipping 339 matching lines @@
     context()->RemoveProviderHost(mock_render_process_id(), kProviderID);
     SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
         embedded_worker_id, response_id,
         SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
         ServiceWorkerResponse(
             GURL(), 200, "OK", blink::WebServiceWorkerResponseTypeDefault,
             ServiceWorkerHeaderMap(), std::string(), 0, GURL(),
             blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
             false /* response_is_in_cache_storage */,
             std::string() /* response_cache_storage_cache_name */,
-            ServiceWorkerHeaderList() /* cors_exposed_header_names */)));
+            ServiceWorkerHeaderList() /* cors_exposed_header_names */),
+        base::Time::Now()));
     SimulateSend(new ServiceWorkerHostMsg_FetchEventFinished(
         embedded_worker_id, event_finish_id,
-        blink::WebServiceWorkerEventResultCompleted));
+        blink::WebServiceWorkerEventResultCompleted, base::Time::Now()));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ProviderDeleteHelper);
 };
 
 TEST_F(ServiceWorkerURLRequestJobTest, DeletedProviderHostOnFetchEvent) {
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   // Shouldn't crash if the ProviderHost is deleted prior to completion of
   // the fetch event.
@@ skipping 59 matching lines @@
                     const ServiceWorkerFetchRequest& request) override {
     SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
         embedded_worker_id, response_id,
         SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
         ServiceWorkerResponse(
             GURL(), 200, "OK", blink::WebServiceWorkerResponseTypeDefault,
             ServiceWorkerHeaderMap(), blob_uuid_, blob_size_, GURL(),
             blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
             false /* response_is_in_cache_storage */,
             std::string() /* response_cache_storage_cache_name */,
-            ServiceWorkerHeaderList() /* cors_exposed_header_names */)));
+            ServiceWorkerHeaderList() /* cors_exposed_header_names */),
+        base::Time::Now()));
     SimulateSend(new ServiceWorkerHostMsg_FetchEventFinished(
         embedded_worker_id, event_finish_id,
-        blink::WebServiceWorkerEventResultCompleted));
+        blink::WebServiceWorkerEventResultCompleted, base::Time::Now()));
   }
 
   std::string blob_uuid_;
   uint64_t blob_size_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BlobResponder);
 };
 
 TEST_F(ServiceWorkerURLRequestJobTest, BlobResponse) {
@@ skipping 59 matching lines @@
                     const ServiceWorkerFetchRequest& request) override {
     SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
         embedded_worker_id, response_id,
         SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
         ServiceWorkerResponse(
             GURL(), 200, "OK", blink::WebServiceWorkerResponseTypeDefault,
             ServiceWorkerHeaderMap(), "", 0, stream_url_,
             blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
             false /* response_is_in_cache_storage */,
             std::string() /* response_cache_storage_cache_name */,
-            ServiceWorkerHeaderList() /* cors_exposed_header_names */)));
+            ServiceWorkerHeaderList() /* cors_exposed_header_names */),
+        base::Time::Now()));
     SimulateSend(new ServiceWorkerHostMsg_FetchEventFinished(
         embedded_worker_id, event_finish_id,
-        blink::WebServiceWorkerEventResultCompleted));
+        blink::WebServiceWorkerEventResultCompleted, base::Time::Now()));
   }
 
   const GURL stream_url_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StreamResponder);
 };
 
 TEST_F(ServiceWorkerURLRequestJobTest, StreamResponse) {
   const GURL stream_url("blob://stream");
@@ skipping 386 matching lines @@
 }
 
 class EarlyResponseHelper : public EmbeddedWorkerTestHelper {
  public:
   EarlyResponseHelper() : EmbeddedWorkerTestHelper(base::FilePath()) {}
   ~EarlyResponseHelper() override {}
 
   void FinishWaitUntil() {
     SimulateSend(new ServiceWorkerHostMsg_FetchEventFinished(
         embedded_worker_id_, event_finish_id_,
-        blink::WebServiceWorkerEventResultCompleted));
+        blink::WebServiceWorkerEventResultCompleted, base::Time::Now()));
   }
 
  protected:
   void OnFetchEvent(int embedded_worker_id,
                     int response_id,
                     int event_finish_id,
                     const ServiceWorkerFetchRequest& request) override {
     embedded_worker_id_ = embedded_worker_id;
     event_finish_id_ = event_finish_id;
     SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
         embedded_worker_id, response_id,
         SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
         ServiceWorkerResponse(
             GURL(), 200, "OK", blink::WebServiceWorkerResponseTypeDefault,
             ServiceWorkerHeaderMap(), std::string(), 0, GURL(),
             blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
             false /* response_is_in_cache_storage */,
             std::string() /* response_cache_storage_cache_name */,
-            ServiceWorkerHeaderList() /* cors_exposed_header_names */)));
+            ServiceWorkerHeaderList() /* cors_exposed_header_names */),
+        base::Time::Now()));
   }
 
  private:
   int embedded_worker_id_ = 0;
   int event_finish_id_ = 0;
   DISALLOW_COPY_AND_ASSIGN(EarlyResponseHelper);
 };
 
 // This simulates the case when a response is returned and the fetch event is
 // still in flight.
@@ skipping 32 matching lines @@
   void Respond() {
     SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
         embedded_worker_id_, response_id_,
         SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
         ServiceWorkerResponse(
             GURL(), 200, "OK", blink::WebServiceWorkerResponseTypeDefault,
             ServiceWorkerHeaderMap(), std::string(), 0, GURL(),
             blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
             false /* response_is_in_cache_storage */,
             std::string() /* response_cache_storage_cache_name */,
-            ServiceWorkerHeaderList() /* cors_exposed_header_names */)));
+            ServiceWorkerHeaderList() /* cors_exposed_header_names */),
+        base::Time::Now()));
     SimulateSend(new ServiceWorkerHostMsg_FetchEventFinished(
         embedded_worker_id_, event_finish_id_,
-        blink::WebServiceWorkerEventResultCompleted));
+        blink::WebServiceWorkerEventResultCompleted, base::Time::Now()));
   }
 
  protected:
   void OnFetchEvent(int embedded_worker_id,
                     int response_id,
                     int event_finish_id,
                     const ServiceWorkerFetchRequest& request) override {
     embedded_worker_id_ = embedded_worker_id;
     response_id_ = response_id;
     event_finish_id_ = event_finish_id;
@@ skipping 31 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   // The fetch event request should no longer be in-flight.
   EXPECT_FALSE(version_->HasWork());
 }
 
 // TODO(kinuko): Add more tests with different response data and also for
 // FallbackToNetwork case.
 
 }  // namespace content