Loading: bulk style errors fix 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 30 matching lines @@
 #include "wtf/StdLibExtras.h"
 #include "wtf/Vector.h"
 #include <memory>
 #include <v8.h>
 
 namespace blink {
 
 ImageResource* ImageResource::fetch(FetchRequest& request,
                                     ResourceFetcher* fetcher) {
   if (request.resourceRequest().requestContext() ==
-      WebURLRequest::RequestContextUnspecified)
+      WebURLRequest::RequestContextUnspecified) {
     request.mutableResourceRequest().setRequestContext(
         WebURLRequest::RequestContextImage);
+  }
   if (fetcher->context().pageDismissalEventBeingDispatched()) {
     KURL requestURL = request.resourceRequest().url();
     if (requestURL.isValid() &&
         fetcher->context().canRequest(Resource::Image,
                                       request.resourceRequest(), requestURL,
                                       request.options(), request.forPreload(),
                                       request.getOriginRestriction()))
       fetcher->context().sendImagePing(requestURL);
     return nullptr;
   }
@@ skipping 158 matching lines @@
   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 (!ThreadHeap::willObjectBeLazilySwept(this))
+    if (!ThreadHeap::willObjectBeLazilySwept(this)) {
       Platform::current()->currentThread()->getWebTaskRunner()->postTask(
           BLINK_FROM_HERE, WTF::bind(&ImageResource::doResetAnimation,
                                      wrapWeakPersistent(this)));
-    else
+    } else {
       m_image->resetAnimation();
+    }
   }
   if (m_multipartParser)
     m_multipartParser->cancel();
   Resource::allClientsAndObserversRemoved();
 }
 
 PassRefPtr<const SharedBuffer> ImageResource::resourceBuffer() const {
   if (data())
     return data();
   if (m_image)
@@ skipping 60 matching lines @@
 LayoutSize ImageResource::imageSize(
     RespectImageOrientationEnum shouldRespectImageOrientation,
     float multiplier,
     SizeType sizeType) {
   if (!m_image)
     return LayoutSize();
 
   LayoutSize size;
 
   if (m_image->isBitmapImage() &&
-      shouldRespectImageOrientation == RespectImageOrientation)
+      shouldRespectImageOrientation == RespectImageOrientation) {
     size =
         LayoutSize(toBitmapImage(m_image.get())->sizeRespectingOrientation());
-  else
+  } else {
     size = LayoutSize(m_image->size());
+  }
 
   if (sizeType == IntrinsicCorrectedToDPR && m_hasDevicePixelRatioHeaderValue &&
       m_devicePixelRatioHeaderValue > 0)
     multiplier = 1 / m_devicePixelRatioHeaderValue;
 
   if (multiplier == 1 || m_image->hasRelativeSize())
     return size;
 
   // Don't let images that have a width/height >= 1 shrink below 1 when zoomed.
   LayoutSize minimumSize(
@@ skipping 111 matching lines @@
   Resource::error(error);
   notifyObservers();
 }
 
 void ImageResource::responseReceived(
     const ResourceResponse& response,
     std::unique_ptr<WebDataConsumerHandle> handle) {
   DCHECK(!handle);
   DCHECK(!m_multipartParser);
   // If there's no boundary, just handle the request normally.
-  if (response.isMultipart() && !response.multipartBoundary().isEmpty())
+  if (response.isMultipart() && !response.multipartBoundary().isEmpty()) {
     m_multipartParser = new MultipartImageResourceParser(
         response, response.multipartBoundary(), this);
+  }
   Resource::responseReceived(response, std::move(handle));
   if (RuntimeEnabledFeatures::clientHintsEnabled()) {
     m_devicePixelRatioHeaderValue =
         this->response()
             .httpHeaderField(HTTPNames::Content_DPR)
             .toFloat(&m_hasDevicePixelRatioHeaderValue);
     if (!m_hasDevicePixelRatioHeaderValue ||
         m_devicePixelRatioHeaderValue <= 0.0) {
       m_devicePixelRatioHeaderValue = 1.0;
       m_hasDevicePixelRatioHeaderValue = false;
@@ skipping 130 matching lines @@
       loader()->didFinishLoadingFirstPartInMultipart();
   }
 }
 
 void ImageResource::multipartDataReceived(const char* bytes, size_t size) {
   DCHECK(m_multipartParser);
   Resource::appendData(bytes, size);
 }
 
 bool ImageResource::isAccessAllowed(SecurityOrigin* securityOrigin) {
-  if (response().wasFetchedViaServiceWorker())
+  if (response().wasFetchedViaServiceWorker()) {
     return response().serviceWorkerResponseType() !=
            WebServiceWorkerResponseTypeOpaque;
+  }
   if (!getImage()->currentFrameHasSingleSecurityOrigin())
     return false;
   if (passesAccessControlCheck(securityOrigin))
     return true;
   return !securityOrigin->taintsCanvas(response().url());
 }
 
 }  // namespace blink