reflow comments in core/xml*

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
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public
  *  License along with this library; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ *  Boston, MA 02110-1301 USA
  */
 
 #include "core/xmlhttprequest/XMLHttpRequest.h"
 
 #include "bindings/core/v8/ArrayBufferOrArrayBufferViewOrBlobOrDocumentOrStringOrFormData.h"
 #include "bindings/core/v8/ArrayBufferOrArrayBufferViewOrBlobOrUSVString.h"
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/DOMArrayBuffer.h"
@@ skipping 72 matching lines @@
 void replaceCharsetInMediaType(String& mediaType, const String& charsetValue) {
   unsigned pos = 0, len = 0;
 
   findCharsetInMediaType(mediaType, pos, len);
 
   if (!len) {
     // When no charset found, do nothing.
     return;
   }
 
-  // Found at least one existing charset, replace all occurrences with new charset.
+  // Found at least one existing charset, replace all occurrences with new
+  // charset.
   while (len) {
     mediaType.replace(pos, len, charsetValue);
     unsigned start = pos + charsetValue.length();
     findCharsetInMediaType(mediaType, pos, len, start);
   }
 }
 
 void logConsoleError(ExecutionContext* context, const String& message) {
   if (!context)
     return;
-  // FIXME: It's not good to report the bad usage without indicating what source line it came from.
-  // We should pass additional parameters so we can tell the console where the mistake occurred.
+  // FIXME: It's not good to report the bad usage without indicating what source
+  // line it came from.  We should pass additional parameters so we can tell the
+  // console where the mistake occurred.
   ConsoleMessage* consoleMessage =
       ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message);
   context->addConsoleMessage(consoleMessage);
 }
 
 enum HeaderValueCategoryByRFC7230 {
   HeaderValueInvalid,
   HeaderValueAffectedByNormalization,
   HeaderValueValid,
   HeaderValueCategoryByRFC7230End
@@ skipping 138 matching lines @@
 
 ScriptString XMLHttpRequest::responseJSONSource() {
   DCHECK_EQ(m_responseTypeCode, ResponseTypeJSON);
 
   if (m_error || m_state != kDone)
     return ScriptString();
   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.
+  // 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);
@@ skipping 101 matching lines @@
   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."
+  // 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,
                                      "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.
+  // 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.
+  // 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 (getExecutionContext() && getExecutionContext()->isDocument() &&
       !m_async) {
     exceptionState.throwDOMException(InvalidAccessError,
                                      "The response type cannot be changed for "
                                      "synchronous requests made from a "
                                      "document.");
     return;
   }
 
   if (responseType == "") {
@@ skipping 162 matching lines @@
     return;
 
   State previousState = m_state;
   m_state = kUnsent;
   m_error = false;
   m_uploadComplete = false;
 
   if (!ContentSecurityPolicy::shouldBypassMainWorld(getExecutionContext()) &&
       !getExecutionContext()->contentSecurityPolicy()->allowConnectToSource(
           url)) {
-    // We can safely expose the URL to JavaScript, as these checks happen synchronously before redirection. JavaScript receives no new information.
+    // We can safely expose the URL to JavaScript, as these checks happen
+    // synchronously before redirection. JavaScript receives no new information.
     exceptionState.throwSecurityError(
         "Refused to connect to '" + url.elidedString() +
         "' because it violates the document's Content Security Policy.");
     return;
   }
 
   if (!async && getExecutionContext()->isDocument()) {
     if (document()->settings() &&
         !document()->settings()->syncXHRInDocumentsEnabled()) {
       exceptionState.throwDOMException(
           InvalidAccessError,
           "Synchronous requests are disabled for this page.");
       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.
+    // 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_responseTypeCode != ResponseTypeDefault) {
       exceptionState.throwDOMException(
           InvalidAccessError,
           "Synchronous requests from a document must not set a response type.");
       return;
     }
 
     // Similarly, timeouts are disabled for synchronous requests as well.
     if (m_timeoutMilliseconds > 0) {
       exceptionState.throwDOMException(
           InvalidAccessError, "Synchronous requests must not set a timeout.");
       return;
     }
 
     // Here we just warn that firing sync XHR's may affect responsiveness.
-    // Eventually sync xhr will be deprecated and an "InvalidAccessError" exception thrown.
+    // Eventually sync xhr will be deprecated and an "InvalidAccessError"
+    // exception thrown.
     // Refer : https://xhr.spec.whatwg.org/#sync-warning
     // Use count for XHR synchronous requests on main thread only.
     if (!document()->processingBeforeUnload())
       Deprecation::countDeprecation(
           getExecutionContext(),
           UseCounter::XMLHttpRequestSynchronousInNonWorkerOutsideBeforeUnload);
   }
 
   m_method = FetchUtils::normalizeMethod(method);
 
@@ skipping 256 matching lines @@
     if (!m_async) {
       throwForLoadFailureIfNeeded(
           exceptionState, "'GET' is the only method allowed for 'blob:' URLs.");
     }
     return;
   }
 
   DCHECK(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.
+  // 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();
       m_upload->dispatchEvent(
           ProgressEvent::create(EventTypeNames::loadstart, false, 0, 0));
     }
   }
 
   m_sameOriginRequest = getSecurityOrigin()->canRequestNoSuborigin(m_url);
 
   if (!m_sameOriginRequest && m_includeCredentials)
     UseCounter::count(&executionContext,
                       UseCounter::XMLHttpRequestCrossOriginWithCredentials);
 
