Let the time origin of WorkerGlobalScope be its time of creation

In this CL, WorkerGlobalScope's |time_origin_| is set to the time of
creation. As a result, many time origins are no longer needed in
constructors.

Bug: chromium:688542
Change-Id: Ie15dccd7c81e6c29ad23244278fb7cc5131bdaf2
Reviewed-on: https://chromium-review.googlesource.com/563957
Commit-Queue: Nicolás Peña <npm@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#487541}

third_party/WebKit/LayoutTests/FlagExpectations/enable-features=NetworkService

@@ -294,7 +294,7 @@ Bug(none) external/wpt/fullscreen/api/document-exit-fullscreen-active-document.h
 Bug(none) external/wpt/fullscreen/api/document-fullscreen-enabled-active-document.html [ Failure Timeout ]
 Bug(none) external/wpt/fullscreen/api/element-request-fullscreen-active-document.html [ Failure Timeout ]
 Bug(none) external/wpt/hr-time/test_cross_frame_start.html [ Failure Timeout ]
-Bug(none) external/wpt/hr-time/window-worker-time-origin.html [ Failure Timeout ]
+Bug(none) external/wpt/hr-time/window-worker-time-origin.html [ Timeout ]
 Bug(none) external/wpt/html/browsers/browsing-the-web/navigating-across-documents/012.html [ Failure Timeout ]
 Bug(none) external/wpt/html/browsers/browsing-the-web/read-media/pageload-video.html [ Crash Pass Failure Timeout ]
 Bug(none) external/wpt/html/browsers/browsing-the-web/unloading-documents/005.html [ Crash ]

third_party/WebKit/LayoutTests/TestExpectations

@@ -1681,7 +1681,6 @@ crbug.com/694958 virtual/stable/http/tests/navigation/same-and-different-back.ht
 # numbers so a consistent baseline cannot be added. This test could be
 # imported if the test passed or if the results for testharness tests
 # were matched on pass/fail but not exact error messages.
-crbug.com/688854 external/wpt/hr-time/window-worker-time-origin.html [ Failure ]
 crbug.com/626703 external/wpt/resource-timing/resource_TAO_space.htm [ Pass Failure ]
 crbug.com/626703 [ Mac ] external/wpt/web-animations/interfaces/AnimationTimeline/document-timeline.html [ Failure ]
 

third_party/WebKit/LayoutTests/http/tests/w3c/webperf/submission/Google/HighResolutionTime/worker-dedicated-basic.html

@@ -26,7 +26,7 @@ worker.onmessage = function(event) {
     assert_true(results.length == 3);
     test_true(results[0], "self.performance is defined");
     test_true(results[1], "self.performance.now is defined");
-    test_greater_than(results[2], startTime, "Time in the worker should be after the startTime in the main document");
+    test_greater_than(results[2], 0, "Time in the worker should be positive");
     test_greater_than(window.performance.now(), results[2], "Time in the worker should be before the current time in the main document");
     done();
 }

third_party/WebKit/Source/core/workers/DedicatedWorkerMessagingProxy.cpp

@@ -34,10 +34,10 @@ DedicatedWorkerMessagingProxy::CreateBackingThreadStartupData(
                              : AtomicsWaitMode::kDisallow);
 }
 
-std::unique_ptr<WorkerThread> DedicatedWorkerMessagingProxy::CreateWorkerThread(
-    double origin_time) {
+std::unique_ptr<WorkerThread>
+DedicatedWorkerMessagingProxy::CreateWorkerThread() {
   return DedicatedWorkerThread::Create(CreateThreadableLoadingContext(),
-                                       WorkerObjectProxy(), origin_time);
+                                       WorkerObjectProxy());
 }
 
 }  // namespace blink

third_party/WebKit/Source/core/workers/DedicatedWorkerMessagingProxy.h

