Reland of Clear LifecycleObserver::m_context when LifecycleObserver::contextDestroyed gets called

third_party/WebKit/Source/core/xmlhttprequest/XMLHttpRequest.cpp

 /*
  *  Copyright (C) 2004, 2006, 2008 Apple Inc. All rights reserved.
  *  Copyright (C) 2005-2007 Alexey Proskuryakov <ap@webkit.org>
  *  Copyright (C) 2007, 2008 Julien Chaffraix <jchaffraix@webkit.org>
  *  Copyright (C) 2008, 2011 Google Inc. All rights reserved.
  *  Copyright (C) 2012 Intel Corporation
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
@@ skipping 277 matching lines @@
     return m_responseText;
 }
 
 void XMLHttpRequest::initResponseDocument()
 {
     // The W3C spec requires the final MIME type to be some valid XML type, or text/html.
     // If it is text/html, then the responseType of "document" must have been supplied explicitly.
     bool isHTML = responseIsHTML();
     if ((m_response.isHTTP() && !responseIsXML() && !isHTML)
         || (isHTML && m_responseTypeCode == ResponseTypeDefault)
+        || !getExecutionContext()
         || getExecutionContext()->isWorkerGlobalScope()) {
         m_responseDocument = nullptr;
         return;
     }
 
     DocumentInit init = DocumentInit::fromContext(document()->contextDocument(), m_url);
     if (isHTML)
         m_responseDocument = HTMLDocument::create(init);
     else
         m_responseDocument = XMLDocument::create(init);
@@ skipping 95 matching lines @@
     if (m_error || (m_state != kLoading && m_state != kDone))
         return nullptr;
 
     return m_responseLegacyStream;
 }
 
 void XMLHttpRequest::setTimeout(unsigned timeout, ExceptionState& exceptionState)
 {
     // FIXME: Need to trigger or update the timeout Timer here, if needed. http://webkit.org/b/98156
     // XHR2 spec, 4.7.3. "This implies that the timeout attribute can be set while fetching is in progress. If that occurs it will still be measured relative to the start of fetching."
-    if (getExecutionContext()->isDocument() && !m_async) {
+    if (getExecutionContext() && getExecutionContext()->isDocument() && !m_async) {
         exceptionState.throwDOMException(InvalidAccessError, "Timeouts cannot be set for synchronous requests made from a document.");
         return;
     }
 
     m_timeoutMilliseconds = timeout;
 
     // From http://www.w3.org/TR/XMLHttpRequest/#the-timeout-attribute:
     // Note: This implies that the timeout attribute can be set while fetching is in progress. If
     // that occurs it will still be measured relative to the start of fetching.
     //
     // The timeout may be overridden after send.
     if (m_loader)
         m_loader->overrideTimeout(timeout);
 }
 
 void XMLHttpRequest::setResponseType(const String& responseType, ExceptionState& exceptionState)
 {
     if (m_state >= kLoading) {
         exceptionState.throwDOMException(InvalidStateError, "The response type cannot be set if the object's state is LOADING or DONE.");
         return;
     }
 
     // Newer functionality is not available to synchronous requests in window contexts, as a spec-mandated
     // attempt to discourage synchronous XHR use. responseType is one such piece of functionality.
-    if (!m_async && getExecutionContext()->isDocument()) {
+    if (getExecutionContext() && getExecutionContext()->isDocument() && !m_async) {
         exceptionState.throwDOMException(InvalidAccessError, "The response type cannot be changed for synchronous requests made from a document.");
         return;
     }
 
     if (responseType == "") {
         m_responseTypeCode = ResponseTypeDefault;
     } else if (responseType == "text") {
         m_responseTypeCode = ResponseTypeText;
     } else if (responseType == "json") {
         m_responseTypeCode = ResponseTypeJSON;
@@ skipping 100 matching lines @@
     if (m_state > kOpened || m_loader) {
         exceptionState.throwDOMException(InvalidStateError,  "The value may only be set if the object's state is UNSENT or OPENED.");
         return;
     }
 
     m_includeCredentials = value;
 }
 
 void XMLHttpRequest::open(const AtomicString& method, const String& urlString, ExceptionState& exceptionState)
 {
+    if (!getExecutionContext())
+        return;
+
     KURL url(getExecutionContext()->completeURL(urlString));
     if (!validateOpenArguments(method, url, exceptionState))
         return;
 
     open(method, url, true, exceptionState);
 }
 
 void XMLHttpRequest::open(const AtomicString& method, const String& urlString, bool async, const String& username, const String& password, ExceptionState& exceptionState)
 {
+    if (!getExecutionContext())
+        return;
+
     KURL url(getExecutionContext()->completeURL(urlString));
     if (!validateOpenArguments(method, url, exceptionState))
         return;
 
     if (!username.isNull())
         url.setUser(username);
     if (!password.isNull())
         url.setPass(password);
 
     open(method, url, async, exceptionState);
@@ skipping 57 matching lines @@
     // Check previous state to avoid dispatching readyState event
     // when calling open several times in a row.
     if (previousState != kOpened)
         changeState(kOpened);
     else
         m_state = kOpened;
 }
 
 bool XMLHttpRequest::initSend(ExceptionState& exceptionState)
 {
-    if (!getExecutionContext())
+    if (!getExecutionContext()) {
+        handleNetworkError();
+        throwForLoadFailureIfNeeded(exceptionState, "Document is already detached.");
         return false;
+    }
 
     if (m_state != kOpened || m_loader) {
         exceptionState.throwDOMException(InvalidStateError, "The object's state must be OPENED.");
         return false;
     }
 
     if (!m_async) {
         v8::Isolate* isolate = v8::Isolate::GetCurrent();
         if (isolate && v8::MicrotasksScope::IsRunningMicrotasks(isolate)) {
             UseCounter::count(getExecutionContext(), UseCounter::During_Microtask_SyncXHR);
@@ skipping 212 matching lines @@
     if (m_url.protocolIs("blob") && m_method != HTTPNames::GET) {
         handleNetworkError();
 
         if (!m_async) {
             throwForLoadFailureIfNeeded(exceptionState, "'GET' is the only method allowed for 'blob:' URLs.");
         }
         return;
     }
 
     DCHECK(getExecutionContext());
-    ExecutionContext& executionContext = *this->getExecutionContext();
+    ExecutionContext& executionContext = *getExecutionContext();
 
     // The presence of upload event listeners forces us to use preflighting because POSTing to an URL that does not
     // permit cross origin requests should look exactly like POSTing to an URL that does not respond at all.
     // Also, only async requests support upload progress events.
     bool uploadEvents = false;
     if (m_async) {
         InspectorInstrumentation::asyncTaskScheduled(&executionContext, "XMLHttpRequest.send", this, true);
         dispatchProgressEvent(EventTypeNames::loadstart, 0, 0);
         if (httpBody && m_upload) {
             uploadEvents = m_upload->hasEventListeners();
@@ skipping 607 matching lines @@
         // Set |m_error| in order to suppress the cancel notification (see
         // XMLHttpRequest::didFail).
         m_error = true;
         m_loader->cancel();
         m_error = hasError;
         m_loader = nullptr;
     }
 
     changeState(kDone);
 
-    if (!getExecutionContext()->isDocument() || !document() || !document()->frame() || !document()->frame()->page())
+    if (!getExecutionContext() || !getExecutionContext()->isDocument() || !document() || !document()->frame() || !document()->frame()->page())
         return;
 
     if (status() >= 200 && status() < 300) {
         document()->frame()->page()->chromeClient().ajaxSucceeded(document()->frame());
     }
 }
 
 void XMLHttpRequest::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
 {
     NETWORK_DVLOG(1) << this << " didSendData(" << bytesSent << ", " << totalBytesToBeSent << ")";
@@ skipping 227 matching lines @@
     visitor->traceWrappers(m_responseDocument);
     visitor->traceWrappers(m_responseArrayBuffer);
 }
 
 std::ostream& operator<<(std::ostream& ostream, const XMLHttpRequest* xhr)
 {
     return ostream << "XMLHttpRequest " << static_cast<const void*>(xhr);
 }
 
 } // namespace blink