Reflow comments in core/fetch

third_party/WebKit/Source/core/fetch/ImageResource.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
@@ skipping 119 matching lines @@
 
 void ImageResource::addObserver(ImageResourceObserver* observer) {
   willAddClientOrObserver(MarkAsReferenced);
 
   m_observers.add(observer);
 
   if (isCacheValidator())
     return;
 
   // When the response is not multipart, if |data()| exists, |m_image| must be
-  // created. This is assured that |updateImage()| is called when
-  // |appendData()| is called.
+  // created. This is assured that |updateImage()| is called when |appendData()|
+  // is called.
   //
-  // On the other hand, when the response is multipart, |updateImage()| is
-  // not called in |appendData()|, which means |m_image| might not be created
-  // even when |data()| exists. This is intentional since creating a |m_image|
-  // on receiving data might destroy an existing image in a previous part.
+  // On the other hand, when the response is multipart, |updateImage()| is not
+  // called in |appendData()|, which means |m_image| might not be created even
+  // when |data()| exists. This is intentional since creating a |m_image| on
+  // receiving data might destroy an existing image in a previous part.
   DCHECK((m_multipartParser && isLoading()) || !data() || m_image);
 
   if (m_image && !m_image->isNull()) {
     observer->imageChanged(this);
   }
 
   if (isLoaded()) {
     markObserverFinished(observer);
     observer->imageNotifyFinished(this);
   }
@@ skipping 49 matching lines @@
 }
 
 void ImageResource::doResetAnimation() {
   if (m_image)
     m_image->resetAnimation();
 }
 
 void ImageResource::allClientsAndObserversRemoved() {
   if (m_image) {
     CHECK(!errorOccurred());
-    // If possible, delay the resetting until back at the event loop.
-    // Doing so after a conservative GC prevents resetAnimation() from
-    // upsetting ongoing animation updates (crbug.com/613709)
+    // If possible, delay the resetting until back at the event loop. Doing so
+    // after a conservative GC prevents resetAnimation() from upsetting ongoing
+    // animation updates (crbug.com/613709)
     if (!ThreadHeap::willObjectBeLazilySwept(this))
       Platform::current()->currentThread()->getWebTaskRunner()->postTask(
           BLINK_FROM_HERE, WTF::bind(&ImageResource::doResetAnimation,
                                      wrapWeakPersistent(this)));
     else
       m_image->resetAnimation();
   }
   if (m_multipartParser)
     m_multipartParser->cancel();
   Resource::allClientsAndObserversRemoved();
@@ skipping 29 matching lines @@
                     (blink::Image::loadPlatformResource("missingImage")));
   return std::make_pair(brokenImageLoRes, 1);
 }
 
 bool ImageResource::willPaintBrokenImage() const {
   return errorOccurred();
 }
 
 blink::Image* ImageResource::getImage() {
   if (errorOccurred()) {
-    // Returning the 1x broken image is non-ideal, but we cannot reliably access the appropriate
-    // deviceScaleFactor from here. It is critical that callers use ImageResource::brokenImage()
-    // when they need the real, deviceScaleFactor-appropriate broken image icon.
+    // Returning the 1x broken image is non-ideal, but we cannot reliably access
+    // the appropriate deviceScaleFactor from here. It is critical that callers
+    // use ImageResource::brokenImage() when they need the real,
+    // deviceScaleFactor-appropriate broken image icon.
     return brokenImage(1).first;
   }
 
   if (m_image)
     return m_image.get();
 
   return blink::Image::nullImage();
 }
 
 bool ImageResource::usesImageContainerSize() const {
@@ skipping 70 matching lines @@
     m_image = BitmapImage::create(this);
   }
 }
 
 inline void ImageResource::clearImage() {
   if (!m_image)
     return;
   int64_t length = m_image->data() ? m_image->data()->size() : 0;
   v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-length);
 
-  // If our Image has an observer, it's always us so we need to clear the back pointer
-  // before dropping our reference.
+  // If our Image has an observer, it's always us so we need to clear the back
+  // pointer before dropping our reference.
   m_image->clearImageObserver();
   m_image.clear();
 }
 
 void ImageResource::updateImage(bool allDataReceived) {
   TRACE_EVENT0("blink", "ImageResource::updateImage");
 
   if (data())
     createImage();
 
   Image::SizeAvailability sizeAvailable = Image::SizeUnavailable;
 
-  // Have the image update its data from its internal buffer.
-  // It will not do anything now, but will delay decoding until
-  // queried for info (like size or specific image frames).
+  // Have the image update its data from its internal buffer. It will not do
+  // anything now, but will delay decoding until queried for info (like size or
+  // specific image frames).
   if (data()) {
     DCHECK(m_image);
     sizeAvailable = m_image->setData(data(), allDataReceived);
   }
 
-  // Go ahead and tell our observers to try to draw if we have either
-  // received all the data or the size is known. Each chunk from the
-  // network causes observers to repaint, which will force that chunk
-  // to decode.
+  // Go ahead and tell our observers to try to draw if we have either received
+  // all the data or the size is known. Each chunk from the network causes
+  // observers to repaint, which will force that chunk to decode.
   if (sizeAvailable == Image::SizeUnavailable && !allDataReceived)
     return;
   if (!m_image || m_image->isNull()) {
     size_t size = encodedSize();
     clear();
     if (!errorOccurred())
       setStatus(DecodeError);
     if (!allDataReceived && loader())
       loader()->didFinishLoading(nullptr, monotonicallyIncreasingTime(), size);
     memoryCache()->remove(this);
   }
 
-  // It would be nice to only redraw the decoded band of the image, but with the current design
-  // (decoding delayed until painting) that seems hard.
+  // It would be nice to only redraw the decoded band of the image, but with the
+  // current design (decoding delayed until painting) that seems hard.
   notifyObservers();
 }
 
 void ImageResource::updateImageAndClearBuffer() {
   clearImage();
   updateImage(true);
   clearData();
 }
 
 void ImageResource::finish(double loadFinishTime) {
@@ skipping 56 matching lines @@
                                          size_t newSize) {
   if (!image || image != m_image)
     return;
 
   setDecodedSize(newSize);
 }
 
 void ImageResource::didDraw(const blink::Image* image) {
   if (!image || image != m_image)
     return;
-  // decodedSize() == 0 indicates that the image is decoded into DiscardableMemory,
-  // not in MemoryCache. So we don't need to call Resource::didAccessDecodedData()
-  // to update MemoryCache.
+  // decodedSize() == 0 indicates that the image is decoded into
+  // DiscardableMemory, not in MemoryCache. So we don't need to call
+  // Resource::didAccessDecodedData() to update MemoryCache.
   if (decodedSize() != 0)
     Resource::didAccessDecodedData();
 }
 
 bool ImageResource::shouldPauseAnimation(const blink::Image* image) {
   if (!image || image != m_image)
     return false;
 
   for (auto* observer : m_finishedObservers.asVector()) {
     if (m_finishedObservers.contains(observer) && observer->willRenderImage())
@@ skipping 96 matching lines @@
     return response().serviceWorkerResponseType() !=
            WebServiceWorkerResponseTypeOpaque;
   if (!getImage()->currentFrameHasSingleSecurityOrigin())
     return false;
   if (passesAccessControlCheck(securityOrigin))
     return true;
   return !securityOrigin->taintsCanvas(response().url());
 }
 
 }  // namespace blink