Add 'get' prefix for Settings.in generated code.

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 153 matching lines @@
 void MixedContentChecker::count(Frame* frame,
                                 WebURLRequest::RequestContext requestContext) {
   UseCounter::count(frame, UseCounter::MixedContentPresent);
 
   // Roll blockable content up into a single counter, count unblocked types
   // individually so we can determine when they can be safely moved to the
   // blockable category:
   WebMixedContent::ContextType contextType =
       WebMixedContent::contextTypeFromRequestContext(
           requestContext,
-          frame->settings()->strictMixedContentCheckingForPlugin());
+          frame->settings()->getStrictMixedContentCheckingForPlugin());
   if (contextType == WebMixedContent::ContextType::Blockable) {
     UseCounter::count(frame, UseCounter::MixedContentBlockable);
     return;
   }
 
   UseCounter::Feature feature;
   switch (requestContext) {
     case WebURLRequest::RequestContextAudio:
       feature = UseCounter::MixedContentAudio;
       break;
@@ skipping 51 matching lines @@
   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();
+                    settings->getStrictMixedContentChecking();
 
   WebMixedContent::ContextType contextType =
       WebMixedContent::contextTypeFromRequestContext(
-          requestContext, settings->strictMixedContentCheckingForPlugin());
+          requestContext, settings->getStrictMixedContentCheckingForPlugin());
 
   // 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, treat frames as passive
   // content.
   //
   // FIXME: Remove this temporary hack once we have a reasonable API for
   // launching external applications via URLs. http://crbug.com/318788 and
   // https://crbug.com/393481
   if (frameType == WebURLRequest::FrameTypeNested &&
@@ skipping 10 matching lines @@
       break;
 
     case WebMixedContent::ContextType::Blockable: {
       // 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() &&
+      if (!settings->getAllowRunningOfInsecureContent() &&
           requestIsSubframeSubresource(effectiveFrame, frameType) &&
           isMixedContent(frame->securityContext()->getSecurityOrigin(), url)) {
         UseCounter::count(mixedFrame,
                           UseCounter::BlockableMixedContentInSubframeBlocked);
         allowed = false;
         break;
       }
 
       bool shouldAskEmbedder =
           !strictMode && settings &&
-          (!settings->strictlyBlockBlockableMixedContent() ||
-           settings->allowRunningOfInsecureContent());
+          (!settings->getStrictlyBlockBlockableMixedContent() ||
+           settings->getAllowRunningOfInsecureContent());
       allowed = shouldAskEmbedder &&
                 client->allowRunningInsecureContent(
-                    settings && settings->allowRunningOfInsecureContent(),
+                    settings && settings->getAllowRunningOfInsecureContent(),
                     securityOrigin, url);
       if (allowed) {
         client->didRunInsecureContent(securityOrigin, url);
         UseCounter::count(mixedFrame, UseCounter::MixedContentBlockableAllowed);
       }
       break;
     }
 
     case WebMixedContent::ContextType::ShouldBeBlockable:
       allowed = !strictMode;
@@ skipping 56 matching lines @@
   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();
+                    settings->getStrictMixedContentChecking();
   if (!strictMode) {
     bool allowedPerSettings =
-        settings && settings->allowRunningOfInsecureContent();
+        settings && settings->getAllowRunningOfInsecureContent();
     allowed = client->allowRunningInsecureContent(allowedPerSettings,
                                                   securityOrigin, url);
   }
 
   if (allowed)
     client->didRunInsecureContent(securityOrigin, url);
 
   if (reportingStatus == SendReport) {
     logToConsoleAboutWebSocket(frame, mainResourceUrlForFrame(mixedFrame), url,
                                allowed);
@@ skipping 80 matching lines @@
     WebURLRequest::RequestContext requestContext) {
   Frame* effectiveFrame = effectiveFrameForFrameType(frame, frameType);
   if (frameType == WebURLRequest::FrameTypeTopLevel || !effectiveFrame)
     return;
 
   // 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();
   bool strictMixedContentCheckingForPlugin =
       effectiveFrame->settings() &&
-      effectiveFrame->settings()->strictMixedContentCheckingForPlugin();
+      effectiveFrame->settings()->getStrictMixedContentCheckingForPlugin();
   WebMixedContent::ContextType contextType =
       WebMixedContent::contextTypeFromRequestContext(
           requestContext, strictMixedContentCheckingForPlugin);
   if (contextType == WebMixedContent::ContextType::Blockable) {
     client->didRunContentWithCertificateErrors(response.url());
   } else {
     // contextTypeFromRequestContext() never returns NotMixedContent (it
     // computes the type of mixed content, given that the content is mixed).
     DCHECK_NE(contextType, WebMixedContent::ContextType::NotMixedContent);
     client->didDisplayContentWithCertificateErrors(response.url());
@@ skipping 14 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 WebMixedContent::ContextType::OptionallyBlockable;
   }
 
   bool strictMixedContentCheckingForPlugin =
       mixedFrame->settings() &&
-      mixedFrame->settings()->strictMixedContentCheckingForPlugin();
+      mixedFrame->settings()->getStrictMixedContentCheckingForPlugin();
   return WebMixedContent::contextTypeFromRequestContext(
       request.requestContext(), strictMixedContentCheckingForPlugin);
 }
 
 }  // namespace blink