Loading: bulk style errors fix in core/loader

third_party/WebKit/Source/core/loader/LinkLoader.cpp

 /*
  * Copyright (C) 2011 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 122 matching lines @@
   if (relAttribute.isDNSPrefetch()) {
     UseCounter::count(document, UseCounter::LinkRelDnsPrefetch);
     if (caller == LinkCalledFromHeader)
       UseCounter::count(document, UseCounter::LinkHeaderDnsPrefetch);
     Settings* settings = document.settings();
     // FIXME: The href attribute of the link element can be in "//hostname"
     // form, and we shouldn't attempt to complete that as URL
     // <https://bugs.webkit.org/show_bug.cgi?id=48857>.
     if (settings && settings->dnsPrefetchingEnabled() && href.isValid() &&
         !href.isEmpty()) {
-      if (settings->logDnsPrefetchAndPreconnect())
+      if (settings->logDnsPrefetchAndPreconnect()) {
         document.addConsoleMessage(ConsoleMessage::create(
             OtherMessageSource, DebugMessageLevel,
             String("DNS prefetch triggered for " + href.host())));
+      }
       networkHintsInterface.dnsPrefetchHost(href.host());
     }
   }
 }
 
 static void preconnectIfNeeded(
     const LinkRelAttribute& relAttribute,
     const KURL& href,
     Document& document,
     const CrossOriginAttributeValue crossOrigin,
@@ skipping 119 matching lines @@
   if (!href.isValid() || href.isEmpty()) {
     document.addConsoleMessage(ConsoleMessage::create(
         OtherMessageSource, WarningMessageLevel,
         String("<link rel=preload> has an invalid `href` value")));
     return nullptr;
   }
 
   if (!media.isEmpty()) {
     MediaValues* mediaValues =
         MediaValues::createDynamicIfFrameExists(document.frame());
-    if (viewportDescription)
+    if (viewportDescription) {
       mediaValues->overrideViewportDimensions(
           viewportDescription->maxWidth.getFloatValue(),
           viewportDescription->maxHeight.getFloatValue());
+    }
 
     // Preload only if media matches
     MediaQuerySet* mediaQueries = MediaQuerySet::create(media);
     MediaQueryEvaluator evaluator(*mediaValues);
     if (!evaluator.eval(mediaQueries))
       return nullptr;
   }
   if (caller == LinkCalledFromHeader)
     UseCounter::count(document, UseCounter::LinkHeaderPreload);
   Resource::Type resourceType;
@@ skipping 10 matching lines @@
         OtherMessageSource, WarningMessageLevel,
         String("<link rel=preload> has an unsupported `type` value")));
     return nullptr;
   }
   ResourceRequest resourceRequest(document.completeURL(href));
   ResourceFetcher::determineRequestContext(resourceRequest, resourceType,
                                            false);
   FetchRequest linkRequest(resourceRequest, FetchInitiatorTypeNames::link,
                            document.encodingName());
 
-  if (crossOrigin != CrossOriginAttributeNotSet)
+  if (crossOrigin != CrossOriginAttributeNotSet) {
     linkRequest.setCrossOriginAccessControl(document.getSecurityOrigin(),
                                             crossOrigin);
+  }
   Settings* settings = document.settings();
-  if (settings && settings->logPreload())
+  if (settings && settings->logPreload()) {
     document.addConsoleMessage(ConsoleMessage::create(
         OtherMessageSource, DebugMessageLevel,
         String("Preload triggered for " + href.host() + href.path())));
+  }
   linkRequest.setForPreload(true, monotonicallyIncreasingTime());
   linkRequest.setLinkPreload(true);
   return document.loader()->startPreload(resourceType, linkRequest);
 }
 
 void LinkLoader::loadLinksFromHeader(
     const String& headerValue,
     const KURL& baseURL,
     Document* document,
     const NetworkHintsInterface& networkHintsInterface,
@@ skipping 55 matching lines @@
 
   // FIXME(crbug.com/463266): We're ignoring type here, for everything but
   // preload. Maybe we shouldn't.
   dnsPrefetchIfNeeded(relAttribute, href, document, networkHintsInterface,
                       LinkCalledFromMarkup);
 
   preconnectIfNeeded(relAttribute, href, document, crossOrigin,
                      networkHintsInterface, LinkCalledFromMarkup);
 
   bool errorOccurred = false;
-  if (m_client->shouldLoadLink())
+  if (m_client->shouldLoadLink()) {
     createLinkPreloadResourceClient(preloadIfNeeded(
         relAttribute, href, document, as, type, media, crossOrigin,
         LinkCalledFromMarkup, errorOccurred, nullptr));
+  }
   if (errorOccurred)
     m_linkLoadingErrorTimer.startOneShot(0, BLINK_FROM_HERE);
 
   if (href.isEmpty() || !href.isValid())
     released();
 
   // FIXME(crbug.com/323096): Should take care of import.
   if (relAttribute.isLinkPrefetch() && href.isValid() && document.frame()) {
     if (!m_client->shouldLoadLink())
       return false;
     UseCounter::count(document, UseCounter::LinkRelPrefetch);
 
     FetchRequest linkRequest(ResourceRequest(document.completeURL(href)),
                              FetchInitiatorTypeNames::link);
-    if (crossOrigin != CrossOriginAttributeNotSet)
+    if (crossOrigin != CrossOriginAttributeNotSet) {
       linkRequest.setCrossOriginAccessControl(document.getSecurityOrigin(),
                                               crossOrigin);
+    }
     setResource(LinkFetchResource::fetch(Resource::LinkPrefetch, linkRequest,
                                          document.fetcher()));
   }
 
   if (const unsigned prerenderRelTypes =
           prerenderRelTypesFromRelAttribute(relAttribute, document)) {
     if (!m_prerender) {
       m_prerender =
           PrerenderHandle::create(document, this, href, prerenderRelTypes);
     } else if (m_prerender->url() != href) {
@@ skipping 22 matching lines @@
 
 DEFINE_TRACE(LinkLoader) {
   visitor->trace(m_client);
   visitor->trace(m_prerender);
   visitor->trace(m_linkPreloadResourceClient);
   ResourceOwner<Resource, ResourceClient>::trace(visitor);
   PrerenderClient::trace(visitor);
 }
 
 }  // namespace blink