reflow comments in web/

third_party/WebKit/Source/web/AssociatedURLLoader.cpp

 /*
  * Copyright (C) 2010, 2011, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 62 matching lines @@
 
 void HTTPRequestHeaderValidator::visitHeader(const WebString& name,
                                              const WebString& value) {
   m_isSafe = m_isSafe && isValidHTTPToken(name) &&
              !FetchUtils::isForbiddenHeaderName(name) &&
              isValidHTTPHeaderValue(value);
 }
 
 }  // namespace
 
-// This class bridges the interface differences between WebCore and WebKit loader clients.
+// This class bridges the interface differences between WebCore and WebKit
+// loader clients.
 // It forwards its ThreadableLoaderClient notifications to a WebURLLoaderClient.
 class AssociatedURLLoader::ClientAdapter final
     : public DocumentThreadableLoaderClient {
   WTF_MAKE_NONCOPYABLE(ClientAdapter);
 
  public:
   static std::unique_ptr<ClientAdapter> create(AssociatedURLLoader*,
                                                WebURLLoaderClient*,
                                                const WebURLLoaderOptions&);
 
@@ skipping 11 matching lines @@
   void didFail(const ResourceError&) override;
   void didFailRedirectCheck() override;
   // DocumentThreadableLoaderClient
   void willFollowRedirect(
       ResourceRequest& /*newRequest*/,
       const ResourceResponse& /*redirectResponse*/) override;
 
   // Sets an error to be reported back to the client, asychronously.
   void setDelayedError(const ResourceError&);
 
-  // Enables forwarding of error notifications to the WebURLLoaderClient. These must be
-  // deferred until after the call to AssociatedURLLoader::loadAsynchronously() completes.
+  // Enables forwarding of error notifications to the WebURLLoaderClient. These
+  // must be deferred until after the call to
+  // AssociatedURLLoader::loadAsynchronously() completes.
   void enableErrorNotifications();
 
-  // Stops loading and releases the DocumentThreadableLoader as early as possible.
+  // Stops loading and releases the DocumentThreadableLoader as early as
+  // possible.
   WebURLLoaderClient* releaseClient() {
     WebURLLoaderClient* client = m_client;
     m_client = nullptr;
     return client;
   }
 
  private:
   ClientAdapter(AssociatedURLLoader*,
                 WebURLLoaderClient*,
                 const WebURLLoaderOptions&);
@@ skipping 142 matching lines @@
   if (m_enableErrorNotifications)
     notifyError(&m_errorTimer);
 }
 
 void AssociatedURLLoader::ClientAdapter::didFailRedirectCheck() {
   didFail(ResourceError());
 }
 
 void AssociatedURLLoader::ClientAdapter::enableErrorNotifications() {
   m_enableErrorNotifications = true;
-  // If an error has already been received, start a timer to report it to the client
-  // after AssociatedURLLoader::loadAsynchronously has returned to the caller.
+  // If an error has already been received, start a timer to report it to the
+  // client after AssociatedURLLoader::loadAsynchronously has returned to the
+  // caller.
   if (m_didFail)
     m_errorTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void AssociatedURLLoader::ClientAdapter::notifyError(TimerBase* timer) {
   ASSERT_UNUSED(timer, timer == &m_errorTimer);
 
   if (!m_client)
     return;
 
@@ skipping 92 matching lines @@
 
     ResourceLoaderOptions resourceLoaderOptions;
     resourceLoaderOptions.allowCredentials = m_options.allowCredentials
                                                  ? AllowStoredCredentials
                                                  : DoNotAllowStoredCredentials;
     resourceLoaderOptions.dataBufferingPolicy = DoNotBufferData;
 
     const ResourceRequest& webcoreRequest = newRequest.toResourceRequest();
     if (webcoreRequest.requestContext() ==
         WebURLRequest::RequestContextUnspecified) {
-      // FIXME: We load URLs without setting a TargetType (and therefore a request context) in several
-      // places in content/ (P2PPortAllocatorSession::AllocateLegacyRelaySession, for example). Remove
-      // this once those places are patched up.
+      // FIXME: We load URLs without setting a TargetType (and therefore a
+      // request context) in several places in content/
+      // (P2PPortAllocatorSession::AllocateLegacyRelaySession, for example).
+      // Remove this once those places are patched up.
       newRequest.setRequestContext(WebURLRequest::RequestContextInternal);
     }
 
     Document* document = toDocument(m_observer->lifecycleContext());
     DCHECK(document);
     m_loader = DocumentThreadableLoader::create(
         *document, m_clientAdapter.get(), options, resourceLoaderOptions);
     m_loader->start(webcoreRequest);
   }
 
@@ skipping 68 matching lines @@
   // there could be a WebURLLoader instance behind the
   // DocumentThreadableLoader instance. So, for safety, we chose to just
   // crash here.
   RELEASE_ASSERT(ThreadState::current());
 
   m_observer->dispose();
   m_observer = nullptr;
 }
 
 }  // namespace blink