Remove "legacy" experimental stream support

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 43 matching lines @@
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/html/FormData.h"
 #include "core/html/HTMLDocument.h"
 #include "core/html/parser/TextResourceDecoder.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "core/loader/ThreadableLoader.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
-#include "core/streams/Stream.h"
 #include "core/xmlhttprequest/XMLHttpRequestUpload.h"
 #include "platform/FileMetadata.h"
 #include "platform/HTTPNames.h"
 #include "platform/Histogram.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/SharedBuffer.h"
 #include "platform/blob/BlobData.h"
 #include "platform/network/HTTPParsers.h"
 #include "platform/network/NetworkLog.h"
 #include "platform/network/ParsedContentType.h"
@@ skipping 146 matching lines @@
   return xmlHttpRequest;
 }
 
 XMLHttpRequest::XMLHttpRequest(
     ExecutionContext* context,
     PassRefPtr<SecurityOrigin> isolatedWorldSecurityOrigin)
     : ActiveScriptWrappable(this),
       ActiveDOMObject(context),
       m_timeoutMilliseconds(0),
       m_responseBlob(this, nullptr),
-      m_responseLegacyStream(this, nullptr),
       m_state(kUnsent),
       m_responseDocument(this, nullptr),
       m_lengthDownloadedToFile(0),
       m_responseArrayBuffer(this, nullptr),
       m_receivedLength(0),
       m_exceptionCode(0),
       m_progressEventThrottle(
           XMLHttpRequestProgressEventThrottle::create(this)),
       m_responseTypeCode(ResponseTypeDefault),
       m_isolatedWorldSecurityOrigin(isolatedWorldSecurityOrigin),
@@ skipping 155 matching lines @@
       m_responseArrayBuffer = buffer;
       m_binaryResponseBuilder.clear();
     } else {
       m_responseArrayBuffer = DOMArrayBuffer::create(nullptr, 0);
     }
   }
 
   return m_responseArrayBuffer.get();
 }
 
-Stream* XMLHttpRequest::responseLegacyStream() {
-  DCHECK_EQ(m_responseTypeCode, ResponseTypeLegacyStream);
-
-  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() && getExecutionContext()->isDocument() &&
       !m_async) {
     exceptionState.throwDOMException(InvalidAccessError,
@@ skipping 40 matching lines @@
   } else if (responseType == "text") {
     m_responseTypeCode = ResponseTypeText;
   } else if (responseType == "json") {
     m_responseTypeCode = ResponseTypeJSON;
   } else if (responseType == "document") {
     m_responseTypeCode = ResponseTypeDocument;
   } else if (responseType == "blob") {
     m_responseTypeCode = ResponseTypeBlob;
   } else if (responseType == "arraybuffer") {
     m_responseTypeCode = ResponseTypeArrayBuffer;
-  } else if (responseType == "legacystream") {
-    if (RuntimeEnabledFeatures::experimentalStreamEnabled())
-      m_responseTypeCode = ResponseTypeLegacyStream;
-    else
-      return;
   } else {
     NOTREACHED();
   }
 }
 
 String XMLHttpRequest::responseType() {
   switch (m_responseTypeCode) {
     case ResponseTypeDefault:
       return "";
     case ResponseTypeText:
       return "text";
     case ResponseTypeJSON:
       return "json";
     case ResponseTypeDocument:
       return "document";
     case ResponseTypeBlob:
       return "blob";
     case ResponseTypeArrayBuffer:
       return "arraybuffer";
-    case ResponseTypeLegacyStream:
-      return "legacystream";
   }
   return "";
 }
 
 String XMLHttpRequest::responseURL() {
   KURL responseURL(m_response.url());
   if (!responseURL.isNull())
     responseURL.removeFragmentIdentifier();
   return responseURL.getString();
 }
