reflow comments in web/

third_party/WebKit/Source/web/SharedWorkerRepositoryClientImpl.cpp

 /*
  * Copyright (C) 2009 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 37 matching lines @@
 #include "public/web/WebKit.h"
 #include "public/web/WebSharedWorker.h"
 #include "public/web/WebSharedWorkerCreationErrors.h"
 #include "public/web/WebSharedWorkerRepositoryClient.h"
 #include "web/WebLocalFrameImpl.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
-// Callback class that keeps the SharedWorker and WebSharedWorker objects alive while connecting.
+// Callback class that keeps the SharedWorker and WebSharedWorker objects alive
+// while connecting.
 class SharedWorkerConnector
     : private WebSharedWorkerConnector::ConnectListener {
  public:
   SharedWorkerConnector(
       SharedWorker* worker,
       const KURL& url,
       const String& name,
       WebMessagePortChannelUniquePtr channel,
       std::unique_ptr<WebSharedWorkerConnector> webWorkerConnector)
       : m_worker(worker),
@@ skipping 20 matching lines @@
 SharedWorkerConnector::~SharedWorkerConnector() {
   m_worker->setIsBeingConnected(false);
 }
 
 void SharedWorkerConnector::connect() {
   m_worker->setIsBeingConnected(true);
   m_webWorkerConnector->connect(m_channel.release(), this);
 }
 
 void SharedWorkerConnector::connected() {
-  // Free ourselves (this releases the SharedWorker so it can be freed as well if unreferenced).
+  // Free ourselves (this releases the SharedWorker so it can be freed as well
+  // if unreferenced).
   delete this;
 }
 
 void SharedWorkerConnector::scriptLoadFailed() {
   m_worker->dispatchEvent(Event::createCancelable(EventTypeNames::error));
-  // Free ourselves (this releases the SharedWorker so it can be freed as well if unreferenced).
+  // Free ourselves (this releases the SharedWorker so it can be freed as well
+  // if unreferenced).
   delete this;
 }
 
 static WebSharedWorkerRepositoryClient::DocumentID getId(void* document) {
   DCHECK(document);
   return reinterpret_cast<WebSharedWorkerRepositoryClient::DocumentID>(
       document);
 }
 
 void SharedWorkerRepositoryClientImpl::connect(
     SharedWorker* worker,
     WebMessagePortChannelUniquePtr port,
     const KURL& url,
     const String& name,
     ExceptionState& exceptionState) {
   DCHECK(m_client);
 
-  // No nested workers (for now) - connect() should only be called from document context.
+  // No nested workers (for now) - connect() should only be called from document
+  // context.
   DCHECK(worker->getExecutionContext()->isDocument());
   Document* document = toDocument(worker->getExecutionContext());
 
   // TODO(estark): this is broken, as it only uses the first header
   // when multiple might have been sent. Fix by making the
   // SharedWorkerConnector interface take a map that can contain
   // multiple headers.
   std::unique_ptr<Vector<CSPHeaderAndType>> headers =
       worker->getExecutionContext()->contentSecurityPolicy()->headers();
   WebString header;
@@ skipping 11 matching lines @@
       worker->getExecutionContext()->isSecureContext(unusedSecureContextError);
   std::unique_ptr<WebSharedWorkerConnector> webWorkerConnector =
       wrapUnique(m_client->createSharedWorkerConnector(
           url, name, getId(document), header, headerType,
           worker->getExecutionContext()->securityContext().addressSpace(),
           isSecureContext ? WebSharedWorkerCreationContextTypeSecure
                           : WebSharedWorkerCreationContextTypeNonsecure,
           &creationError));
   if (creationError != WebWorkerCreationErrorNone) {
     if (creationError == WebWorkerCreationErrorURLMismatch) {
-      // Existing worker does not match this url, so return an error back to the caller.
+      // Existing worker does not match this url, so return an error back to the
+      // caller.
       exceptionState.throwDOMException(
           URLMismatchError, "The location of the SharedWorker named '" + name +
                                 "' does not exactly match the provided URL ('" +
                                 url.elidedString() + "').");
       return;
     } else if (creationError == WebWorkerCreationErrorSecureContextMismatch) {
       if (isSecureContext) {
         UseCounter::count(
             document,
             UseCounter::NonSecureSharedWorkerAccessedFromSecureContext);
       } else {
         UseCounter::count(
             document,
             UseCounter::SecureSharedWorkerAccessedFromNonSecureContext);
       }
     }
   }
 
-  // The connector object manages its own lifecycle (and the lifecycles of the two worker objects).
-  // It will free itself once connecting is completed.
+  // The connector object manages its own lifecycle (and the lifecycles of the
+  // two worker objects).  It will free itself once connecting is completed.
   SharedWorkerConnector* connector = new SharedWorkerConnector(
       worker, url, name, std::move(port), std::move(webWorkerConnector));
   connector->connect();
 }
 
 void SharedWorkerRepositoryClientImpl::documentDetached(Document* document) {
   DCHECK(m_client);
   m_client->documentDetached(getId(document));
 }
 
 SharedWorkerRepositoryClientImpl::SharedWorkerRepositoryClientImpl(
     WebSharedWorkerRepositoryClient* client)
     : m_client(client) {}
 
 }  // namespace blink