-  // We also remember whether upload events should be allowed for this request in case the upload listeners are
-  // added after the request is started.
+  // We also remember whether upload events should be allowed for this request
+  // in case the upload listeners are added after the request is started.
   m_uploadEventsAllowed =
       m_sameOriginRequest || uploadEvents ||
       !FetchUtils::isSimpleRequest(m_method, m_requestHeaders);
 
   ResourceRequest request(m_url);
   request.setHTTPMethod(m_method);
   request.setRequestContext(WebURLRequest::RequestContextXMLHttpRequest);
   request.setFetchCredentialsMode(
       m_includeCredentials ? WebURLRequest::FetchCredentialsModeInclude
                            : WebURLRequest::FetchCredentialsModeSameOrigin);
@@ skipping 266 matching lines @@
   // the end here.
   DCHECK(m_error);
   changeState(kDone);
 
   if (!m_uploadComplete) {
     m_uploadComplete = true;
     if (m_upload && m_uploadEventsAllowed)
       m_upload->handleRequestError(type);
   }
 
-  // Note: The below event dispatch may be called while |hasPendingActivity() == false|,
-  // when |handleRequestError| is called after |internalAbort()|.
-  // This is safe, however, as |this| will be kept alive from a strong ref |Event::m_target|.
+  // Note: The below event dispatch may be called while |hasPendingActivity() ==
+  // false|, when |handleRequestError| is called after |internalAbort()|.  This

[jbroman, 2016/10/04 19:56:51]

ditto

+  // is safe, however, as |this| will be kept alive from a strong ref
+  // |Event::m_target|.
   dispatchProgressEvent(EventTypeNames::progress, receivedLength,
                         expectedLength);
   dispatchProgressEvent(type, receivedLength, expectedLength);
   dispatchProgressEvent(EventTypeNames::loadend, receivedLength,
                         expectedLength);
 }
 
 void XMLHttpRequest::overrideMimeType(const AtomicString& mimeType,
                                       ExceptionState& exceptionState) {
   if (m_state == kLoading || m_state == kDone) {
@@ skipping 189 matching lines @@
   if (!m_response.httpStatusText().isNull())
     return m_response.httpStatusText();
 
   return String();
 }
 
 void XMLHttpRequest::didFail(const ResourceError& error) {
   NETWORK_DVLOG(1) << this << " didFail()";
   ScopedEventDispatchProtect protect(&m_eventDispatchRecursionLevel);
 
-  // If we are already in an error state, for instance we called abort(), bail out early.
+  // If we are already in an error state, for instance we called abort(), bail
+  // out early.
   if (m_error)
     return;
 
   if (error.isCancellation()) {
     handleDidCancel();
     return;
   }
 
   if (error.isTimeout()) {
     handleDidTimeout();
@@ skipping 33 matching lines @@
     // but the user changed the response type after that. Hence we need to
     // read the response data and provide it to this object.
     m_blobLoader = BlobLoader::create(this, createBlobDataHandleFromResponse());
   } else {
     didFinishLoadingInternal();
   }
 }
 
 void XMLHttpRequest::didFinishLoadingInternal() {
   if (m_responseDocumentParser) {
-    // |DocumentParser::finish()| tells the parser that we have reached end of the data.
-    // When using |HTMLDocumentParser|, which works asynchronously, we do not have the
-    // complete document just after the |DocumentParser::finish()| call.
-    // Wait for the parser to call us back in |notifyParserStopped| to progress state.
+    // |DocumentParser::finish()| tells the parser that we have reached end of
+    // the data.  When using |HTMLDocumentParser|, which works asynchronously,

[jbroman, 2016/10/04 19:56:51]

ditto

+    // we do not have the complete document just after the
+    // |DocumentParser::finish()| call.  Wait for the parser to call us back in
+    // |notifyParserStopped| to progress state.
     m_responseDocumentParser->finish();
     DCHECK(m_responseDocument);
     return;
   }
 
   if (m_decoder) {
     auto text = m_decoder->flush();
     if (!text.isEmpty() && !m_responseTextOverflow) {
       m_responseText = m_responseText.concatenateWith(text);
       m_responseTextOverflow = m_responseText.isEmpty();
@@ skipping 320 matching lines @@
   visitor->traceWrappers(m_responseLegacyStream);
   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