@@ skipping 610 matching lines @@
 }
 
 bool XMLHttpRequest::internalAbort() {
   m_error = true;
 
   if (m_responseDocumentParser && !m_responseDocumentParser->isStopped())
     m_responseDocumentParser->stopParsing();
 
   clearVariablesForLoading();
 
-  if (m_responseLegacyStream && m_state != kDone)
-    m_responseLegacyStream->abort();
-
   clearResponse();
   clearRequest();
 
   if (!m_loader)
     return true;
 
   // Cancelling the ThreadableLoader m_loader may result in calling
   // window.onload synchronously. If such an onload handler contains open()
   // call on the same XMLHttpRequest object, reentry happens.
   //
@@ skipping 23 matching lines @@
   m_responseText.clear();
 
   m_parsedResponse = false;
   m_responseDocument = nullptr;
 
   m_responseBlob = nullptr;
 
   m_downloadingToFile = false;
   m_lengthDownloadedToFile = 0;
 
-  m_responseLegacyStream = nullptr;
-
   // These variables may referred by the response accessors. So, we can clear
   // this only when we clear the response holder variables above.
   m_binaryResponseBuilder.clear();
   m_responseArrayBuffer.clear();
 }
 
 void XMLHttpRequest::clearRequest() {
   m_requestHeaders.clear();
 }
 
@@ skipping 362 matching lines @@
   }
 
   if (m_decoder) {
     auto text = m_decoder->flush();
     if (!text.isEmpty() && !m_responseTextOverflow) {
       m_responseText = m_responseText.concatenateWith(text);
       m_responseTextOverflow = m_responseText.isEmpty();
     }
   }
 
-  if (m_responseLegacyStream)
-    m_responseLegacyStream->finalize();
-
   clearVariablesForLoading();
   endLoading();
 }
 
 void XMLHttpRequest::didFinishLoadingFromBlob() {
   NETWORK_DVLOG(1) << this << " didFinishLoadingFromBlob";
   ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
 
   didFinishLoadingInternal();
 }
@@ skipping 22 matching lines @@
   }
   return BlobDataHandle::create(std::move(blobData), m_lengthDownloadedToFile);
 }
 
 void XMLHttpRequest::notifyParserStopped() {
   ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
 
   // This should only be called when response document is parsed asynchronously.
   DCHECK(m_responseDocumentParser);
   DCHECK(!m_responseDocumentParser->isParsing());
-  DCHECK(!m_responseLegacyStream);
 
   // Do nothing if we are called from |internalAbort()|.
   if (m_error)
     return;
 
   clearVariablesForLoading();
 
   m_responseDocument->implicitClose();
 
   if (!m_responseDocument->wellFormed())
@@ skipping 142 matching lines @@
     if (!text.isEmpty() && !m_responseTextOverflow) {
       m_responseText = m_responseText.concatenateWith(text);
       m_responseTextOverflow = m_responseText.isEmpty();
     }
   } else if (m_responseTypeCode == ResponseTypeArrayBuffer ||
              m_responseTypeCode == ResponseTypeBlob) {
     // Buffer binary data.
     if (!m_binaryResponseBuilder)
       m_binaryResponseBuilder = SharedBuffer::create();
     m_binaryResponseBuilder->append(data, len);
-  } else if (m_responseTypeCode == ResponseTypeLegacyStream) {
-    if (!m_responseLegacyStream)
-      m_responseLegacyStream =
-          Stream::create(getExecutionContext(), responseType());
-    m_responseLegacyStream->addData(data, len);
   }
 
   if (m_blobLoader) {
     // In this case, the data is provided by m_blobLoader. As progress
     // events are already fired, we should return here.
     return;
   }
   trackProgress(len);
 }
 
@@ skipping 64 matching lines @@
 const AtomicString& XMLHttpRequest::interfaceName() const {
   return EventTargetNames::XMLHttpRequest;
 }
 
 ExecutionContext* XMLHttpRequest::getExecutionContext() const {
   return ActiveDOMObject::getExecutionContext();
 }
 
 DEFINE_TRACE(XMLHttpRequest) {
   visitor->trace(m_responseBlob);
-  visitor->trace(m_responseLegacyStream);
   visitor->trace(m_loader);
   visitor->trace(m_responseDocument);
   visitor->trace(m_responseDocumentParser);
   visitor->trace(m_responseArrayBuffer);
   visitor->trace(m_progressEventThrottle);
   visitor->trace(m_upload);
   visitor->trace(m_blobLoader);
   XMLHttpRequestEventTarget::trace(visitor);
   DocumentParserClient::trace(visitor);
   ActiveDOMObject::trace(visitor);
 }
 
 DEFINE_TRACE_WRAPPERS(XMLHttpRequest) {
   visitor->traceWrappers(m_responseBlob);
-  visitor->traceWrappers(m_responseLegacyStream);
   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