Add WorkerSettings to expose certain flag values in WorkerGlobalScope

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

 /*
  * Copyright (C) 2008, 2009 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 22 matching lines @@
 #include "core/dom/ExecutionContext.h"
 #include "core/events/EventListener.h"
 #include "core/events/EventTarget.h"
 #include "core/fetch/CachedMetadataHandler.h"
 #include "core/frame/DOMTimerCoordinator.h"
 #include "core/frame/DOMWindowBase64.h"
 #include "core/frame/UseCounter.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/workers/WorkerEventQueue.h"
 #include "core/workers/WorkerOrWorkletGlobalScope.h"
+#include "core/workers/WorkerSettings.h"
 #include "platform/heap/Handle.h"
 #include "wtf/ListHashSet.h"
 #include <memory>
 
 namespace blink {
 
 class ConsoleMessage;
 class ConsoleMessageStorage;
 class ExceptionState;
 class V8AbstractEventListener;
@@ skipping 68 matching lines @@
 
     // Returns true when the WorkerGlobalScope is closing (e.g. via close()
     // method). If this returns true, the worker is going to be shutdown after
     // the current task execution. Workers that don't support close operation
     // should always return false.
     bool isClosing() const { return m_closing; }
 
     const KURL& url() const { return m_url; }
     WorkerThread* thread() const { return m_thread; }
     double timeOrigin() const { return m_timeOrigin; }
+    WorkerSettings* workerSettings() const { return m_workerSettings.get(); }
 
     WorkerOrWorkletScriptController* scriptController() final { return m_scriptController.get(); }
     WorkerInspectorController* workerInspectorController() { return m_workerInspectorController.get(); }
     WorkerClients* clients() { return m_workerClients.get(); }
     ConsoleMessageStorage* consoleMessageStorage() { return m_consoleMessageStorage.get(); }
 
     DECLARE_VIRTUAL_TRACE();
 
 protected:
     WorkerGlobalScope(const KURL&, const String& userAgent, WorkerThread*, double timeOrigin, std::unique_ptr<SecurityOrigin::PrivilegeData>, WorkerClients*);
+    void setWorkerSettings(std::unique_ptr<WorkerSettings>);
     void applyContentSecurityPolicyFromVector(const Vector<CSPHeaderAndType>& headers);
 
     void addMessageToWorkerConsole(ConsoleMessage*);
     void setV8CacheOptions(V8CacheOptions v8CacheOptions) { m_v8CacheOptions = v8CacheOptions; }
 
     // ExecutionContext
     void exceptionThrown(const String& errorMessage, std::unique_ptr<SourceLocation>) override;
     void removeURLFromMemoryCache(const KURL&) final;
 
 private:
     // ExecutionContext
     EventTarget* errorEventTarget() final { return this; }
     const KURL& virtualURL() const final { return m_url; }
     KURL virtualCompleteURL(const String&) const final;
 
     // SecurityContext
     void didUpdateSecurityOrigin() final {}
 
     void clearScript();
     void clearInspector();
 
     const KURL m_url;
     const String m_userAgent;
     V8CacheOptions m_v8CacheOptions;
+    std::unique_ptr<WorkerSettings> m_workerSettings;
 
     mutable Member<WorkerLocation> m_location;
     mutable Member<WorkerNavigator> m_navigator;
 
     mutable UseCounter::CountBits m_deprecationWarningBits;
 
     Member<WorkerOrWorkletScriptController> m_scriptController;
     WorkerThread* m_thread;
 
     Member<WorkerInspectorController> m_workerInspectorController;
@@ skipping 10 matching lines @@
     Member<ConsoleMessageStorage> m_consoleMessageStorage;
 
     HeapListHashSet<Member<V8AbstractEventListener>> m_eventListeners;
 };
 
 DEFINE_TYPE_CASTS(WorkerGlobalScope, ExecutionContext, context, context->isWorkerGlobalScope(), context.isWorkerGlobalScope());
 
 } // namespace blink
 
 #endif // WorkerGlobalScope_h