Loading: bulk style errors fix in core/loader

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

 /*
  * Copyright (C) 2012 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 36 matching lines @@
 
 namespace blink {
 
 namespace {
 
 // When a frame is local, use its full URL to represent the main resource. When
 // the frame is remote, the full URL isn't accessible, so use the origin. This
 // function is used, for example, to determine the URL to show in console
 // messages about mixed content.
 KURL mainResourceUrlForFrame(Frame* frame) {
-  if (frame->isRemoteFrame())
+  if (frame->isRemoteFrame()) {
     return KURL(KURL(),
                 frame->securityContext()->getSecurityOrigin()->toString());
+  }
   return toLocalFrame(frame)->document()->url();
 }
 
 }  // namespace
 
 static void measureStricterVersionOfIsMixedContent(Frame* frame,
                                                    const KURL& url) {
   // We're currently only checking for mixed content in `https://*` contexts.
   // What about other "secure" contexts the SchemeRegistry knows about? We'll
   // use this method to measure the occurance of non-webby mixed content to make
   // sure we're not breaking the world without realizing it.
   SecurityOrigin* origin = frame->securityContext()->getSecurityOrigin();
   if (MixedContentChecker::isMixedContent(origin, url)) {
-    if (origin->protocol() != "https")
+    if (origin->protocol() != "https") {
       UseCounter::count(
           frame,
           UseCounter::MixedContentInNonHTTPSFrameThatRestrictsMixedContent);
+    }
   } else if (!SecurityOrigin::isSecure(url) &&
              SchemeRegistry::shouldTreatURLSchemeAsSecure(origin->protocol())) {
     UseCounter::count(
         frame,
         UseCounter::MixedContentInSecureFrameThatDoesNotRestrictMixedContent);
   }
 }
 
 bool requestIsSubframeSubresource(Frame* frame,
                                   WebURLRequest::FrameType frameType) {
@@ skipping 212 matching lines @@
     case WebMixedContent::ContextType::ShouldBeBlockable:
       allowed = !strictMode;
       if (allowed)
         client->didDisplayInsecureContent();
       break;
     case WebMixedContent::ContextType::NotMixedContent:
       NOTREACHED();
       break;
   };
 
-  if (reportingStatus == SendReport)
+  if (reportingStatus == SendReport) {
     logToConsoleAboutFetch(frame, mainResourceUrlForFrame(mixedFrame), url,
                            requestContext, allowed);
+  }
   return !allowed;
 }
 
 // static
 void MixedContentChecker::logToConsoleAboutWebSocket(
     LocalFrame* frame,
     const KURL& mainResourceUrl,
     const KURL& url,
     bool allowed) {
   String message = String::format(
@@ skipping 16 matching lines @@
     const KURL& url,
     MixedContentChecker::ReportingStatus reportingStatus) {
   Frame* mixedFrame =
       inWhichFrameIsContentMixed(frame, WebURLRequest::FrameTypeNone, url);
   if (!mixedFrame)
     return false;
 
   UseCounter::count(mixedFrame, UseCounter::MixedContentPresent);
   UseCounter::count(mixedFrame, UseCounter::MixedContentWebSocket);
   if (ContentSecurityPolicy* policy =
-          frame->securityContext()->contentSecurityPolicy())
+          frame->securityContext()->contentSecurityPolicy()) {
     policy->reportMixedContent(url,
                                ResourceRequest::RedirectStatus::NoRedirect);
+  }
 
   Settings* settings = mixedFrame->settings();
   // Use the current local frame's client; the embedder doesn't distinguish
   // mixed content signals from different frames on the same page.
   FrameLoaderClient* client = frame->loader().client();
   SecurityOrigin* securityOrigin =
       mixedFrame->securityContext()->getSecurityOrigin();
   bool allowed = false;
 
   // If we're in strict mode, we'll automagically fail everything, and
   // intentionally skip the client checks in order to prevent degrading the
   // site's security UI.
   bool strictMode = mixedFrame->securityContext()->getInsecureRequestPolicy() &
                         kBlockAllMixedContent ||
                     settings->strictMixedContentChecking();
   if (!strictMode) {
     bool allowedPerSettings =
         settings && settings->allowRunningOfInsecureContent();
     allowed = client->allowRunningInsecureContent(allowedPerSettings,
                                                   securityOrigin, url);
   }
 
   if (allowed)
     client->didRunInsecureContent(securityOrigin, url);
 
-  if (reportingStatus == SendReport)
+  if (reportingStatus == SendReport) {
     logToConsoleAboutWebSocket(frame, mainResourceUrlForFrame(mixedFrame), url,
                                allowed);
+  }
   return !allowed;
 }
 
 bool MixedContentChecker::isMixedFormAction(LocalFrame* frame,
                                             const KURL& url,
                                             ReportingStatus reportingStatus) {
   // For whatever reason, some folks handle forms via JavaScript, and submit to
   // `javascript:void(0)` rather than calling `preventDefault()`. We
   // special-case `javascript:` URLs here, as they don't introduce MixedContent
   // for form submissions.
@@ skipping 26 matching lines @@
 }
 
 void MixedContentChecker::checkMixedPrivatePublic(
     LocalFrame* frame,
     const AtomicString& resourceIPAddress) {
   if (!frame || !frame->document() || !frame->document()->loader())
     return;
 
   // Just count these for the moment, don't block them.
   if (NetworkUtils::isReservedIPAddress(resourceIPAddress) &&
-      frame->document()->addressSpace() == WebAddressSpacePublic)
+      frame->document()->addressSpace() == WebAddressSpacePublic) {
     UseCounter::count(frame->document(),
                       UseCounter::MixedContentPrivateHostnameInPublicHostname);
+  }
 }
 
 Frame* MixedContentChecker::effectiveFrameForFrameType(
     LocalFrame* frame,
     WebURLRequest::FrameType frameType) {
   // If we're loading the main resource of a subframe, ensure that we check
   // against the parent of the active frame, rather than the frame itself.
   if (frameType != WebURLRequest::FrameTypeNested)
     return frame;
 
@@ skipping 50 matching lines @@
   }
 
   bool strictMixedContentCheckingForPlugin =
       mixedFrame->settings() &&
       mixedFrame->settings()->strictMixedContentCheckingForPlugin();
   return WebMixedContent::contextTypeFromRequestContext(
       request.requestContext(), strictMixedContentCheckingForPlugin);
 }
 
 }  // namespace blink