Offer Resource Timing in workers

Source/core/loader/WorkerThreadableLoader.cpp

 /*
  * Copyright (C) 2009, 2010 Google 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 18 matching lines @@
  */
 
 #include "config.h"
 
 #include "core/loader/WorkerThreadableLoader.h"
 
 #include "core/dom/CrossThreadTask.h"
 #include "core/dom/Document.h"
 #include "core/loader/DocumentThreadableLoader.h"
 #include "core/loader/WorkerLoaderClientBridgeSyncHelper.h"
+#include "core/timing/WorkerGlobalScopePerformance.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerLoaderProxy.h"
 #include "core/workers/WorkerThread.h"
 #include "platform/heap/SafePoint.h"
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
 #include "platform/weborigin/SecurityPolicy.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebWaitableEvent.h"
 #include "wtf/MainThread.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 WorkerThreadableLoader::WorkerThreadableLoader(WorkerGlobalScope& workerGlobalScope, PassRefPtr<ThreadableLoaderClientWrapper> clientWrapper, PassOwnPtr<ThreadableLoaderClient> clientBridge, const ResourceRequest& request, const ThreadableLoaderOptions& options, const ResourceLoaderOptions& resourceLoaderOptions)
     : m_workerGlobalScope(&workerGlobalScope)
     , m_workerClientWrapper(clientWrapper)
     , m_bridge(*(new MainThreadBridge(m_workerClientWrapper, clientBridge, workerGlobalScope.thread()->workerLoaderProxy(), request, options, resourceLoaderOptions, workerGlobalScope.referrerPolicy(), workerGlobalScope.url().strippedForUseAsReferrer())))
 {
+    m_workerClientWrapper->setResourceTimingClient(this);
 }
 
 WorkerThreadableLoader::~WorkerThreadableLoader()
 {
+    m_workerClientWrapper->clearResourceTimingClient();
     m_bridge.destroy();
 }
 
 void WorkerThreadableLoader::loadResourceSynchronously(WorkerGlobalScope& workerGlobalScope, const ResourceRequest& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options, const ResourceLoaderOptions& resourceLoaderOptions)
 {
     WebWaitableEvent* shutdownEvent =
         workerGlobalScope.thread()->shutdownEvent();
     OwnPtr<WebWaitableEvent> loaderDone =
         adoptPtr(Platform::current()->createWaitableEvent());
 
     Vector<WebWaitableEvent*> events;
     events.append(shutdownEvent);
     events.append(loaderDone.get());
 
     RefPtr<ThreadableLoaderClientWrapper> clientWrapper(ThreadableLoaderClientWrapper::create(&client));
-    OwnPtr<WorkerLoaderClientBridgeSyncHelper> clientBridge(WorkerLoaderClientBridgeSyncHelper::create(client, loaderDone.release()));
+    OwnPtr<WorkerLoaderClientBridgeSyncHelper> clientBridge(WorkerLoaderClientBridgeSyncHelper::create(clientWrapper.get(), loaderDone.release()));
 
     // This must be valid while loader is around.
     WorkerLoaderClientBridgeSyncHelper* clientBridgePtr = clientBridge.get();
 
     RefPtr<WorkerThreadableLoader> loader = WorkerThreadableLoader::create(workerGlobalScope, clientWrapper, clientBridge.release(), request, options, resourceLoaderOptions);
 
     WebWaitableEvent* signalled;
     {
         SafePointScope scope(ThreadState::HeapPointersOnStack);
         signalled = Platform::current()->waitMultipleEvents(events);
     }
     if (signalled == shutdownEvent) {
         loader->cancel();
         return;
     }
 
     clientBridgePtr->run();
 }
 
 void WorkerThreadableLoader::overrideTimeout(unsigned long timeoutMilliseconds)
 {
     m_bridge.overrideTimeout(timeoutMilliseconds);
 }
 
 void WorkerThreadableLoader::cancel()
 {
     m_bridge.cancel();
 }
 
+void WorkerThreadableLoader::didReceiveResourceTiming(const ResourceTimingInfo& info)
+{
+    WorkerGlobalScopePerformance::performance(*m_workerGlobalScope)->addResourceTiming(info);
+}
+
 WorkerThreadableLoader::MainThreadBridge::MainThreadBridge(
     PassRefPtr<ThreadableLoaderClientWrapper> workerClientWrapper,
     PassOwnPtr<ThreadableLoaderClient> clientBridge,
     PassRefPtr<WorkerLoaderProxy> loaderProxy,
     const ResourceRequest& request,
     const ThreadableLoaderOptions& options,
     const ResourceLoaderOptions& resourceLoaderOptions,
     const ReferrerPolicy referrerPolicy,
     const String& outgoingReferrer)
     : m_clientBridge(clientBridge)
@@ skipping 128 matching lines @@
 void WorkerThreadableLoader::MainThreadBridge::didFailAccessControlCheck(const ResourceError& error)
 {
     m_clientBridge->didFailAccessControlCheck(error);
 }
 
 void WorkerThreadableLoader::MainThreadBridge::didFailRedirectCheck()
 {
     m_clientBridge->didFailRedirectCheck();
 }
 
+void WorkerThreadableLoader::MainThreadBridge::didReceiveResourceTiming(const ResourceTimingInfo& info)
+{
+    m_clientBridge->didReceiveResourceTiming(info);
+}
+
 } // namespace blink