Disallow Atomics.wait in ServiceWorker, allow in SharedWorker

Atomics.wait is a blocking call, and is only allowed on certain workers. See
the new web platform tests here:
https://github.com/w3c/web-platform-tests/pull/5569

BUG=chromium:711809

Review-Url: https://codereview.chromium.org/2841003002
Cr-Commit-Position: refs/heads/master@{#468188}

third_party/WebKit/Source/bindings/core/v8/WorkerV8Settings.h

@@ -13,15 +13,20 @@ namespace blink {
 // The V8 settings that are passed from the main isolate to the worker isolate.
 struct CORE_EXPORT WorkerV8Settings {
   enum class HeapLimitMode { kDefault, kIncreasedForDebugging };
+  enum class AtomicsWaitMode { kDisallow, kAllow };
   WorkerV8Settings(HeapLimitMode heap_limit_mode,
-                   V8CacheOptions v8_cache_options)
+                   V8CacheOptions v8_cache_options,
+                   AtomicsWaitMode atomics_wait_mode)
       : heap_limit_mode_(heap_limit_mode),
-        v8_cache_options_(v8_cache_options) {}
+        v8_cache_options_(v8_cache_options),
+        atomics_wait_mode_(atomics_wait_mode) {}
   static WorkerV8Settings Default() {
-    return WorkerV8Settings(HeapLimitMode::kDefault, kV8CacheOptionsDefault);
+    return WorkerV8Settings(HeapLimitMode::kDefault, kV8CacheOptionsDefault,
+                            AtomicsWaitMode::kDisallow);
   }
   HeapLimitMode heap_limit_mode_;
   V8CacheOptions v8_cache_options_;
+  AtomicsWaitMode atomics_wait_mode_;
 };
 
 }  // namespace blink

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

@@ -23,4 +23,8 @@ std::unique_ptr<WorkerThread> DedicatedWorkerMessagingProxy::CreateWorkerThread(
                                        origin_time);
 }
 
+bool DedicatedWorkerMessagingProxy::IsAtomicsWaitAllowed() {
+  return true;
+}
+
 }  // namespace blink

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

@@ -21,6 +21,8 @@ class CORE_EXPORT DedicatedWorkerMessagingProxy final
   ~DedicatedWorkerMessagingProxy() override;
 
   std::unique_ptr<WorkerThread> CreateWorkerThread(double origin_time) override;
+
+  bool IsAtomicsWaitAllowed() override;
 };
 
 }  // namespace blink

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

@@ -118,6 +118,9 @@ class InProcessWorkerMessagingProxyForTest
     CSPHeaderAndType header_and_type("contentSecurityPolicy",
                                      kContentSecurityPolicyHeaderTypeReport);
     headers->push_back(header_and_type);
+    WorkerV8Settings worker_v8_settings = WorkerV8Settings::Default();
+    worker_v8_settings.atomics_wait_mode_ =
+        WorkerV8Settings::AtomicsWaitMode::kAllow;
     GetWorkerThread()->Start(
         WorkerThreadStartupData::Create(
             script_url, "fake user agent", source, nullptr /* cachedMetaData */,
@@ -125,7 +128,7 @@ class InProcessWorkerMessagingProxyForTest
             "" /* referrerPolicy */, security_origin_.Get(),
             nullptr /* workerClients */, kWebAddressSpaceLocal,
             nullptr /* originTrialTokens */, nullptr /* workerSettings */,
-            WorkerV8Settings::Default()),
+            worker_v8_settings),
         GetParentFrameTaskRunners());
 
     GetWorkerInspectorProxy()->WorkerThreadCreated(

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

@@ -107,6 +107,9 @@ void InProcessWorkerMessagingProxy::StartWorkerGlobalScope(
       ToIsolate(document)->IsHeapLimitIncreasedForDebugging()
           ? WorkerV8Settings::HeapLimitMode::kIncreasedForDebugging
           : WorkerV8Settings::HeapLimitMode::kDefault;
+  worker_v8_settings.atomics_wait_mode_ =
+      IsAtomicsWaitAllowed() ? WorkerV8Settings::AtomicsWaitMode::kAllow
+                             : WorkerV8Settings::AtomicsWaitMode::kDisallow;
   std::unique_ptr<WorkerThreadStartupData> startup_data =
       WorkerThreadStartupData::Create(
           script_url, user_agent, source_code, nullptr, start_mode,

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

@@ -87,6 +87,9 @@ class CORE_EXPORT InProcessWorkerMessagingProxy
     return *worker_object_proxy_.get();
   }
 
+  // Whether Atomics.wait (a blocking function call) is allowed on this thread.
+  virtual bool IsAtomicsWaitAllowed() { return false; }
+
  private:
   friend class InProcessWorkerMessagingProxyForTest;
   InProcessWorkerMessagingProxy(ExecutionContext*,

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

@@ -447,6 +447,9 @@ void WorkerThread::InitializeOnWorkerThread(
   bool heap_limit_increased_for_debugging =
       startup_data->worker_v8_settings_.heap_limit_mode_ ==
       WorkerV8Settings::HeapLimitMode::kIncreasedForDebugging;
+  bool allow_atomics_wait =
+      startup_data->worker_v8_settings_.atomics_wait_mode_ ==
+      WorkerV8Settings::AtomicsWaitMode::kAllow;
 
   {
     MutexLocker lock(thread_state_mutex_);
@@ -462,6 +465,8 @@ void WorkerThread::InitializeOnWorkerThread(
       GetIsolate()->IncreaseHeapLimitForDebugging();
     }
 
+    GetIsolate()->SetAllowAtomicsWait(allow_atomics_wait);
+
     console_message_storage_ = new ConsoleMessageStorage();
     global_scope_ = CreateWorkerGlobalScope(std::move(startup_data));
     worker_reporting_proxy_.DidCreateWorkerGlobalScope(GlobalScope());

third_party/WebKit/Source/web/WebSharedWorkerImpl.cpp

@@ -350,6 +350,9 @@ void WebSharedWorkerImpl::OnScriptLoaderFinished() {
       worker_inspector_proxy_->WorkerStartMode(document);
   std::unique_ptr<WorkerSettings> worker_settings =
       WTF::WrapUnique(new WorkerSettings(document->GetSettings()));
+  WorkerV8Settings worker_v8_settings = WorkerV8Settings::Default();
+  worker_v8_settings.atomics_wait_mode_ =
+      WorkerV8Settings::AtomicsWaitMode::kAllow;
   std::unique_ptr<WorkerThreadStartupData> startup_data =
       WorkerThreadStartupData::Create(
           url_, loading_document_->UserAgent(),
@@ -359,7 +362,7 @@ void WebSharedWorkerImpl::OnScriptLoaderFinished() {
           main_script_loader_->GetReferrerPolicy(), starter_origin,
           worker_clients, main_script_loader_->ResponseAddressSpace(),
           main_script_loader_->OriginTrialTokens(), std::move(worker_settings),
-          WorkerV8Settings::Default());
+          worker_v8_settings);
 
   // SharedWorker can sometimes run tasks that are initiated by/associated with
   // a document's frame but these documents can be from a different process. So