blink: Rename modules/ method to prefix with get when they collide.

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 37 matching lines @@
 
 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())
-        return KURL(KURL(), frame->securityContext()->securityOrigin()->toString());
+        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()->securityOrigin();
+    SecurityOrigin* origin = frame->securityContext()->getSecurityOrigin();
     if (MixedContentChecker::isMixedContent(origin, url)) {
         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 13 matching lines @@
 // static
 Frame* MixedContentChecker::inWhichFrameIsContentMixed(Frame* frame, WebURLRequest::FrameType frameType, const KURL& url)
 {
     // We only care about subresource loads; top-level navigations cannot be mixed content. Neither can frameless requests.
     if (frameType == WebURLRequest::FrameTypeTopLevel || !frame)
         return nullptr;
 
     // Check the top frame first.
     if (Frame* top = frame->tree().top()) {
         measureStricterVersionOfIsMixedContent(top, url);
-        if (isMixedContent(top->securityContext()->securityOrigin(), url))
+        if (isMixedContent(top->securityContext()->getSecurityOrigin(), url))
             return top;
     }
 
     measureStricterVersionOfIsMixedContent(frame, url);
-    if (isMixedContent(frame->securityContext()->securityOrigin(), url))
+    if (isMixedContent(frame->securityContext()->getSecurityOrigin(), url))
         return frame;
 
     // No mixed content, no problem.
     return nullptr;
 }
 
 // static
 MixedContentChecker::ContextType MixedContentChecker::contextTypeFromContext(WebURLRequest::RequestContext context, Frame* frame)
 {
     switch (context) {
@@ skipping 194 matching lines @@
     if (!mixedFrame)
         return false;
 
     MixedContentChecker::count(mixedFrame, requestContext);
 
     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()->securityOrigin();
+    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()->shouldEnforceStrictMixedContentChecking() || settings->strictMixedContentChecking();
 
     ContextType contextType = contextTypeFromContext(requestContext, mixedFrame);
 
     // If we're loading the main resource of a subframe, we need to take a close look at the loaded URL.
     // If we're dealing with a CORS-enabled scheme, then block mixed frames as active content. Otherwise,
@@ skipping 13 matching lines @@
 
     case ContextTypeBlockable: {
         // Strictly block subresources that are mixed with respect to
         // their subframes, unless all insecure content is allowed. This
         // is to avoid the following situation: https://a.com embeds
         // https://b.com, which loads a script over insecure HTTP. The
         // user opts to allow the insecure content, thinking that they are
         // allowing an insecure script to run on https://a.com and not
         // realizing that they are in fact allowing an insecure script on
         // https://b.com.
-        if (!settings->allowRunningOfInsecureContent() && requestIsSubframeSubresource(effectiveFrame, frameType) && isMixedContent(frame->securityContext()->securityOrigin(), url)) {
+        if (!settings->allowRunningOfInsecureContent() && requestIsSubframeSubresource(effectiveFrame, frameType) && isMixedContent(frame->securityContext()->getSecurityOrigin(), url)) {
             UseCounter::count(mixedFrame, UseCounter::BlockableMixedContentInSubframeBlocked);
             allowed = false;
             break;
         }
 
         bool shouldAskEmbedder = !strictMode && settings && (!settings->strictlyBlockBlockableMixedContent() || settings->allowRunningOfInsecureContent());
         allowed = shouldAskEmbedder && client->allowRunningInsecureContent(settings && settings->allowRunningOfInsecureContent(), securityOrigin, url);
         if (allowed) {
             client->didRunInsecureContent(securityOrigin, url);
             UseCounter::count(mixedFrame, UseCounter::MixedContentBlockableAllowed);
@@ skipping 35 matching lines @@
         return false;
 
     UseCounter::count(mixedFrame, UseCounter::MixedContentPresent);
     UseCounter::count(mixedFrame, UseCounter::MixedContentWebSocket);
 
     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()->securityOrigin();
+    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()->shouldEnforceStrictMixedContentChecking() || settings->strictMixedContentChecking();
     if (!strictMode) {
         bool allowedPerSettings = settings && settings->allowRunningOfInsecureContent();
         allowed = client->allowRunningInsecureContent(allowedPerSettings, securityOrigin, url);
     }
 
@@ skipping 94 matching lines @@
 
     // See comment in shouldBlockFetch() about loading the main resource of a subframe.
     if (request.frameType() == WebURLRequest::FrameTypeNested && !SchemeRegistry::shouldTreatURLSchemeAsCORSEnabled(request.url().protocol())) {
         return ContextTypeOptionallyBlockable;
     }
 
     return contextTypeFromContext(request.requestContext(), mixedFrame);
 }
 
 } // namespace blink