Use nullptr instead of 0 in xml and xmlhttprequest.

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 418 matching lines @@
     // FIXME: Set Last-Modified.
     m_responseDocument->setSecurityOrigin(securityOrigin());
     m_responseDocument->setContextFeatures(document()->contextFeatures());
     m_responseDocument->setMimeType(finalResponseMIMETypeWithFallback());
 }
 
 Document* XMLHttpRequest::responseXML(ExceptionState& exceptionState)
 {
     if (m_responseTypeCode != ResponseTypeDefault && m_responseTypeCode != ResponseTypeDocument) {
         exceptionState.throwDOMException(InvalidStateError, "The value is only accessible if the object's 'responseType' is '' or 'document' (was '" + responseType() + "').");
-        return 0;
+        return nullptr;
     }
 
     if (m_error || m_state != DONE)
-        return 0;
+        return nullptr;
 
     if (!m_parsedResponse) {
         initResponseDocument();
         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();
 }
 
 Blob* XMLHttpRequest::responseBlob()
 {
     ASSERT(m_responseTypeCode == ResponseTypeBlob);
 
     // We always return null before DONE.
     if (m_error || m_state != DONE)
-        return 0;
+        return nullptr;
 
     if (!m_responseBlob) {
         if (m_downloadingToFile) {
             ASSERT(!m_binaryResponseBuilder);
 
             // When responseType is set to "blob", we redirect the downloaded
             // data to a file-handle directly in the browser process. We get
             // the file-path from the ResourceResponse directly instead of
             // copying the bytes between the browser and the renderer.
             m_responseBlob = Blob::create(createBlobDataHandleFromResponse());
         } else {
             OwnPtr<BlobData> blobData = BlobData::create();
             size_t size = 0;
             if (m_binaryResponseBuilder && m_binaryResponseBuilder->size()) {
                 size = m_binaryResponseBuilder->size();
                 blobData->appendBytes(m_binaryResponseBuilder->data(), size);
                 blobData->setContentType(finalResponseMIMETypeWithFallback().lower());
                 m_binaryResponseBuilder.clear();
             }
             m_responseBlob = Blob::create(BlobDataHandle::create(blobData.release(), size));
         }
     }
 
-    return m_responseBlob.get();
+    return m_responseBlob;
 }
 
 DOMArrayBuffer* XMLHttpRequest::responseArrayBuffer()
 {
     ASSERT(m_responseTypeCode == ResponseTypeArrayBuffer);
 
     if (m_error || m_state != DONE)
-        return 0;
+        return nullptr;
 
     if (!m_responseArrayBuffer) {
         if (m_binaryResponseBuilder && m_binaryResponseBuilder->size()) {
             RefPtr<DOMArrayBuffer> buffer = DOMArrayBuffer::createUninitialized(m_binaryResponseBuilder->size(), 1);
             if (!m_binaryResponseBuilder->getAsBytes(buffer->data(), buffer->byteLength())) {
                 // m_binaryResponseBuilder failed to allocate an ArrayBuffer.
                 // We need to crash the renderer since there's no way defined in
                 // the spec to tell this to the user.
                 CRASH();
             }
             m_responseArrayBuffer = buffer.release();
             m_binaryResponseBuilder.clear();
         } else {
             m_responseArrayBuffer = DOMArrayBuffer::create(nullptr, 0);
         }
     }
 
     return m_responseArrayBuffer.get();
 }
 
 Stream* XMLHttpRequest::responseLegacyStream()
 {
     ASSERT(m_responseTypeCode == ResponseTypeLegacyStream);
 
     if (m_error || (m_state != LOADING && m_state != DONE))
-        return 0;
+        return nullptr;
 
-    return m_responseLegacyStream.get();
+    return m_responseLegacyStream;
 }
 
 ReadableStream* XMLHttpRequest::responseStream()
 {
     ASSERT(m_responseTypeCode == ResponseTypeStream);
     if (m_error || (m_state != LOADING && m_state != DONE))
-        return 0;
+        return nullptr;
 
     return m_responseStream;
 }
 
 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 (executionContext()->isDocument() && !m_async) {
         exceptionState.throwDOMException(InvalidAccessError, "Timeouts cannot be set for synchronous requests made from a document.");
@@ skipping 1320 matching lines @@
     visitor->trace(m_responseDocumentParser);
     visitor->trace(m_progressEventThrottle);
     visitor->trace(m_upload);
     visitor->trace(m_blobLoader);
     XMLHttpRequestEventTarget::trace(visitor);
     DocumentParserClient::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink