Loading: bulk style errors fix in core/fetch

third_party/WebKit/Source/core/fetch/ResourceFetcher.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) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
     rights reserved.
     Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
@@ skipping 306 matching lines @@
 // http://crbug.com/52411
 static const int kMaxValidatedURLsSize = 10000;
 
 void ResourceFetcher::requestLoadStarted(unsigned long identifier,
                                          Resource* resource,
                                          const FetchRequest& request,
                                          ResourceLoadStartType type,
                                          bool isStaticData) {
   if (type == ResourceLoadingFromCache &&
       resource->getStatus() == Resource::Cached &&
-      !m_validatedURLs.contains(resource->url()))
+      !m_validatedURLs.contains(resource->url())) {
     context().dispatchDidLoadResourceFromMemoryCache(
         identifier, resource, request.resourceRequest().frameType(),
         request.resourceRequest().requestContext());
+  }
 
   if (isStaticData)
     return;
 
   if (type == ResourceLoadingFromCache && !resource->stillNeedsLoad() &&
       !m_validatedURLs.contains(request.resourceRequest().url())) {
     // Resources loaded from memory cache should be reported the first time
     // they're used.
     std::unique_ptr<ResourceTimingInfo> info = ResourceTimingInfo::create(
         request.options().initiatorInfo.name, monotonicallyIncreasingTime(),
@@ skipping 174 matching lines @@
   initializeResourceRequest(request.mutableResourceRequest(), factory.type(),
                             request.defer());
   context().willStartLoadingResource(
       identifier, request.mutableResourceRequest(), factory.type());
   if (!request.url().isValid())
     return nullptr;
 
   if (!request.forPreload()) {
     V8DOMActivityLogger* activityLogger = nullptr;
     if (request.options().initiatorInfo.name ==
-        FetchInitiatorTypeNames::xmlhttprequest)
+        FetchInitiatorTypeNames::xmlhttprequest) {
       activityLogger = V8DOMActivityLogger::currentActivityLogger();
-    else
+    } else {
       activityLogger =
           V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld();
+    }
 
     if (activityLogger) {
       Vector<String> argv;
       argv.append(Resource::resourceTypeToString(
           factory.type(), request.options().initiatorInfo));
       argv.append(request.url());
       activityLogger->logEvent("blinkRequestResource", argv.size(),
                                argv.data());
     }
   }
 
   bool isDataUrl = request.resourceRequest().url().protocolIsData();
   bool isStaticData = isDataUrl || substituteData.isValid() || m_archive;
   Resource* resource(nullptr);
   if (isStaticData) {
     resource = resourceForStaticData(request, factory, substituteData);
     // Abort the request if the archive doesn't contain the resource, except in
     // the case of data URLs which might have resources such as fonts that need
     // to be decoded only on demand.  These data URLs are allowed to be
     // processed using the normal ResourceFetcher machinery.
     if (!resource && !isDataUrl && m_archive)
       return nullptr;
   }
-  if (!resource)
+  if (!resource) {
     resource =
         memoryCache()->resourceForURL(request.url(), getCacheIdentifier());
+  }
 
   // See if we can use an existing resource from the cache. If so, we need to
   // move it to be load blocking.
   moveCachedNonBlockingResourceToBlocking(resource, request);
 
   const RevalidationPolicy policy = determineRevalidationPolicy(
       factory.type(), request, resource, isStaticData);
   TRACE_EVENT_INSTANT1("blink", "ResourceFetcher::determineRevalidationPolicy",
                        TRACE_EVENT_SCOPE_THREAD, "revalidationPolicy", policy);
 
@@ skipping 115 matching lines @@
   DCHECK(resource->canUseCacheValidator());
   DCHECK(!resource->isCacheValidator());
   DCHECK(!context().isControlledByServiceWorker());
 
   const AtomicString& lastModified =
       resource->response().httpHeaderField(HTTPNames::Last_Modified);
   const AtomicString& eTag =
       resource->response().httpHeaderField(HTTPNames::ETag);
   if (!lastModified.isEmpty() || !eTag.isEmpty()) {
     DCHECK_NE(context().getCachePolicy(), CachePolicyReload);
-    if (context().getCachePolicy() == CachePolicyRevalidate)
+    if (context().getCachePolicy() == CachePolicyRevalidate) {
       revalidatingRequest.setHTTPHeaderField(HTTPNames::Cache_Control,
                                              "max-age=0");
+    }
   }
-  if (!lastModified.isEmpty())
+  if (!lastModified.isEmpty()) {
     revalidatingRequest.setHTTPHeaderField(HTTPNames::If_Modified_Since,
                                            lastModified);
+  }
   if (!eTag.isEmpty())
     revalidatingRequest.setHTTPHeaderField(HTTPNames::If_None_Match, eTag);
 
   double stalenessLifetime = resource->stalenessLifetime();
   if (std::isfinite(stalenessLifetime) && stalenessLifetime > 0) {
     revalidatingRequest.setHTTPHeaderField(
         HTTPNames::Resource_Freshness,
         AtomicString(String::format(
             "max-age=%.0lf,stale-while-revalidate=%.0lf,age=%.0lf",
             resource->freshnessLifetime(), stalenessLifetime,
@@ skipping 505 matching lines @@
     resource->loader()->didFail(
         nullptr, ResourceError::cancelledDueToAccessCheckError(response.url()));
     return;
   }
 
   context().dispatchDidReceiveResponse(
       resource->identifier(), response, resource->resourceRequest().frameType(),
       resource->resourceRequest().requestContext(), resource);
   resource->responseReceived(response, std::move(handle));
   if (resource->loader() && response.httpStatusCode() >= 400 &&
-      !resource->shouldIgnoreHTTPStatusCodeErrors())
+      !resource->shouldIgnoreHTTPStatusCodeErrors()) {
     resource->loader()->didFail(nullptr,
                                 ResourceError::cancelledError(response.url()));
+  }
 }
 
 void ResourceFetcher::didReceiveData(const Resource* resource,
                                      const char* data,
                                      int dataLength,
                                      int encodedDataLength) {
   context().dispatchDidReceiveData(resource->identifier(), data, dataLength,
                                    encodedDataLength);
 }
 
@@ skipping 367 matching lines @@
   visitor->trace(m_context);
   visitor->trace(m_archive);
   visitor->trace(m_loaders);
   visitor->trace(m_nonBlockingLoaders);
   visitor->trace(m_documentResources);
   visitor->trace(m_preloads);
   visitor->trace(m_resourceTimingInfoMap);
 }
 
 }  // namespace blink