Introduce ServiceWorker.EventDispatchingDelay UMA

third_party/WebKit/Source/modules/serviceworkers/WaitUntilObserver.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/serviceworkers/WaitUntilObserver.h"
 
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
@@ skipping 66 matching lines @@
     ResolveType m_resolveType;
 };
 
 WaitUntilObserver* WaitUntilObserver::create(ExecutionContext* context, EventType type, int eventID)
 {
     return new WaitUntilObserver(context, type, eventID);
 }
 
 void WaitUntilObserver::willDispatchEvent()
 {
+    m_eventDispatchTime = WTF::currentTime();
     // When handling a notificationclick event, we want to allow one window to
     // be focused or opened. These calls are allowed between the call to
     // willDispatchEvent() and the last call to decrementPendingActivity(). If
     // waitUntil() isn't called, that means between willDispatchEvent() and
     // didDispatchEvent().
     if (m_type == NotificationClick)
         getExecutionContext()->allowWindowInteraction();
 
     incrementPendingActivity();
 }
@@ skipping 27 matching lines @@
     incrementPendingActivity();
     scriptPromise.then(
         ThenFunction::createFunction(scriptState, this, ThenFunction::Fulfilled),
         ThenFunction::createFunction(scriptState, this, ThenFunction::Rejected));
 }
 
 WaitUntilObserver::WaitUntilObserver(ExecutionContext* context, EventType type, int eventID)
     : ContextLifecycleObserver(context)
     , m_type(type)
     , m_eventID(eventID)
-    , m_pendingActivity(0)
-    , m_hasError(false)
-    , m_eventDispatched(false)
     , m_consumeWindowInteractionTimer(this, &WaitUntilObserver::consumeWindowInteraction)
 {
 }
 
 void WaitUntilObserver::reportError(const ScriptValue& value)
 {
     // FIXME: Propagate error message to the client for onerror handling.
     NOTIMPLEMENTED();
 
     m_hasError = true;
 }
 
 void WaitUntilObserver::incrementPendingActivity()
 {
     ++m_pendingActivity;
 }
 
 void WaitUntilObserver::decrementPendingActivity()
 {
     ASSERT(m_pendingActivity > 0);
     if (!getExecutionContext() || (!m_hasError && --m_pendingActivity))
         return;
 
     ServiceWorkerGlobalScopeClient* client = ServiceWorkerGlobalScopeClient::from(getExecutionContext());
     WebServiceWorkerEventResult result = m_hasError ? WebServiceWorkerEventResultRejected : WebServiceWorkerEventResultCompleted;
     switch (m_type) {
     case Activate:
-        client->didHandleActivateEvent(m_eventID, result);
+        client->didHandleActivateEvent(m_eventID, result, m_eventDispatchTime);
         break;
     case Fetch:
-        client->didHandleFetchEvent(m_eventID, result);
+        client->didHandleFetchEvent(m_eventID, result, m_eventDispatchTime);
         break;
     case Install:
-        client->didHandleInstallEvent(m_eventID, result);
+        client->didHandleInstallEvent(m_eventID, result, m_eventDispatchTime);
         break;
     case Message:
-        client->didHandleExtendableMessageEvent(m_eventID, result);
+        client->didHandleExtendableMessageEvent(m_eventID, result, m_eventDispatchTime);
         break;
     case NotificationClick:
-        client->didHandleNotificationClickEvent(m_eventID, result);
+        client->didHandleNotificationClickEvent(m_eventID, result, m_eventDispatchTime);
         m_consumeWindowInteractionTimer.stop();
         consumeWindowInteraction(nullptr);
         break;
     case NotificationClose:
-        client->didHandleNotificationCloseEvent(m_eventID, result);
+        client->didHandleNotificationCloseEvent(m_eventID, result, m_eventDispatchTime);
         break;
     case Push:
-        client->didHandlePushEvent(m_eventID, result);
+        client->didHandlePushEvent(m_eventID, result, m_eventDispatchTime);
         break;
     case Sync:
-        client->didHandleSyncEvent(m_eventID, result);
+        client->didHandleSyncEvent(m_eventID, result, m_eventDispatchTime);
         break;
     }
     setContext(nullptr);
 }
 
 void WaitUntilObserver::consumeWindowInteraction(TimerBase*)
 {
     if (!getExecutionContext())
         return;
     getExecutionContext()->consumeWindowInteraction();
 }
 
 DEFINE_TRACE(WaitUntilObserver)
 {
     ContextLifecycleObserver::trace(visitor);
 }
 
 } // namespace blink