@@ -25,7 +25,7 @@ class CORE_EXPORT DedicatedWorkerMessagingProxy final
   WTF::Optional<WorkerBackingThreadStartupData> CreateBackingThreadStartupData(
       v8::Isolate*) override;
 
-  std::unique_ptr<WorkerThread> CreateWorkerThread(double origin_time) override;
+  std::unique_ptr<WorkerThread> CreateWorkerThread() override;
 };
 
 }  // namespace blink

third_party/WebKit/Source/core/workers/DedicatedWorkerTest.cpp

@@ -41,8 +41,7 @@ class DedicatedWorkerThreadForTest final : public DedicatedWorkerThread {
  public:
   DedicatedWorkerThreadForTest(InProcessWorkerObjectProxy& worker_object_proxy)
       : DedicatedWorkerThread(nullptr /* ThreadableLoadingContext */,
-                              worker_object_proxy,
-                              MonotonicallyIncreasingTime()) {
+                              worker_object_proxy) {
     worker_backing_thread_ = WorkerBackingThread::CreateForTest("Test thread");
   }
 
@@ -203,8 +202,7 @@ class InProcessWorkerMessagingProxyForTest
   }
 
  private:
-  std::unique_ptr<WorkerThread> CreateWorkerThread(
-      double origin_time) override {
+  std::unique_ptr<WorkerThread> CreateWorkerThread() override {
     auto worker_thread =
         WTF::MakeUnique<DedicatedWorkerThreadForTest>(WorkerObjectProxy());
     mock_worker_thread_lifecycle_observer_ =

third_party/WebKit/Source/core/workers/DedicatedWorkerThread.cpp

@@ -42,21 +42,18 @@ namespace blink {
 
 std::unique_ptr<DedicatedWorkerThread> DedicatedWorkerThread::Create(
     ThreadableLoadingContext* loading_context,
-    InProcessWorkerObjectProxy& worker_object_proxy,
-    double time_origin) {
-  return WTF::WrapUnique(new DedicatedWorkerThread(
-      loading_context, worker_object_proxy, time_origin));
+    InProcessWorkerObjectProxy& worker_object_proxy) {
+  return WTF::WrapUnique(
+      new DedicatedWorkerThread(loading_context, worker_object_proxy));
 }
 
 DedicatedWorkerThread::DedicatedWorkerThread(
     ThreadableLoadingContext* loading_context,
-    InProcessWorkerObjectProxy& worker_object_proxy,
-    double time_origin)
+    InProcessWorkerObjectProxy& worker_object_proxy)
     : WorkerThread(loading_context, worker_object_proxy),
       worker_backing_thread_(
           WorkerBackingThread::Create("DedicatedWorker Thread")),
-      worker_object_proxy_(worker_object_proxy),
-      time_origin_(time_origin) {}
+      worker_object_proxy_(worker_object_proxy) {}
 
 DedicatedWorkerThread::~DedicatedWorkerThread() {}
 

third_party/WebKit/Source/core/workers/DedicatedWorkerThread.h

@@ -42,8 +42,7 @@ class CORE_EXPORT DedicatedWorkerThread : public WorkerThread {
  public:
   static std::unique_ptr<DedicatedWorkerThread> Create(
       ThreadableLoadingContext*,
-      InProcessWorkerObjectProxy&,
-      double time_origin);
+      InProcessWorkerObjectProxy&);
   ~DedicatedWorkerThread() override;
 
   WorkerBackingThread& GetWorkerBackingThread() override {
@@ -55,9 +54,7 @@ class CORE_EXPORT DedicatedWorkerThread : public WorkerThread {
   }
 
  protected:
-  DedicatedWorkerThread(ThreadableLoadingContext*,
-                        InProcessWorkerObjectProxy&,
-                        double time_origin);
+  DedicatedWorkerThread(ThreadableLoadingContext*, InProcessWorkerObjectProxy&);
   WorkerOrWorkletGlobalScope* CreateWorkerGlobalScope(
       std::unique_ptr<GlobalScopeCreationParams>) override;
 
@@ -66,7 +63,6 @@ class CORE_EXPORT DedicatedWorkerThread : public WorkerThread {
 
   std::unique_ptr<WorkerBackingThread> worker_backing_thread_;
   InProcessWorkerObjectProxy& worker_object_proxy_;
-  double time_origin_;
 };
 
 }  // namespace blink

third_party/WebKit/Source/core/workers/SharedWorkerGlobalScope.cpp

@@ -54,11 +54,12 @@ MessageEvent* CreateConnectEvent(MessagePort* port) {
 SharedWorkerGlobalScope* SharedWorkerGlobalScope::Create(
     const String& name,
     SharedWorkerThread* thread,
-    std::unique_ptr<GlobalScopeCreationParams> creation_params) {
+    std::unique_ptr<GlobalScopeCreationParams> creation_params,
+    double time_origin) {
   SharedWorkerGlobalScope* context = new SharedWorkerGlobalScope(
       name, creation_params->script_url, creation_params->user_agent, thread,
       std::move(creation_params->starter_origin_privilege_data),
-      creation_params->worker_clients);
+      creation_params->worker_clients, time_origin);
   context->ApplyContentSecurityPolicyFromVector(
       *creation_params->content_security_policy_headers);
   context->SetWorkerSettings(std::move(creation_params->worker_settings));
@@ -77,11 +78,12 @@ SharedWorkerGlobalScope::SharedWorkerGlobalScope(
     SharedWorkerThread* thread,
     std::unique_ptr<SecurityOrigin::PrivilegeData>
         starter_origin_privilege_data,
-    WorkerClients* worker_clients)
+    WorkerClients* worker_clients,
+    double time_origin)
     : WorkerGlobalScope(url,
                         user_agent,
                         thread,
-                        MonotonicallyIncreasingTime(),
+                        time_origin,
                         std::move(starter_origin_privilege_data),
                         worker_clients),
       name_(name) {}

third_party/WebKit/Source/core/workers/SharedWorkerGlobalScope.h

@@ -50,7 +50,8 @@ class SharedWorkerGlobalScope final : public WorkerGlobalScope {
   static SharedWorkerGlobalScope* Create(
       const String& name,
       SharedWorkerThread*,
-      std::unique_ptr<GlobalScopeCreationParams>);
+      std::unique_ptr<GlobalScopeCreationParams>,
+      double time_origin);
   ~SharedWorkerGlobalScope() override;
 
   bool IsSharedWorkerGlobalScope() const override { return true; }
@@ -70,7 +71,8 @@ class SharedWorkerGlobalScope final : public WorkerGlobalScope {
                           const String& user_agent,
                           SharedWorkerThread*,
                           std::unique_ptr<SecurityOrigin::PrivilegeData>,
-                          WorkerClients*);
+                          WorkerClients*,
+                          double time_origin);
   void ExceptionThrown(ErrorEvent*) override;
 
   String name_;

third_party/WebKit/Source/core/workers/SharedWorkerThread.cpp

@@ -55,8 +55,8 @@ void SharedWorkerThread::ClearWorkerBackingThread() {
 
 WorkerOrWorkletGlobalScope* SharedWorkerThread::CreateWorkerGlobalScope(
     std::unique_ptr<GlobalScopeCreationParams> creation_params) {
-  return SharedWorkerGlobalScope::Create(name_, this,
-                                         std::move(creation_params));
+  return SharedWorkerGlobalScope::Create(
+      name_, this, std::move(creation_params), time_origin_);
 }
 
 }  // namespace blink

third_party/WebKit/Source/core/workers/ThreadedMessagingProxyBase.cpp

@@ -79,12 +79,8 @@ void ThreadedMessagingProxyBase::InitializeWorkerThread(
   DCHECK(IsParentContextThread());
 
   Document* document = ToDocument(GetExecutionContext());
-  double origin_time =
-      document->Loader()
-          ? document->Loader()->GetTiming().ReferenceMonotonicTime()
-          : MonotonicallyIncreasingTime();
 
-  worker_thread_ = CreateWorkerThread(origin_time);
+  worker_thread_ = CreateWorkerThread();
   worker_thread_->Start(std::move(global_scope_creation_params),
                         thread_startup_data, GetParentFrameTaskRunners());
   WorkerThreadCreated();

third_party/WebKit/Source/core/workers/ThreadedMessagingProxyBase.h

@@ -91,8 +91,7 @@ class CORE_EXPORT ThreadedMessagingProxyBase
   bool IsParentContextThread() const;
 
  private:
-  virtual std::unique_ptr<WorkerThread> CreateWorkerThread(
-      double origin_time) = 0;
+  virtual std::unique_ptr<WorkerThread> CreateWorkerThread() = 0;
 
   Member<ExecutionContext> execution_context_;
   Member<WorkerClients> worker_clients_;

third_party/WebKit/Source/core/workers/ThreadedWorkletTest.cpp

@@ -151,7 +151,7 @@ class ThreadedWorkletMessagingProxyForTest
  private:
   friend class ThreadedWorkletTest;
 
-  std::unique_ptr<WorkerThread> CreateWorkerThread(double origin_time) final {
+  std::unique_ptr<WorkerThread> CreateWorkerThread() final {
     return WTF::MakeUnique<ThreadedWorkletThreadForTest>(WorkletObjectProxy());
   }
 

third_party/WebKit/Source/core/workers/WorkerThread.cpp

@@ -329,7 +329,8 @@ service_manager::InterfaceProvider& WorkerThread::GetInterfaceProvider() {
 
 WorkerThread::WorkerThread(ThreadableLoadingContext* loading_context,
                            WorkerReportingProxy& worker_reporting_proxy)
-    : worker_thread_id_(GetNextWorkerThreadId()),
+    : time_origin_(MonotonicallyIncreasingTime()),
+      worker_thread_id_(GetNextWorkerThreadId()),
       forcible_termination_delay_(kForcibleTerminationDelay),
       inspector_task_runner_(WTF::MakeUnique<InspectorTaskRunner>()),
       loading_context_(loading_context),

third_party/WebKit/Source/core/workers/WorkerThread.h

@@ -196,6 +196,10 @@ class CORE_EXPORT WorkerThread : public WebThread::TaskObserver {
   // out of this class.
   virtual bool IsOwningBackingThread() const { return true; }
 
+  // Official moment of creation of worker: when the worker thread is created.
+  // (https://w3c.github.io/hr-time/#time-origin)
+  const double time_origin_;
+
  private:
   friend class WorkerThreadTest;
   FRIEND_TEST_ALL_PREFIXES(WorkerThreadTest,

third_party/WebKit/Source/modules/compositorworker/AnimationWorkletMessagingProxy.cpp

@@ -22,7 +22,7 @@ DEFINE_TRACE(AnimationWorkletMessagingProxy) {
 AnimationWorkletMessagingProxy::~AnimationWorkletMessagingProxy() {}
 
 std::unique_ptr<WorkerThread>
-AnimationWorkletMessagingProxy::CreateWorkerThread(double origin_time) {
+AnimationWorkletMessagingProxy::CreateWorkerThread() {
   return AnimationWorkletThread::Create(CreateThreadableLoadingContext(),
                                         WorkletObjectProxy());
 }

third_party/WebKit/Source/modules/compositorworker/AnimationWorkletMessagingProxy.h

@@ -25,7 +25,7 @@ class AnimationWorkletMessagingProxy final
  private:
   ~AnimationWorkletMessagingProxy() override;
 
-  std::unique_ptr<WorkerThread> CreateWorkerThread(double origin_time) override;
+  std::unique_ptr<WorkerThread> CreateWorkerThread() override;
 };
 
 }  // namespace blink

third_party/WebKit/Source/modules/compositorworker/CompositorWorkerMessagingProxy.cpp

@@ -24,9 +24,9 @@ CompositorWorkerMessagingProxy::CreateBackingThreadStartupData(v8::Isolate*) {
 }
 
 std::unique_ptr<WorkerThread>
-CompositorWorkerMessagingProxy::CreateWorkerThread(double origin_time) {
+CompositorWorkerMessagingProxy::CreateWorkerThread() {
   return CompositorWorkerThread::Create(CreateThreadableLoadingContext(),
-                                        WorkerObjectProxy(), origin_time);
+                                        WorkerObjectProxy());
 }
 
 }  // namespace blink

third_party/WebKit/Source/modules/compositorworker/CompositorWorkerMessagingProxy.h

@@ -19,7 +19,7 @@ class CompositorWorkerMessagingProxy final
   ~CompositorWorkerMessagingProxy() override;
   WTF::Optional<WorkerBackingThreadStartupData> CreateBackingThreadStartupData(
       v8::Isolate*) override;
-  std::unique_ptr<WorkerThread> CreateWorkerThread(double origin_time) override;
+  std::unique_ptr<WorkerThread> CreateWorkerThread() override;
 };
 
 }  // namespace blink

third_party/WebKit/Source/modules/compositorworker/CompositorWorkerThread.cpp

@@ -15,22 +15,19 @@ namespace blink {
 
 std::unique_ptr<CompositorWorkerThread> CompositorWorkerThread::Create(
     ThreadableLoadingContext* loading_context,
-    InProcessWorkerObjectProxy& worker_object_proxy,
-    double time_origin) {
+    InProcessWorkerObjectProxy& worker_object_proxy) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
                "CompositorWorkerThread::create");
   DCHECK(IsMainThread());
-  return WTF::WrapUnique(new CompositorWorkerThread(
-      loading_context, worker_object_proxy, time_origin));
+  return WTF::WrapUnique(
+      new CompositorWorkerThread(loading_context, worker_object_proxy));
 }
 
 CompositorWorkerThread::CompositorWorkerThread(
     ThreadableLoadingContext* loading_context,
-    InProcessWorkerObjectProxy& worker_object_proxy,
-    double time_origin)
+    InProcessWorkerObjectProxy& worker_object_proxy)
     : AbstractAnimationWorkletThread(loading_context, worker_object_proxy),
-      worker_object_proxy_(worker_object_proxy),
-      time_origin_(time_origin) {}
+      worker_object_proxy_(worker_object_proxy) {}
 
 CompositorWorkerThread::~CompositorWorkerThread() {}
 

third_party/WebKit/Source/modules/compositorworker/CompositorWorkerThread.h

@@ -18,8 +18,7 @@ class MODULES_EXPORT CompositorWorkerThread final
  public:
   static std::unique_ptr<CompositorWorkerThread> Create(
       ThreadableLoadingContext*,
-      InProcessWorkerObjectProxy&,
-      double time_origin);
+      InProcessWorkerObjectProxy&);
   ~CompositorWorkerThread() override;
 
   InProcessWorkerObjectProxy& WorkerObjectProxy() const {
@@ -32,11 +31,9 @@ class MODULES_EXPORT CompositorWorkerThread final
 
  private:
   CompositorWorkerThread(ThreadableLoadingContext*,
-                         InProcessWorkerObjectProxy&,
-                         double time_origin);
+                         InProcessWorkerObjectProxy&);
 
   InProcessWorkerObjectProxy& worker_object_proxy_;
