Loading: bulk style errors fix in core/loader

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

 /*
  * Copyright (C) 2013 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 216 matching lines @@
                                                 request.url(),
                                                 request.httpReferrer())
                    .referrer,
                request.httpReferrer());
       outgoingOrigin = SecurityOrigin::createFromString(request.httpReferrer());
     }
 
     request.addHTTPOriginIfNeeded(outgoingOrigin.get());
   }
 
-  if (m_document)
+  if (m_document) {
     request.setExternalRequestStateFromRequestorAddressSpace(
         m_document->addressSpace());
+  }
 
   // The remaining modifications are only necessary for HTTP and HTTPS.
   if (!request.url().isEmpty() && !request.url().protocolIsInHTTPFamily())
     return;
 
   if (frame()->loader().loadType() == FrameLoadTypeReload)
     request.clearHTTPHeaderField("Save-Data");
 
   if (frame()->settings() && frame()->settings()->dataSaverEnabled())
     request.setHTTPHeaderField("Save-Data", "on");
@@ skipping 131 matching lines @@
 }
 
 void FrameFetchContext::dispatchWillSendRequest(
     unsigned long identifier,
     ResourceRequest& request,
     const ResourceResponse& redirectResponse,
     const FetchInitiatorInfo& initiatorInfo) {
   // For initial requests, prepareRequest() is called in
   // willStartLoadingResource(), before revalidation policy is determined. That
   // call doesn't exist for redirects, so call preareRequest() here.
-  if (!redirectResponse.isNull())
+  if (!redirectResponse.isNull()) {
     prepareRequest(request);
-  else
+  } else {
     frame()->loader().progress().willStartLoading(identifier,
                                                   request.priority());
+  }
   TRACE_EVENT_INSTANT1(
       "devtools.timeline", "ResourceSendRequest", TRACE_EVENT_SCOPE_THREAD,
       "data", InspectorSendRequestEvent::data(identifier, frame(), request));
   InspectorInstrumentation::willSendRequest(frame(), identifier,
                                             masterDocumentLoader(), request,
                                             redirectResponse, initiatorInfo);
   if (frame()->frameScheduler())
     frame()->frameScheduler()->didStartLoading(identifier);
 }
 
@@ skipping 67 matching lines @@
     Resource* resource,
     WebURLRequest::FrameType frameType,
     WebURLRequest::RequestContext requestContext) {
   ResourceRequest request(resource->url());
   frame()->loader().client()->dispatchDidLoadResourceFromMemoryCache(
       request, resource->response());
   dispatchWillSendRequest(identifier, request, ResourceResponse(),
                           resource->options().initiatorInfo);
 
   InspectorInstrumentation::markResourceAsCached(frame(), identifier);
-  if (!resource->response().isNull())
+  if (!resource->response().isNull()) {
     dispatchDidReceiveResponseInternal(identifier, resource->response(),
                                        frameType, requestContext, resource,
                                        LinkLoader::DoNotLoadResources);
+  }
 
   if (resource->encodedSize() > 0)
     dispatchDidReceiveData(identifier, 0, resource->encodedSize(), 0);
 
   dispatchDidFinishLoading(identifier, 0, 0);
 }
 
 bool FrameFetchContext::shouldLoadNewResource(Resource::Type type) const {
   if (!m_documentLoader)
     return true;
@@ skipping 17 matching lines @@
                                                  ResourceRequest& request,
                                                  Resource::Type type) {
   TRACE_EVENT_ASYNC_BEGIN1(
       "blink.net", "Resource", identifier, "data",
       loadResourceTraceData(identifier, request.url(), request.priority()));
   prepareRequest(request);
 
   if (!m_documentLoader || m_documentLoader->fetcher()->archive() ||
       !request.url().isValid())
     return;
-  if (type == Resource::MainResource)
+  if (type == Resource::MainResource) {
     m_documentLoader->applicationCacheHost()->willStartLoadingMainResource(
         request);
-  else
+  } else {
     m_documentLoader->applicationCacheHost()->willStartLoadingResource(request);
+  }
 }
 
 void FrameFetchContext::didLoadResource(Resource* resource) {
   if (resource->isLoadEventBlockingResourceType())
     frame()->loader().checkCompleted();
   if (m_document)
     FirstMeaningfulPaintDetector::from(*m_document).checkNetworkStable();
 }
 
 void FrameFetchContext::addResourceTiming(const ResourceTimingInfo& info) {
   Document* initiatorDocument = m_document && info.isMainResource()
                                     ? m_document->parentDocument()
                                     : m_document.get();
   if (!initiatorDocument || !initiatorDocument->domWindow())
     return;
   DOMWindowPerformance::performance(*initiatorDocument->domWindow())
       ->addResourceTiming(info);
 }
 
 bool FrameFetchContext::allowImage(bool imagesEnabled, const KURL& url) const {
   return frame()->loader().client()->allowImage(imagesEnabled, url);
 }
 
 void FrameFetchContext::printAccessDeniedMessage(const KURL& url) const {
   if (url.isNull())
     return;
 
   String message;
-  if (!m_document || m_document->url().isNull())
+  if (!m_document || m_document->url().isNull()) {
     message = "Unsafe attempt to load URL " + url.elidedString() + '.';
-  else if (url.isLocalFile() || m_document->url().isLocalFile())
+  } else if (url.isLocalFile() || m_document->url().isLocalFile()) {
     message = "Unsafe attempt to load URL " + url.elidedString() +
               " from frame with URL " + m_document->url().elidedString() +
               ". 'file:' URLs are treated as unique security origins.\n";
-  else
+  } else {
     message = "Unsafe attempt to load URL " + url.elidedString() +
               " from frame with URL " + m_document->url().elidedString() +
               ". Domains, protocols and ports must match.\n";
+  }
 
   frame()->document()->addConsoleMessage(ConsoleMessage::create(
       SecurityMessageSource, ErrorMessageLevel, message));
 }
 
 bool FrameFetchContext::canRequest(
     Resource::Type type,
     const ResourceRequest& resourceRequest,
     const KURL& url,
     const ResourceLoaderOptions& options,
     bool forPreload,
     FetchRequest::OriginRestriction originRestriction) const {
   ResourceRequestBlockedReason reason =
       canRequestInternal(type, resourceRequest, url, options, forPreload,
                          originRestriction, resourceRequest.redirectStatus());
   if (reason != ResourceRequestBlockedReasonNone) {
-    if (!forPreload)
+    if (!forPreload) {
       InspectorInstrumentation::didBlockRequest(frame(), resourceRequest,
                                                 masterDocumentLoader(),
                                                 options.initiatorInfo, reason);
+    }
     return false;
   }
   return true;
 }
 
 bool FrameFetchContext::allowResponse(
     Resource::Type type,
     const ResourceRequest& resourceRequest,
     const KURL& url,
     const ResourceLoaderOptions& options) const {
@@ skipping 112 matching lines @@
     return ResourceRequestBlockedReasonOrigin;
 
   // Measure the number of legacy URL schemes ('ftp://') and the number of
   // embedded-credential ('http://user:password@...') resources embedded as
   // subresources. in the hopes that we can block them at some point in the
   // future.
   if (resourceRequest.frameType() != WebURLRequest::FrameTypeTopLevel) {
     DCHECK(frame()->document());
     if (SchemeRegistry::shouldTreatURLSchemeAsLegacy(url.protocol()) &&
         !SchemeRegistry::shouldTreatURLSchemeAsLegacy(
-            frame()->document()->getSecurityOrigin()->protocol()))
+            frame()->document()->getSecurityOrigin()->protocol())) {
       UseCounter::count(frame()->document(),
                         UseCounter::LegacyProtocolEmbeddedAsSubresource);
-    if (!url.user().isEmpty() || !url.pass().isEmpty())
+    }
+    if (!url.user().isEmpty() || !url.pass().isEmpty()) {
       UseCounter::count(
           frame()->document(),
           UseCounter::RequestedSubresourceWithEmbeddedCredentials);
+    }
   }
 
   // Check for mixed content. We do this second-to-last so that when folks block
   // mixed content with a CSP policy, they don't get a warning. They'll still
   // get a warning in the console about CSP blocking the load.
   MixedContentChecker::ReportingStatus mixedContentReporting =
       forPreload ? MixedContentChecker::SuppressReport
                  : MixedContentChecker::SendReport;
   if (MixedContentChecker::shouldBlockFetch(frame(), resourceRequest, url,
                                             mixedContentReporting))
@@ skipping 21 matching lines @@
   // service workers on a per-request basis. Additionally, it is necessary to
   // explicitly return |false| here so that it is clear that the SW will be
   // bypassed. In particular, this is important for
   // ResourceFetcher::getCacheIdentifier(), which will return the SW's cache if
   // the context's isControlledByServiceWorker() returns |true|, and thus will
   // returned cached resources from the service worker. That would have the
   // effect of not bypassing the SW.
   if (getSecurityOrigin() && getSecurityOrigin()->hasSuborigin())
     return false;
 
-  if (m_documentLoader)
+  if (m_documentLoader) {
     return frame()->loader().client()->isControlledByServiceWorker(
         *m_documentLoader);
+  }
   // m_documentLoader is null while loading resources from an HTML import. In
   // such cases whether the request is controlled by ServiceWorker or not is
   // determined by the document loader of the frame.
   return frame()->loader().client()->isControlledByServiceWorker(
       *frame()->loader().documentLoader());
 }
 
 int64_t FrameFetchContext::serviceWorkerID() const {
   DCHECK(m_documentLoader || frame()->loader().documentLoader());
   if (m_documentLoader)
@@ skipping 41 matching lines @@
 }
 
 void FrameFetchContext::sendImagePing(const KURL& url) {
   PingLoader::loadImage(frame(), url);
 }
 
 void FrameFetchContext::addConsoleMessage(const String& message,
                                           LogMessageType messageType) const {
   MessageLevel level = messageType == LogWarningMessage ? WarningMessageLevel
                                                         : ErrorMessageLevel;
-  if (frame()->document())
+  if (frame()->document()) {
     frame()->document()->addConsoleMessage(
         ConsoleMessage::create(JSMessageSource, level, message));
+  }
 }
 
 SecurityOrigin* FrameFetchContext::getSecurityOrigin() const {
   return m_document ? m_document->getSecurityOrigin() : nullptr;
 }
 
 void FrameFetchContext::modifyRequestForCSP(ResourceRequest& resourceRequest) {
   // Record the latest requiredCSP value that will be used when sending this
   // request.
   frame()->loader().recordLatestRequiredCSP();
   frame()->loader().modifyRequestForCSP(resourceRequest, m_document);
 }
 
 void FrameFetchContext::addClientHintsIfNecessary(FetchRequest& fetchRequest) {
   if (!RuntimeEnabledFeatures::clientHintsEnabled() || !m_document)
     return;
 
   bool shouldSendDPR = m_document->clientHintsPreferences().shouldSendDPR() ||
                        fetchRequest.clientHintsPreferences().shouldSendDPR();
   bool shouldSendResourceWidth =
       m_document->clientHintsPreferences().shouldSendResourceWidth() ||
       fetchRequest.clientHintsPreferences().shouldSendResourceWidth();
   bool shouldSendViewportWidth =
       m_document->clientHintsPreferences().shouldSendViewportWidth() ||
       fetchRequest.clientHintsPreferences().shouldSendViewportWidth();
 
-  if (shouldSendDPR)
+  if (shouldSendDPR) {
     fetchRequest.mutableResourceRequest().addHTTPHeaderField(
         "DPR", AtomicString(String::number(m_document->devicePixelRatio())));
+  }
 
   if (shouldSendResourceWidth) {
     FetchRequest::ResourceWidth resourceWidth = fetchRequest.getResourceWidth();
     if (resourceWidth.isSet) {
       float physicalWidth =
           resourceWidth.width * m_document->devicePixelRatio();
       fetchRequest.mutableResourceRequest().addHTTPHeaderField(
           "Width", AtomicString(String::number(ceil(physicalWidth))));
     }
   }
 
-  if (shouldSendViewportWidth && frame()->view())
+  if (shouldSendViewportWidth && frame()->view()) {
     fetchRequest.mutableResourceRequest().addHTTPHeaderField(
         "Viewport-Width",
         AtomicString(String::number(frame()->view()->viewportWidth())));
+  }
 }
 
 void FrameFetchContext::addCSPHeaderIfNecessary(Resource::Type type,
                                                 FetchRequest& fetchRequest) {
   if (!m_document)
     return;
 
   const ContentSecurityPolicy* csp = m_document->contentSecurityPolicy();
   if (csp->shouldSendCSPHeader(type))
     fetchRequest.mutableResourceRequest().addHTTPHeaderField("CSP", "active");
@@ skipping 87 matching lines @@
             response.httpHeaderField(HTTPNames::Accept_CH), fetcher);
     // When response is received with a provisional docloader, the resource
     // haven't committed yet, and we cannot load resources, only preconnect.
     resourceLoadingPolicy = LinkLoader::DoNotLoadResources;
   }
   LinkLoader::loadLinksFromHeader(
       response.httpHeaderField(HTTPNames::Link), response.url(),
       frame()->document(), NetworkHintsInterfaceImpl(), resourceLoadingPolicy,
       LinkLoader::LoadAll, nullptr);
 
-  if (response.hasMajorCertificateErrors())
+  if (response.hasMajorCertificateErrors()) {
     MixedContentChecker::handleCertificateError(frame(), response, frameType,
                                                 requestContext);
+  }
 
   frame()->loader().progress().incrementProgress(identifier, response);
   frame()->loader().client()->dispatchDidReceiveResponse(response);
   TRACE_EVENT_INSTANT1(
       "devtools.timeline", "ResourceReceiveResponse", TRACE_EVENT_SCOPE_THREAD,
       "data",
       InspectorReceiveResponseEvent::data(identifier, frame(), response));
   DocumentLoader* documentLoader = masterDocumentLoader();
   InspectorInstrumentation::didReceiveResourceResponse(
       frame(), identifier, documentLoader, response, resource);
   // It is essential that inspector gets resource response BEFORE console.
   frame()->console().reportResourceResponseReceived(documentLoader, identifier,
                                                     response);
 }
 
 DEFINE_TRACE(FrameFetchContext) {
   visitor->trace(m_document);
   visitor->trace(m_documentLoader);
   FetchContext::trace(visitor);
 }
 
 }  // namespace blink