XMLHttpRequest.abort(): follow spec wrt readyState transitions.

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 322 matching lines @@
     if (!m_responseDocument)
       return nullptr;
 
     m_responseDocument->setContent(m_responseText.flattenToString());
     if (!m_responseDocument->wellFormed())
       m_responseDocument = nullptr;
 
     m_parsedResponse = true;
   }
 
-  return m_responseDocument.get();
+  return m_responseDocument;
 }
 
 Blob* XMLHttpRequest::responseBlob() {
   DCHECK_EQ(m_responseTypeCode, ResponseTypeBlob);
 
   // We always return null before kDone.
   if (m_error || m_state != kDone)
     return nullptr;
 
   if (!m_responseBlob) {
@@ skipping 39 matching lines @@
         // the spec to tell this to the user.
         CRASH();
       }
       m_responseArrayBuffer = buffer;
       m_binaryResponseBuilder.clear();
     } else {
       m_responseArrayBuffer = DOMArrayBuffer::create(nullptr, 0);
     }
   }
 
-  return m_responseArrayBuffer.get();
+  return m_responseArrayBuffer;
 }
 
 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() && getExecutionContext()->isDocument() &&
@@ skipping 75 matching lines @@
 String XMLHttpRequest::responseURL() {
   KURL responseURL(m_response.url());
   if (!responseURL.isNull())
     responseURL.removeFragmentIdentifier();
   return responseURL.getString();
 }
 
 XMLHttpRequestUpload* XMLHttpRequest::upload() {
   if (!m_upload)
     m_upload = XMLHttpRequestUpload::create(this);
-  return m_upload.get();
+  return m_upload;
 }
 
 void XMLHttpRequest::trackProgress(long long length) {
   m_receivedLength += length;
 
   changeState(kLoading);
   if (m_async) {
     // readyStateChange event is fired as well.
     dispatchProgressEventFromSnapshot(EventTypeNames::progress);
   }
@@ skipping 574 matching lines @@
   // becomes true by that. We should implement more reliable treatment for
   // nested method invocations at some point.
   if (m_async) {
     if ((m_state == kOpened && m_sendFlag) || m_state == kHeadersReceived ||
         m_state == kLoading) {
       DCHECK(!m_loader);
       handleRequestError(0, EventTypeNames::abort, receivedLength,
                          expectedLength);
     }
   }
-  m_state = kUnsent;
+  if (m_state == kDone)
+    m_state = kUnsent;
 }
 
 void XMLHttpRequest::clearVariablesForLoading() {
   if (m_blobLoader) {
     m_blobLoader->cancel();
     m_blobLoader = nullptr;
   }
 
   m_decoder.reset();
 
@@ skipping 26 matching lines @@
   //
   // If, window.onload contains open() and send(), m_loader will be set to
   // non 0 value. So, we cannot continue the outer open(). In such case,
   // just abort the outer open() by returning false.
   ThreadableLoader* loader = m_loader.release();
   loader->cancel();
 
   // If abort() called internalAbort() and a nested open() ended up
   // clearing the error flag, but didn't send(), make sure the error
   // flag is still set.
-  bool newLoadStarted = m_loader.get();
+  bool newLoadStarted = m_loader;
   if (!newLoadStarted)
     m_error = true;
 
   return !newLoadStarted;
 }
 
 void XMLHttpRequest::clearResponse() {
   // FIXME: when we add the support for multi-part XHR, we will have to
   // be careful with this initialization.
   m_receivedLength = 0;
@@ skipping 699 matching lines @@
   visitor->traceWrappers(m_responseDocument);
   visitor->traceWrappers(m_responseArrayBuffer);
   XMLHttpRequestEventTarget::traceWrappers(visitor);
 }
 
 std::ostream& operator<<(std::ostream& ostream, const XMLHttpRequest* xhr) {
   return ostream << "XMLHttpRequest " << static_cast<const void*>(xhr);
 }
 
 }  // namespace blink