Source/WebCore/bindings/js/JSDOMWindowBase.cpp

   1 /*
   2  *  Copyright (C) 2000 Harri Porten (porten@kde.org)
   3  *  Copyright (C) 2006 Jon Shier (jshier@iastate.edu)
   4  *  Copyright (C) 2003-2017 Apple Inc. All rights reseved.
   5  *  Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
   6  *  Copyright (c) 2015 Canon Inc. All rights reserved.
   7  *
   8  *  This library is free software; you can redistribute it and/or
   9  *  modify it under the terms of the GNU Lesser General Public
  10  *  License as published by the Free Software Foundation; either
  11  *  version 2 of the License, or (at your option) any later version.
  12  *
  13  *  This library is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *  Lesser General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU Lesser General Public
  19  *  License along with this library; if not, write to the Free Software
  20  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
  21  *  USA
  22  */
  23
  24 #include "config.h"
  25 #include "JSDOMWindowBase.h"
  26
  27 #include "ActiveDOMCallbackMicrotask.h"
  28 #include "Chrome.h"
  29 #include "CommonVM.h"
  30 #include "DOMWindow.h"
  31 #include "Document.h"
  32 #include "Frame.h"
  33 #include "InspectorController.h"
  34 #include "JSDOMBindingSecurity.h"
  35 #include "JSDOMGlobalObjectTask.h"
  36 #include "JSDOMWindowCustom.h"
  37 #include "JSMainThreadExecState.h"
  38 #include "JSNode.h"
  39 #include "Logging.h"
  40 #include "Page.h"
  41 #include "RejectedPromiseTracker.h"
  42 #include "RuntimeApplicationChecks.h"
  43 #include "ScriptController.h"
  44 #include "ScriptModuleLoader.h"
  45 #include "SecurityOrigin.h"
  46 #include "Settings.h"
  47 #include "WebCoreJSClientData.h"
  48 #include <JavaScriptCore/CodeBlock.h>
  49 #include <JavaScriptCore/JSInternalPromise.h>
  50 #include <JavaScriptCore/JSInternalPromiseDeferred.h>
  51 #include <JavaScriptCore/Microtask.h>
  52 #include <JavaScriptCore/StrongInlines.h>
  53 #include <wtf/Language.h>
  54 #include <wtf/MainThread.h>
  55
  56 #if PLATFORM(IOS)
  57 #include "ChromeClient.h"
  58 #endif
  59
  60
  61 namespace WebCore {
  62 using namespace JSC;
  63
  64 const ClassInfo JSDOMWindowBase::s_info = { "Window", &JSDOMGlobalObject::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSDOMWindowBase) };
  65
  66 const GlobalObjectMethodTable JSDOMWindowBase::s_globalObjectMethodTable = {
  67     &supportsRichSourceInfo,
  68     &shouldInterruptScript,
  69     &javaScriptRuntimeFlags,
  70     &queueTaskToEventLoop,
  71     &shouldInterruptScriptBeforeTimeout,
  72     &moduleLoaderImportModule,
  73     &moduleLoaderResolve,
  74     &moduleLoaderFetch,
  75     &moduleLoaderCreateImportMetaProperties,
  76     &moduleLoaderEvaluate,
  77     &promiseRejectionTracker,
  78     &defaultLanguage
  79 };
  80
  81 JSDOMWindowBase::JSDOMWindowBase(VM& vm, Structure* structure, RefPtr<DOMWindow>&& window, JSDOMWindowProxy* proxy)
  82     : JSDOMGlobalObject(vm, structure, proxy->world(), &s_globalObjectMethodTable)
  83     , m_windowCloseWatchpoints((window && window->frame()) ? IsWatched : IsInvalidated)
  84     , m_wrapped(WTFMove(window))
  85     , m_proxy(proxy)
  86 {
  87 }
  88
  89 void JSDOMWindowBase::finishCreation(VM& vm, JSDOMWindowProxy* proxy)
  90 {
  91     Base::finishCreation(vm, proxy);
  92     ASSERT(inherits(vm, info()));
  93
  94     auto& builtinNames = static_cast<JSVMClientData*>(vm.clientData)->builtinNames();
  95
  96     GlobalPropertyInfo staticGlobals[] = {
  97         GlobalPropertyInfo(builtinNames.documentPublicName(), jsNull(), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly),
  98         GlobalPropertyInfo(builtinNames.windowPublicName(), m_proxy, PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly),
  99     };
 100
 101     addStaticGlobals(staticGlobals, WTF_ARRAY_LENGTH(staticGlobals));
 102
 103     if (m_wrapped && m_wrapped->frame() && m_wrapped->frame()->settings().needsSiteSpecificQuirks())
 104         setNeedsSiteSpecificQuirks(true);
 105 }
 106
 107 void JSDOMWindowBase::destroy(JSCell* cell)
 108 {
 109     static_cast<JSDOMWindowBase*>(cell)->JSDOMWindowBase::~JSDOMWindowBase();
 110 }
 111
 112 void JSDOMWindowBase::updateDocument()
 113 {
 114     // Since "document" property is defined as { configurable: false, writable: false, enumerable: true },
 115     // users cannot change its attributes further.
 116     // Reaching here, the attributes of "document" property should be never changed.
 117     ASSERT(m_wrapped->document());
 118     ExecState* exec = globalExec();
 119     bool shouldThrowReadOnlyError = false;
 120     bool ignoreReadOnlyErrors = true;
 121     bool putResult = false;
 122     symbolTablePutTouchWatchpointSet(this, exec, static_cast<JSVMClientData*>(exec->vm().clientData)->builtinNames().documentPublicName(), toJS(exec, this, m_wrapped->document()), shouldThrowReadOnlyError, ignoreReadOnlyErrors, putResult);
 123 }
 124
 125 ScriptExecutionContext* JSDOMWindowBase::scriptExecutionContext() const
 126 {
 127     return m_wrapped->document();
 128 }
 129
 130 void JSDOMWindowBase::printErrorMessage(const String& message) const
 131 {
 132     printErrorMessageForFrame(wrapped().frame(), message);
 133 }
 134
 135 bool JSDOMWindowBase::supportsRichSourceInfo(const JSGlobalObject* object)
 136 {
 137     const JSDOMWindowBase* thisObject = static_cast<const JSDOMWindowBase*>(object);
 138     Frame* frame = thisObject->wrapped().frame();
 139     if (!frame)
 140         return false;
 141
 142     Page* page = frame->page();
 143     if (!page)
 144         return false;
 145
 146     bool enabled = page->inspectorController().enabled();
 147     ASSERT(enabled || !thisObject->debugger());
 148     return enabled;
 149 }
 150
 151 static inline bool shouldInterruptScriptToPreventInfiniteRecursionWhenClosingPage(Page* page)
 152 {
 153     // See <rdar://problem/5479443>. We don't think that page can ever be NULL
 154     // in this case, but if it is, we've gotten into a state where we may have
 155     // hung the UI, with no way to ask the client whether to cancel execution.
 156     // For now, our solution is just to cancel execution no matter what,
 157     // ensuring that we never hang. We might want to consider other solutions
 158     // if we discover problems with this one.
 159     ASSERT(page);
 160     return !page;
 161 }
 162
 163 bool JSDOMWindowBase::shouldInterruptScript(const JSGlobalObject* object)
 164 {
 165     const JSDOMWindowBase* thisObject = static_cast<const JSDOMWindowBase*>(object);
 166     ASSERT(thisObject->wrapped().frame());
 167     Page* page = thisObject->wrapped().frame()->page();
 168     return shouldInterruptScriptToPreventInfiniteRecursionWhenClosingPage(page);
 169 }
 170
 171 bool JSDOMWindowBase::shouldInterruptScriptBeforeTimeout(const JSGlobalObject* object)
 172 {
 173     const JSDOMWindowBase* thisObject = static_cast<const JSDOMWindowBase*>(object);
 174     ASSERT(thisObject->wrapped().frame());
 175     Page* page = thisObject->wrapped().frame()->page();
 176
 177     if (shouldInterruptScriptToPreventInfiniteRecursionWhenClosingPage(page))
 178         return true;
 179
 180 #if PLATFORM(IOS)
 181     if (page->chrome().client().isStopping())
 182         return true;
 183 #endif
 184
 185     return JSGlobalObject::shouldInterruptScriptBeforeTimeout(object);
 186 }
 187
 188 RuntimeFlags JSDOMWindowBase::javaScriptRuntimeFlags(const JSGlobalObject* object)
 189 {
 190     const JSDOMWindowBase* thisObject = static_cast<const JSDOMWindowBase*>(object);
 191     Frame* frame = thisObject->wrapped().frame();
 192     if (!frame)
 193         return RuntimeFlags();
 194     return frame->settings().javaScriptRuntimeFlags();
 195 }
 196
 197 class JSDOMWindowMicrotaskCallback : public RefCounted<JSDOMWindowMicrotaskCallback> {
 198 public:
 199     static Ref<JSDOMWindowMicrotaskCallback> create(JSDOMWindowBase& globalObject, Ref<JSC::Microtask>&& task)
 200     {
 201         return adoptRef(*new JSDOMWindowMicrotaskCallback(globalObject, WTFMove(task)));
 202     }
 203
 204     void call()
 205     {
 206         Ref<JSDOMWindowMicrotaskCallback> protectedThis(*this);
 207         VM& vm = m_globalObject->vm();
 208         JSLockHolder lock(vm);
 209         auto scope = DECLARE_THROW_SCOPE(vm);
 210
 211         ExecState* exec = m_globalObject->globalExec();
 212
 213         JSMainThreadExecState::runTask(exec, m_task);
 214
 215         scope.assertNoException();
 216     }
 217
 218 private:
 219     JSDOMWindowMicrotaskCallback(JSDOMWindowBase& globalObject, Ref<JSC::Microtask>&& task)
 220         : m_globalObject { globalObject.vm(), &globalObject }
 221         , m_task { WTFMove(task) }
 222     {
 223     }
 224
 225     Strong<JSDOMWindowBase> m_globalObject;
 226     Ref<JSC::Microtask> m_task;
 227 };
 228
 229 void JSDOMWindowBase::queueTaskToEventLoop(JSGlobalObject& object, Ref<JSC::Microtask>&& task)
 230 {
 231     JSDOMWindowBase& thisObject = static_cast<JSDOMWindowBase&>(object);
 232
 233     RefPtr<JSDOMWindowMicrotaskCallback> callback = JSDOMWindowMicrotaskCallback::create(thisObject, WTFMove(task));
 234     auto microtask = std::make_unique<ActiveDOMCallbackMicrotask>(MicrotaskQueue::mainThreadQueue(), *thisObject.scriptExecutionContext(), [callback]() mutable {
 235         callback->call();
 236     });
 237
 238     MicrotaskQueue::mainThreadQueue().append(WTFMove(microtask));
 239 }
 240
 241 void JSDOMWindowBase::willRemoveFromWindowProxy()
 242 {
 243     setCurrentEvent(0);
 244 }
 245
 246 JSDOMWindowProxy* JSDOMWindowBase::proxy() const
 247 {
 248     return m_proxy;
 249 }
 250
 251 // JSDOMGlobalObject* is ignored, accessing a window in any context will
 252 // use that DOMWindow's prototype chain.
 253 JSValue toJS(ExecState* state, JSDOMGlobalObject*, DOMWindow& domWindow)
 254 {
 255     return toJS(state, domWindow);
 256 }
 257
 258 JSValue toJS(JSC::ExecState* state, JSDOMGlobalObject*, Frame& frame)
 259 {
 260     return toJS(state, frame);
 261 }
 262
 263 JSValue toJS(ExecState* state, DOMWindow& domWindow)
 264 {
 265     return toJS(state, domWindow.frame());
 266 }
 267
 268 JSDOMWindow* toJSDOMWindow(Frame& frame, DOMWrapperWorld& world)
 269 {
 270     return frame.script().windowProxy(world)->window();
 271 }
 272
 273 JSDOMWindow* toJSDOMWindow(JSC::VM& vm, JSValue value)
 274 {
 275     if (!value.isObject())
 276         return nullptr;
 277
 278     while (!value.isNull()) {
 279         JSObject* object = asObject(value);
 280         const ClassInfo* classInfo = object->classInfo(vm);
 281         if (classInfo == JSDOMWindow::info())
 282             return jsCast<JSDOMWindow*>(object);
 283         if (classInfo == JSDOMWindowProxy::info())
 284             return jsCast<JSDOMWindowProxy*>(object)->window();
 285         value = object->getPrototypeDirect(vm);
 286     }
 287     return nullptr;
 288 }
 289
 290 DOMWindow& incumbentDOMWindow(ExecState& state)
 291 {
 292     return asJSDOMWindow(&callerGlobalObject(state))->wrapped();
 293 }
 294
 295 DOMWindow& activeDOMWindow(ExecState& state)
 296 {
 297     return asJSDOMWindow(state.lexicalGlobalObject())->wrapped();
 298 }
 299
 300 DOMWindow& firstDOMWindow(ExecState& state)
 301 {
 302     return asJSDOMWindow(state.vmEntryGlobalObject())->wrapped();
 303 }
 304
 305 Document* responsibleDocument(ExecState& state)
 306 {
 307     CallerFunctor functor;
 308     state.iterate(functor);
 309     auto* callerFrame = functor.callerFrame();
 310     if (!callerFrame)
 311         return nullptr;
 312     return asJSDOMWindow(callerFrame->lexicalGlobalObject())->wrapped().document();
 313 }
 314
 315 void JSDOMWindowBase::fireFrameClearedWatchpointsForWindow(DOMWindow* window)
 316 {
 317     JSC::VM& vm = commonVM();
 318     JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData);
 319     Vector<Ref<DOMWrapperWorld>> wrapperWorlds;
 320     clientData->getAllWorlds(wrapperWorlds);
 321     for (unsigned i = 0; i < wrapperWorlds.size(); ++i) {
 322         auto& wrappers = wrapperWorlds[i]->wrappers();
 323         auto result = wrappers.find(window);
 324         if (result == wrappers.end())
 325             continue;
 326         JSC::JSObject* wrapper = result->value.get();
 327         if (!wrapper)
 328             continue;
 329         JSDOMWindowBase* jsWindow = JSC::jsCast<JSDOMWindowBase*>(wrapper);
 330         jsWindow->m_windowCloseWatchpoints.fireAll(vm, "Frame cleared");
 331     }
 332 }
 333
 334 JSC::Identifier JSDOMWindowBase::moduleLoaderResolve(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSModuleLoader* moduleLoader, JSC::JSValue moduleName, JSC::JSValue importerModuleKey, JSC::JSValue scriptFetcher)
 335 {
 336     JSDOMWindowBase* thisObject = JSC::jsCast<JSDOMWindowBase*>(globalObject);
 337     if (RefPtr<Document> document = thisObject->wrapped().document())
 338         return document->moduleLoader()->resolve(globalObject, exec, moduleLoader, moduleName, importerModuleKey, scriptFetcher);
 339     return { };
 340 }
 341
 342 JSC::JSInternalPromise* JSDOMWindowBase::moduleLoaderFetch(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSModuleLoader* moduleLoader, JSC::JSValue moduleKey, JSC::JSValue parameters, JSC::JSValue scriptFetcher)
 343 {
 344     JSDOMWindowBase* thisObject = JSC::jsCast<JSDOMWindowBase*>(globalObject);
 345     if (RefPtr<Document> document = thisObject->wrapped().document())
 346         return document->moduleLoader()->fetch(globalObject, exec, moduleLoader, moduleKey, parameters, scriptFetcher);
 347     JSC::JSInternalPromiseDeferred* deferred = JSC::JSInternalPromiseDeferred::create(exec, globalObject);
 348     return deferred->reject(exec, jsUndefined());
 349 }
 350
 351 JSC::JSValue JSDOMWindowBase::moduleLoaderEvaluate(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSModuleLoader* moduleLoader, JSC::JSValue moduleKey, JSC::JSValue moduleRecord, JSC::JSValue scriptFetcher)
 352 {
 353     JSDOMWindowBase* thisObject = JSC::jsCast<JSDOMWindowBase*>(globalObject);
 354     if (RefPtr<Document> document = thisObject->wrapped().document())
 355         return document->moduleLoader()->evaluate(globalObject, exec, moduleLoader, moduleKey, moduleRecord, scriptFetcher);
 356     return JSC::jsUndefined();
 357 }
 358
 359 JSC::JSInternalPromise* JSDOMWindowBase::moduleLoaderImportModule(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSModuleLoader* moduleLoader, JSC::JSString* moduleName, JSC::JSValue parameters, const JSC::SourceOrigin& sourceOrigin)
 360 {
 361     JSDOMWindowBase* thisObject = JSC::jsCast<JSDOMWindowBase*>(globalObject);
 362     if (RefPtr<Document> document = thisObject->wrapped().document())
 363         return document->moduleLoader()->importModule(globalObject, exec, moduleLoader, moduleName, parameters, sourceOrigin);
 364     JSC::JSInternalPromiseDeferred* deferred = JSC::JSInternalPromiseDeferred::create(exec, globalObject);
 365     return deferred->reject(exec, jsUndefined());
 366 }
 367
 368 JSC::JSObject* JSDOMWindowBase::moduleLoaderCreateImportMetaProperties(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSModuleLoader* moduleLoader, JSC::JSValue moduleKey, JSC::JSModuleRecord* moduleRecord, JSC::JSValue scriptFetcher)
 369 {
 370     JSDOMWindowBase* thisObject = JSC::jsCast<JSDOMWindowBase*>(globalObject);
 371     if (RefPtr<Document> document = thisObject->wrapped().document())
 372         return document->moduleLoader()->createImportMetaProperties(globalObject, exec, moduleLoader, moduleKey, moduleRecord, scriptFetcher);
 373     return constructEmptyObject(exec, globalObject->nullPrototypeObjectStructure());
 374 }
 375
 376 void JSDOMWindowBase::promiseRejectionTracker(JSGlobalObject* jsGlobalObject, ExecState* exec, JSPromise* promise, JSPromiseRejectionOperation operation)
 377 {
 378     // https://html.spec.whatwg.org/multipage/webappapis.html#the-hostpromiserejectiontracker-implementation
 379
 380     VM& vm = exec->vm();
 381     auto& globalObject = *JSC::jsCast<JSDOMWindowBase*>(jsGlobalObject);
 382     auto* context = globalObject.scriptExecutionContext();
 383     if (!context)
 384         return;
 385
 386     // InternalPromises should not be exposed to user scripts.
 387     if (JSC::jsDynamicCast<JSC::JSInternalPromise*>(vm, promise))
 388         return;
 389
 390     // FIXME: If script has muted errors (cross origin), terminate these steps.
 391     // <https://webkit.org/b/171415> Implement the `muted-errors` property of Scripts to avoid onerror/onunhandledrejection for cross-origin scripts
 392
 393     switch (operation) {
 394     case JSPromiseRejectionOperation::Reject:
 395         context->ensureRejectedPromiseTracker().promiseRejected(*exec, globalObject, *promise);
 396         break;
 397     case JSPromiseRejectionOperation::Handle:
 398         context->ensureRejectedPromiseTracker().promiseHandled(*exec, globalObject, *promise);
 399         break;
 400     }
 401 }
 402
 403 } // namespace WebCore