-  double time_origin_;
 };
 
 }  // namespace blink

third_party/WebKit/Source/modules/compositorworker/CompositorWorkerThreadTest.cpp

@@ -110,7 +110,7 @@ class CompositorWorkerThreadTest : public ::testing::Test {
 
   std::unique_ptr<CompositorWorkerThread> CreateCompositorWorker() {
     std::unique_ptr<CompositorWorkerThread> worker_thread =
-        CompositorWorkerThread::Create(nullptr, *object_proxy_, 0);
+        CompositorWorkerThread::Create(nullptr, *object_proxy_);
     WorkerClients* clients = WorkerClients::Create();
     ProvideCompositorWorkerProxyClientTo(clients,
                                          new TestCompositorWorkerProxyClient);

third_party/WebKit/Source/modules/serviceworkers/ServiceWorkerGlobalScope.cpp

@@ -71,11 +71,11 @@ namespace blink {
 
 ServiceWorkerGlobalScope* ServiceWorkerGlobalScope::Create(
     ServiceWorkerThread* thread,
-    std::unique_ptr<GlobalScopeCreationParams> creation_params) {
+    std::unique_ptr<GlobalScopeCreationParams> creation_params,
+    double time_origin) {
   ServiceWorkerGlobalScope* context = new ServiceWorkerGlobalScope(
       creation_params->script_url, creation_params->user_agent, thread,
-      MonotonicallyIncreasingTime(),
-      std::move(creation_params->starter_origin_privilege_data),
+      time_origin, std::move(creation_params->starter_origin_privilege_data),
       creation_params->worker_clients);
 
   context->SetV8CacheOptions(creation_params->v8_cache_options);

third_party/WebKit/Source/modules/serviceworkers/ServiceWorkerGlobalScope.h

@@ -59,7 +59,8 @@ class MODULES_EXPORT ServiceWorkerGlobalScope final : public WorkerGlobalScope {
  public:
   static ServiceWorkerGlobalScope* Create(
       ServiceWorkerThread*,
-      std::unique_ptr<GlobalScopeCreationParams>);
+      std::unique_ptr<GlobalScopeCreationParams>,
+      double time_origin);
 
   ~ServiceWorkerGlobalScope() override;
   bool IsServiceWorkerGlobalScope() const override { return true; }

third_party/WebKit/Source/modules/serviceworkers/ServiceWorkerThread.cpp

@@ -57,7 +57,8 @@ void ServiceWorkerThread::ClearWorkerBackingThread() {
 
 WorkerOrWorkletGlobalScope* ServiceWorkerThread::CreateWorkerGlobalScope(
     std::unique_ptr<GlobalScopeCreationParams> creation_params) {
-  return ServiceWorkerGlobalScope::Create(this, std::move(creation_params));
+  return ServiceWorkerGlobalScope::Create(this, std::move(creation_params),
+                                          time_origin_);
 }
 
 InstalledScriptsManager* ServiceWorkerThread::GetInstalledScriptsManager() {

third_party/WebKit/Source/modules/webaudio/AudioWorkletMessagingProxy.cpp

@@ -16,8 +16,7 @@ AudioWorkletMessagingProxy::AudioWorkletMessagingProxy(
 
 AudioWorkletMessagingProxy::~AudioWorkletMessagingProxy() {}
 
-std::unique_ptr<WorkerThread> AudioWorkletMessagingProxy::CreateWorkerThread(
-    double origin_time) {
+std::unique_ptr<WorkerThread> AudioWorkletMessagingProxy::CreateWorkerThread() {
   return AudioWorkletThread::Create(CreateThreadableLoadingContext(),
                                     WorkletObjectProxy());
 }

third_party/WebKit/Source/modules/webaudio/AudioWorkletMessagingProxy.h

@@ -20,7 +20,7 @@ class AudioWorkletMessagingProxy final : public ThreadedWorkletMessagingProxy {
  private:
   ~AudioWorkletMessagingProxy() override;
 
-  std::unique_ptr<WorkerThread> CreateWorkerThread(double origin_time) override;
+  std::unique_ptr<WorkerThread> CreateWorkerThread() override;
 };
 
 }  // namespace blink