reflow comments in modules/[fetch,indexeddb]

third_party/WebKit/Source/modules/indexeddb/IDBRequest.cpp

 /*
  * Copyright (C) 2010 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 37 matching lines @@
 
 using blink::WebIDBCursor;
 
 namespace blink {
 
 IDBRequest* IDBRequest::create(ScriptState* scriptState,
                                IDBAny* source,
                                IDBTransaction* transaction) {
   IDBRequest* request = new IDBRequest(scriptState, source, transaction);
   request->suspendIfNeeded();
-  // Requests associated with IDBFactory (open/deleteDatabase/getDatabaseNames) are not associated with transactions.
+  // Requests associated with IDBFactory (open/deleteDatabase/getDatabaseNames)
+  // are not associated with transactions.
   if (transaction)
     transaction->registerRequest(request);
   return request;
 }
 
 IDBRequest::IDBRequest(ScriptState* scriptState,
                        IDBAny* source,
                        IDBTransaction* transaction)
     : ActiveScriptWrappable(this),
       ActiveDOMObject(scriptState->getExecutionContext()),
@@ skipping 14 matching lines @@
   visitor->trace(m_enqueuedEvents);
   visitor->trace(m_pendingCursor);
   visitor->trace(m_cursorKey);
   visitor->trace(m_cursorPrimaryKey);
   EventTargetWithInlineData::trace(visitor);
   ActiveDOMObject::trace(visitor);
 }
 
 ScriptValue IDBRequest::result(ExceptionState& exceptionState) {
   if (m_readyState != DONE) {
-    // Must throw if returning an empty value. Message is arbitrary since it will never be seen.
+    // Must throw if returning an empty value. Message is arbitrary since it
+    // will never be seen.
     exceptionState.throwDOMException(
         InvalidStateError, IDBDatabase::requestNotFinishedErrorMessage);
     return ScriptValue();
   }
   if (m_contextStopped || !getExecutionContext()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      IDBDatabase::databaseClosedErrorMessage);
     return ScriptValue();
   }
   m_resultDirty = false;
@@ skipping 257 matching lines @@
                            PassRefPtr<IDBValue> value) {
   IDB_TRACE("IDBRequest::onSuccess(key, primaryKey, value)");
   if (!shouldEnqueueEvent())
     return;
 
   DCHECK(m_pendingCursor);
   setResultCursor(m_pendingCursor.release(), key, primaryKey, std::move(value));
 }
 
 bool IDBRequest::hasPendingActivity() const {
-  // FIXME: In an ideal world, we should return true as long as anyone has a or can
-  //        get a handle to us and we have event listeners. This is order to handle
-  //        user generated events properly.
+  // FIXME: In an ideal world, we should return true as long as anyone has a or
+  //        can get a handle to us and we have event listeners. This is order to
+  //        handle user generated events properly.
   return m_hasPendingActivity && !m_contextStopped;
 }
 
 void IDBRequest::stop() {
   if (m_contextStopped)
     return;
 
   m_contextStopped = true;
 
   if (m_readyState == PENDING) {
@@ skipping 40 matching lines @@
   targets.append(this);
   if (m_transaction && !m_preventPropagation) {
     targets.append(m_transaction);
     // If there ever are events that are associated with a database but
     // that do not have a transaction, then this will not work and we need
     // this object to actually hold a reference to the database (to ensure
     // it stays alive).
     targets.append(m_transaction->db());
   }
 
-  // Cursor properties should not be updated until the success event is being dispatched.
+  // Cursor properties should not be updated until the success event is being
+  // dispatched.
   IDBCursor* cursorToNotify = nullptr;
   if (event->type() == EventTypeNames::success) {
     cursorToNotify = getResultCursor();
     if (cursorToNotify)
       cursorToNotify->setValueReady(m_cursorKey.release(),
                                     m_cursorPrimaryKey.release(),
                                     m_cursorValue.release());
   }
 
   if (event->type() == EventTypeNames::upgradeneeded) {
     DCHECK(!m_didFireUpgradeNeededEvent);
     m_didFireUpgradeNeededEvent = true;
   }
 
-  // FIXME: When we allow custom event dispatching, this will probably need to change.
+  // FIXME: When we allow custom event dispatching, this will probably need to
+  // change.
   DCHECK(event->type() == EventTypeNames::success ||
          event->type() == EventTypeNames::error ||
          event->type() == EventTypeNames::blocked ||
          event->type() == EventTypeNames::upgradeneeded)
       << "event type was " << event->type();
   const bool setTransactionActive =
       m_transaction &&
       (event->type() == EventTypeNames::success ||
        event->type() == EventTypeNames::upgradeneeded ||
        (event->type() == EventTypeNames::error && !m_requestAborted));
 
   if (setTransactionActive)
     m_transaction->setActive(true);
 
   DispatchEventResult dispatchResult =
       IDBEventDispatcher::dispatch(event, targets);
 
   if (m_transaction) {
     if (m_readyState == DONE)
       m_transaction->unregisterRequest(this);
 
-    // Possibly abort the transaction. This must occur after unregistering (so this request
-    // doesn't receive a second error) and before deactivating (which might trigger commit).
+    // Possibly abort the transaction. This must occur after unregistering (so
+    // this request doesn't receive a second error) and before deactivating
+    // (which might trigger commit).
     if (event->type() == EventTypeNames::error &&
         dispatchResult == DispatchEventResult::NotCanceled &&
         !m_requestAborted) {
       m_transaction->setError(m_error);
       m_transaction->abort(IGNORE_EXCEPTION);
     }
 
-    // If this was the last request in the transaction's list, it may commit here.
+    // If this was the last request in the transaction's list, it may commit
+    // here.
     if (setTransactionActive)
       m_transaction->setActive(false);
   }
 
   if (cursorToNotify)
     cursorToNotify->postSuccessHandlerCallback();
 
-  // An upgradeneeded event will always be followed by a success or error event, so must
-  // be kept alive.
+  // An upgradeneeded event will always be followed by a success or error event,
+  // so must be kept alive.
   if (m_readyState == DONE && event->type() != EventTypeNames::upgradeneeded)
     m_hasPendingActivity = false;
 
   return dispatchResult;
 }
 
 void IDBRequest::uncaughtExceptionInEventHandler() {
   if (m_transaction && !m_requestAborted) {
     m_transaction->setError(DOMException::create(
         AbortError, "Uncaught exception in event handler."));
@@ skipping 36 matching lines @@
 }
 
 void IDBRequest::dequeueEvent(Event* event) {
   for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
     if (m_enqueuedEvents[i].get() == event)
       m_enqueuedEvents.remove(i);
   }
 }
 
 }  // namespace blink