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

third_party/WebKit/Source/core/dom/Document.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved.
@@ skipping 2416 matching lines @@
         exceptionState.throwDOMException(InvalidStateError, "Imported document doesn't support open().");
         return;
     }
 
     if (!isHTMLDocument()) {
         exceptionState.throwDOMException(InvalidStateError, "Only HTML documents support open().");
         return;
     }
 
     if (enteredDocument) {
-        if (!securityOrigin()->canAccess(enteredDocument->securityOrigin())) {
+        if (!getSecurityOrigin()->canAccess(enteredDocument->getSecurityOrigin())) {
             exceptionState.throwSecurityError("Can only call open() on same-origin documents.");
             return;
         }
-        setSecurityOrigin(enteredDocument->securityOrigin());
+        setSecurityOrigin(enteredDocument->getSecurityOrigin());
         setURL(enteredDocument->url());
         m_cookieURL = enteredDocument->cookieURL();
     }
 
     open();
 }
 
 void Document::open()
 {
     ASSERT(!importLoader());
@@ skipping 405 matching lines @@
     if (importLoader()) {
         exceptionState.throwDOMException(InvalidStateError, "Imported document doesn't support write().");
         return;
     }
 
     if (!isHTMLDocument()) {
         exceptionState.throwDOMException(InvalidStateError, "Only HTML documents support write().");
         return;
     }
 
-    if (enteredDocument && !securityOrigin()->canAccess(enteredDocument->securityOrigin())) {
+    if (enteredDocument && !getSecurityOrigin()->canAccess(enteredDocument->getSecurityOrigin())) {
         exceptionState.throwSecurityError("Can only call write() on same-origin documents.");
         return;
     }
 
     NestingLevelIncrementer nestingLevelIncrementer(m_writeRecursionDepth);
 
     m_writeRecursionIsTooDeep = (m_writeRecursionDepth > 1) && m_writeRecursionIsTooDeep;
     m_writeRecursionIsTooDeep = (m_writeRecursionDepth > cMaxWriteRecursionDepth) || m_writeRecursionIsTooDeep;
 
     if (m_writeRecursionIsTooDeep)
@@ skipping 293 matching lines @@
     if (!SecurityPolicy::referrerPolicyFromString(policy, &referrerPolicy)) {
         addConsoleMessage(ConsoleMessage::create(RenderingMessageSource, ErrorMessageLevel, "Failed to set referrer policy: The value '" + policy + "' is not one of 'always', 'default', 'never', 'no-referrer', 'no-referrer-when-downgrade', 'origin', 'origin-when-crossorigin', or 'unsafe-url'. This document's referrer policy has been left unchanged."));
         return;
     }
 
     setReferrerPolicy(referrerPolicy);
 }
 
 String Document::outgoingReferrer() const
 {
-    if (securityOrigin()->isUnique()) {
+    if (getSecurityOrigin()->isUnique()) {
         // Return |no-referrer|.
         return String();
     }
 
     // See http://www.whatwg.org/specs/web-apps/current-work/#fetching-resources
     // for why we walk the parent chain for srcdoc documents.
     const Document* referrerDocument = this;
     if (LocalFrame* frame = m_frame) {
         while (frame->document()->isSrcdocDocument()) {
             // Srcdoc documents must be local within the containing frame.
@@ skipping 154 matching lines @@
         return XMLDocument::create(init);
     }
     return create(init);
 }
 
 void Document::cloneDataFromDocument(const Document& other)
 {
     setCompatibilityMode(other.getCompatibilityMode());
     setEncodingData(other.m_encodingData);
     setContextFeatures(other.contextFeatures());
-    setSecurityOrigin(other.securityOrigin()->isolatedCopy());
+    setSecurityOrigin(other.getSecurityOrigin()->isolatedCopy());
     setMimeType(other.contentType());
 }
 
 bool Document::isSecureContextImpl(String* errorMessage, const SecureContextCheck privilegeContextCheck) const
 {
     // There may be exceptions for the secure context check defined for certain
     // schemes. The exceptions are applied only to the special scheme and to
     // sandboxed URLs from those origins, but *not* to any children.
     //
     // For example:
@@ skipping 20 matching lines @@
     //
     // In all cases, a frame must be potentially trustworthy in addition to
     // having an exception listed in order for the exception to be granted.
     if (SecurityContext::isSandboxed(SandboxOrigin)) {
         RefPtr<SecurityOrigin> origin = SecurityOrigin::create(url());
         if (!isOriginPotentiallyTrustworthy(origin.get(), errorMessage))
             return false;
         if (SchemeRegistry::schemeShouldBypassSecureContextCheck(origin->protocol()))
             return true;
     } else {
-        if (!isOriginPotentiallyTrustworthy(securityOrigin(), errorMessage))
+        if (!isOriginPotentiallyTrustworthy(getSecurityOrigin(), errorMessage))
             return false;
-        if (SchemeRegistry::schemeShouldBypassSecureContextCheck(securityOrigin()->protocol()))
+        if (SchemeRegistry::schemeShouldBypassSecureContextCheck(getSecurityOrigin()->protocol()))
             return true;
     }
 
     if (privilegeContextCheck == StandardSecureContextCheck) {
         Document* context = parentDocument();
         while (context) {
             // Skip to the next ancestor if it's a srcdoc.
             if (!context->isSrcdocDocument()) {
                 if (context->securityContext().isSandboxed(SandboxOrigin)) {
                     // For a sandboxed origin, use the document's URL.
                     RefPtr<SecurityOrigin> origin = SecurityOrigin::create(context->url());
                     if (!isOriginPotentiallyTrustworthy(origin.get(), errorMessage))
                         return false;
                 } else {
-                    if (!isOriginPotentiallyTrustworthy(context->securityOrigin(), errorMessage))
+                    if (!isOriginPotentiallyTrustworthy(context->getSecurityOrigin(), errorMessage))
                         return false;
                 }
             }
             context = context->parentDocument();
         }
     }
     return true;
 }
 
 StyleSheetList* Document::styleSheets()
@@ skipping 520 matching lines @@
 }
 
 EventListener* Document::getWindowAttributeEventListener(const AtomicString& eventType)
 {
     LocalDOMWindow* domWindow = this->domWindow();
     if (!domWindow)
         return 0;
     return domWindow->getAttributeEventListener(eventType);
 }
 
-EventQueue* Document::eventQueue() const
+EventQueue* Document::getEventQueue() const
 {
     if (!m_domWindow)
         return 0;
-    return m_domWindow->eventQueue();
+    return m_domWindow->getEventQueue();
 }
 
 void Document::enqueueAnimationFrameEvent(PassRefPtrWillBeRawPtr<Event> event)
 {
     ensureScriptedAnimationController().enqueueEvent(event);
 }
 
 void Document::enqueueUniqueAnimationFrameEvent(PassRefPtrWillBeRawPtr<Event> event)
 {
     ensureScriptedAnimationController().enqueuePerFrameEvent(event);
@@ skipping 120 matching lines @@
 
 String Document::cookie(ExceptionState& exceptionState) const
 {
     if (settings() && !settings()->cookieEnabled())
         return String();
 
     // FIXME: The HTML5 DOM spec states that this attribute can raise an
     // InvalidStateError exception on getting if the Document has no
     // browsing context.
 
-    if (!securityOrigin()->canAccessCookies()) {
+    if (!getSecurityOrigin()->canAccessCookies()) {
         if (isSandboxed(SandboxOrigin))
             exceptionState.throwSecurityError("The document is sandboxed and lacks the 'allow-same-origin' flag.");
         else if (url().protocolIs("data"))
             exceptionState.throwSecurityError("Cookies are disabled inside 'data:' URLs.");
         else
             exceptionState.throwSecurityError("Access is denied for this document.");
         return String();
     }
 
     KURL cookieURL = this->cookieURL();
     if (cookieURL.isEmpty())
         return String();
 
     return cookies(this, cookieURL);
 }
 
 void Document::setCookie(const String& value, ExceptionState& exceptionState)
 {
     if (settings() && !settings()->cookieEnabled())
         return;
 
     // FIXME: The HTML5 DOM spec states that this attribute can raise an
     // InvalidStateError exception on setting if the Document has no
     // browsing context.
 
-    if (!securityOrigin()->canAccessCookies()) {
+    if (!getSecurityOrigin()->canAccessCookies()) {
         if (isSandboxed(SandboxOrigin))
             exceptionState.throwSecurityError("The document is sandboxed and lacks the 'allow-same-origin' flag.");
         else if (url().protocolIs("data"))
             exceptionState.throwSecurityError("Cookies are disabled inside 'data:' URLs.");
         else
             exceptionState.throwSecurityError("Access is denied for this document.");
         return;
     }
 
     KURL cookieURL = this->cookieURL();
     if (cookieURL.isEmpty())
         return;
 
     setCookies(this, cookieURL, value);
 }
 
 const AtomicString& Document::referrer() const
 {
     if (loader())
         return loader()->request().httpReferrer();
     return nullAtom;
 }
 
 String Document::domain() const
 {
-    return securityOrigin()->domain();
+    return getSecurityOrigin()->domain();
 }
 
 void Document::setDomain(const String& newDomain, ExceptionState& exceptionState)
 {
     UseCounter::count(*this, UseCounter::DocumentSetDomain);
 
     if (isSandboxed(SandboxDocumentDomain)) {
         exceptionState.throwSecurityError("Assignment is forbidden for sandboxed iframes.");
         return;
     }
 
-    if (SchemeRegistry::isDomainRelaxationForbiddenForURLScheme(securityOrigin()->protocol())) {
-        exceptionState.throwSecurityError("Assignment is forbidden for the '" + securityOrigin()->protocol() + "' scheme.");
+    if (SchemeRegistry::isDomainRelaxationForbiddenForURLScheme(getSecurityOrigin()->protocol())) {
+        exceptionState.throwSecurityError("Assignment is forbidden for the '" + getSecurityOrigin()->protocol() + "' scheme.");
         return;
     }
 
     if (newDomain.isEmpty()) {
         exceptionState.throwSecurityError("'" + newDomain + "' is an empty domain.");
         return;
     }
 
-    OriginAccessEntry accessEntry(securityOrigin()->protocol(), newDomain, OriginAccessEntry::AllowSubdomains);
-    OriginAccessEntry::MatchResult result = accessEntry.matchesOrigin(*securityOrigin());
+    OriginAccessEntry accessEntry(getSecurityOrigin()->protocol(), newDomain, OriginAccessEntry::AllowSubdomains);
+    OriginAccessEntry::MatchResult result = accessEntry.matchesOrigin(*getSecurityOrigin());
     if (result == OriginAccessEntry::DoesNotMatchOrigin) {
         exceptionState.throwSecurityError("'" + newDomain + "' is not a suffix of '" + domain() + "'.");
         return;
     }
 
     if (result == OriginAccessEntry::MatchesOriginButIsPublicSuffix) {
         exceptionState.throwSecurityError("'" + newDomain + "' is a top-level domain.");
         return;
     }
 
-    securityOrigin()->setDomainFromDOM(newDomain);
+    getSecurityOrigin()->setDomainFromDOM(newDomain);
     if (m_frame)
-        m_frame->script().updateSecurityOrigin(securityOrigin());
+        m_frame->script().updateSecurityOrigin(getSecurityOrigin());
 }
 
 // http://www.whatwg.org/specs/web-apps/current-work/#dom-document-lastmodified
 String Document::lastModified() const
 {
     DateComponents date;
     bool foundDate = false;
     if (m_frame) {
         if (DocumentLoader* documentLoader = loader()) {
             const AtomicString& httpLastModified = documentLoader->response().httpHeaderField(HTTPNames::Last_Modified);
@@ skipping 22 matching lines @@
     const OriginAccessEntry& accessEntry = topDocument().accessEntryFromURL();
     const Document* currentDocument = this;
     while (currentDocument) {
         // Skip over srcdoc documents, as they are always same-origin with their closest non-srcdoc parent.
         while (currentDocument->isSrcdocDocument())
             currentDocument = currentDocument->parentDocument();
         ASSERT(currentDocument);
 
         // We use 'matchesDomain' here, as it turns out that some folks embed HTTPS login forms
         // into HTTP pages; we should allow this kind of upgrade.
-        if (accessEntry.matchesDomain(*currentDocument->securityOrigin()) == OriginAccessEntry::DoesNotMatchOrigin)
+        if (accessEntry.matchesDomain(*currentDocument->getSecurityOrigin()) == OriginAccessEntry::DoesNotMatchOrigin)
             return SecurityOrigin::urlWithUniqueSecurityOrigin();
 
         currentDocument = currentDocument->parentDocument();
     }
 
     return topDocument().url();
 }
 
 static bool isValidNameNonASCII(const LChar* characters, unsigned length)
 {
@@ skipping 667 matching lines @@
     m_frame->selection().updateSecureKeyboardEntryIfActive();
 }
 
 bool Document::useSecureKeyboardEntryWhenActive() const
 {
     return m_useSecureKeyboardEntryWhenActive;
 }
 
 void Document::initSecurityContext(const DocumentInit& initializer)
 {
-    ASSERT(!securityOrigin());
+    ASSERT(!getSecurityOrigin());
 
     if (!initializer.hasSecurityContext()) {
         // No source for a security context.
         // This can occur via document.implementation.createDocument().
         m_cookieURL = KURL(ParsedURLString, emptyString());
         setSecurityOrigin(SecurityOrigin::createUnique());
         initContentSecurityPolicy();
         // Unique security origins cannot have a suborigin
         return;
     }
 
     // In the common case, create the security context from the currently
     // loading URL with a fresh content security policy.
     enforceSandboxFlags(initializer.getSandboxFlags());
     if (initializer.shouldEnforceStrictMixedContentChecking())
         enforceStrictMixedContentChecking();
     setInsecureRequestsPolicy(initializer.getInsecureRequestsPolicy());
     if (initializer.insecureNavigationsToUpgrade()) {
         for (auto toUpgrade : *initializer.insecureNavigationsToUpgrade())
             addInsecureNavigationUpgrade(toUpgrade);
     }
 
     if (isSandboxed(SandboxOrigin)) {
         m_cookieURL = m_url;
         setSecurityOrigin(SecurityOrigin::createUnique());
         // If we're supposed to inherit our security origin from our owner,
         // but we're also sandboxed, the only thing we inherit is the ability
         // to load local resources. This lets about:blank iframes in file://
         // URL documents load images and other resources from the file system.
-        if (initializer.owner() && initializer.owner()->securityOrigin()->canLoadLocalResources())
-            securityOrigin()->grantLoadLocalResources();
+        if (initializer.owner() && initializer.owner()->getSecurityOrigin()->canLoadLocalResources())
+            getSecurityOrigin()->grantLoadLocalResources();
     } else if (initializer.owner()) {
         m_cookieURL = initializer.owner()->cookieURL();
         // We alias the SecurityOrigins to match Firefox, see Bug 15313
         // https://bugs.webkit.org/show_bug.cgi?id=15313
-        setSecurityOrigin(initializer.owner()->securityOrigin());
+        setSecurityOrigin(initializer.owner()->getSecurityOrigin());
     } else {
         m_cookieURL = m_url;
         setSecurityOrigin(SecurityOrigin::create(m_url));
     }
 
     // Set the address space before setting up CSP, as the latter may override
     // the former via the 'treat-as-public-address' directive (see
     // https://mikewest.github.io/cors-rfc1918/#csp).
     if (initializer.isHostedInReservedIPRange()) {
-        setAddressSpace(securityOrigin()->isLocalhost() ? WebAddressSpaceLocal : WebAddressSpacePrivate);
+        setAddressSpace(getSecurityOrigin()->isLocalhost() ? WebAddressSpaceLocal : WebAddressSpacePrivate);
     } else {
         setAddressSpace(WebAddressSpacePublic);
     }
 
     if (importsController()) {
         // If this document is an HTML import, grab a reference to it's master document's Content
         // Security Policy. We don't call 'initContentSecurityPolicy' in this case, as we can't
         // rebind the master document's policy object: its ExecutionContext needs to remain tied
         // to the master document.
         setContentSecurityPolicy(importsController()->master()->contentSecurityPolicy());
     } else {
         initContentSecurityPolicy();
     }
 
-    if (securityOrigin()->hasSuborigin())
-        enforceSuborigin(securityOrigin()->suboriginName());
+    if (getSecurityOrigin()->hasSuborigin())
+        enforceSuborigin(getSecurityOrigin()->suboriginName());
 
     if (Settings* settings = initializer.settings()) {
         if (!settings->webSecurityEnabled()) {
             // Web security is turned off. We should let this document access every other document. This is used primary by testing
             // harnesses for web sites.
-            securityOrigin()->grantUniversalAccess();
-        } else if (securityOrigin()->isLocal()) {
+            getSecurityOrigin()->grantUniversalAccess();
+        } else if (getSecurityOrigin()->isLocal()) {
             if (settings->allowUniversalAccessFromFileURLs()) {
                 // Some clients want local URLs to have universal access, but that setting is dangerous for other clients.
-                securityOrigin()->grantUniversalAccess();
+                getSecurityOrigin()->grantUniversalAccess();
             } else if (!settings->allowFileAccessFromFileURLs()) {
                 // Some clients do not want local URLs to have access to other local URLs.
-                securityOrigin()->blockLocalAccessFromLocalOrigin();
+                getSecurityOrigin()->blockLocalAccessFromLocalOrigin();
             }
         }
     }
 
     if (initializer.shouldTreatURLAsSrcdocDocument()) {
         m_isSrcdocDocument = true;
         setBaseURLOverride(initializer.parentBaseURL());
     }
 
-    if (securityOrigin()->hasSuborigin())
-        enforceSuborigin(securityOrigin()->suboriginName());
+    if (getSecurityOrigin()->hasSuborigin())
+        enforceSuborigin(getSecurityOrigin()->suboriginName());
 }
 
 void Document::initContentSecurityPolicy(PassRefPtrWillBeRawPtr<ContentSecurityPolicy> csp)
 {
     setContentSecurityPolicy(csp ? csp : ContentSecurityPolicy::create());
     if (m_frame && m_frame->tree().parent() && m_frame->tree().parent()->isLocalFrame()) {
         ContentSecurityPolicy* parentCSP = toLocalFrame(m_frame->tree().parent())->document()->contentSecurityPolicy();
         if (shouldInheritSecurityOriginFromOwner(m_url)) {
             contentSecurityPolicy()->copyStateFrom(parentCSP);
         } else if (isPluginDocument()) {
             // Per CSP2, plugin-types for plugin documents in nested browsing
             // contexts gets inherited from the parent.
             contentSecurityPolicy()->copyPluginTypesFrom(parentCSP);
         }
     }
     contentSecurityPolicy()->bindToExecutionContext(this);
 }
 
 bool Document::isSecureTransitionTo(const KURL& url) const
 {
     RefPtr<SecurityOrigin> other = SecurityOrigin::create(url);
-    return securityOrigin()->canAccess(other.get());
+    return getSecurityOrigin()->canAccess(other.get());
 }
 
 bool Document::allowInlineEventHandlers(Node* node, EventListener* listener, const String& contextURL, const WTF::OrdinalNumber& contextLine)
 {
     bool allowedByHash = contentSecurityPolicy()->experimentalFeaturesEnabled() && contentSecurityPolicy()->allowScriptWithHash(listener->code());
     if (!ContentSecurityPolicy::shouldBypassMainWorld(this) && !allowedByHash && !contentSecurityPolicy()->allowInlineEventHandlers(contextURL, contextLine))
         return false;
 
     // HTML says that inline script needs browsing context to create its execution environment.
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/webappapis.html#event-handler-attributes
@@ skipping 28 matching lines @@
 void Document::updateSecurityOrigin(PassRefPtr<SecurityOrigin> origin)
 {
     setSecurityOrigin(origin);
     didUpdateSecurityOrigin();
 }
 
 void Document::didUpdateSecurityOrigin()
 {
     if (!m_frame)
         return;
-    m_frame->updateSecurityOrigin(securityOrigin());
+    m_frame->updateSecurityOrigin(getSecurityOrigin());
 }
 
 bool Document::isContextThread() const
 {
     return isMainThread();
 }
 
 void Document::updateFocusAppearanceSoon(SelectionBehaviorOnFocus selectionbehavioronfocus)
 {
     m_updateFocusAppearanceSelectionBahavior = selectionbehavioronfocus;
@@ skipping 27 matching lines @@
     // We don't ASSERT m_ranges.contains(range) to allow us to call this
     // unconditionally to fix: https://bugs.webkit.org/show_bug.cgi?id=26044
     m_ranges.remove(range);
 }
 
 void Document::initDNSPrefetch()
 {
     Settings* settings = this->settings();
 
     m_haveExplicitlyDisabledDNSPrefetch = false;
-    m_isDNSPrefetchEnabled = settings && settings->dnsPrefetchingEnabled() && securityOrigin()->protocol() == "http";
+    m_isDNSPrefetchEnabled = settings && settings->dnsPrefetchingEnabled() && getSecurityOrigin()->protocol() == "http";
 
     // Inherit DNS prefetch opt-out from parent frame
     if (Document* parent = parentDocument()) {
         if (!parent->isDNSPrefetchEnabled())
             m_isDNSPrefetchEnabled = false;
     }
 }
 
 void Document::parseDNSPrefetchControlHeader(const String& dnsPrefetchControl)
 {
@@ skipping 42 matching lines @@
 void Document::addConsoleMessage(PassRefPtrWillBeRawPtr<ConsoleMessage> consoleMessage)
 {
     if (!isContextThread()) {
         m_taskRunner->postTask(BLINK_FROM_HERE, AddConsoleMessageTask::create(consoleMessage->source(), consoleMessage->level(), consoleMessage->message()));
         return;
     }
 
     if (!m_frame)
         return;
 
-    if (!consoleMessage->scriptState() && consoleMessage->url().isNull() && !consoleMessage->lineNumber()) {
+    if (!consoleMessage->getScriptState() && consoleMessage->url().isNull() && !consoleMessage->lineNumber()) {
         consoleMessage->setURL(url().getString());
         if (!isInDocumentWrite() && scriptableDocumentParser()) {
             ScriptableDocumentParser* parser = scriptableDocumentParser();
             if (parser->isParsingAtLineNumber())
                 consoleMessage->setLineNumber(parser->lineNumber().oneBasedInt());
         }
     }
     m_frame->console().addMessage(consoleMessage);
 }
 
@@ skipping 798 matching lines @@
 #ifndef NDEBUG
 using namespace blink;
 void showLiveDocumentInstances()
 {
     Document::WeakDocumentSet& set = Document::liveDocumentSet();
     fprintf(stderr, "There are %u documents currently alive:\n", set.size());
     for (Document* document : set)
         fprintf(stderr, "- Document %p URL: %s\n", document, document->url().getString().utf8().data());
 }
 #endif