Move unique name generation and tracking into //content.

third_party/WebKit/Source/web/WebRemoteFrameImpl.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "web/WebRemoteFrameImpl.h"
 
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/WindowProxy.h"
 #include "core/dom/Fullscreen.h"
 #include "core/dom/RemoteSecurityContext.h"
@@ skipping 61 matching lines @@
 WebRemoteFrame* WebRemoteFrameImpl::toWebRemoteFrame() {
   return this;
 }
 
 void WebRemoteFrameImpl::close() {
   WebRemoteFrame::close();
 
   m_selfKeepAlive.clear();
 }
 
-WebString WebRemoteFrameImpl::uniqueName() const {
-  NOTREACHED();
-  return WebString();
-}
-
 WebString WebRemoteFrameImpl::assignedName() const {
   NOTREACHED();
   return WebString();
 }
 
 void WebRemoteFrameImpl::setName(const WebString&) {
   NOTREACHED();
 }
 
 WebVector<WebIconURL> WebRemoteFrameImpl::iconURLs(int iconTypesMask) const {
@@ skipping 221 matching lines @@
 }
 
 WebString WebRemoteFrameImpl::layerTreeAsText(bool showDebugInfo) const {
   NOTREACHED();
   return WebString();
 }
 
 WebLocalFrame* WebRemoteFrameImpl::createLocalChild(
     WebTreeScopeType scope,
     const WebString& name,
-    const WebString& uniqueName,
     WebSandboxFlags sandboxFlags,
     WebFrameClient* client,
     blink::InterfaceProvider* interfaceProvider,
     blink::InterfaceRegistry* interfaceRegistry,
     WebFrame* previousSibling,
     const WebFrameOwnerProperties& frameOwnerProperties,
     WebFrame* opener) {
   WebLocalFrameImpl* child = WebLocalFrameImpl::create(
       scope, client, interfaceProvider, interfaceRegistry, opener);
   insertAfter(child, previousSibling);
   RemoteFrameOwner* owner = RemoteFrameOwner::create(
       static_cast<SandboxFlags>(sandboxFlags), frameOwnerProperties);
   // FIXME: currently this calls LocalFrame::init() on the created LocalFrame,
   // which may result in the browser observing two navigations to about:blank
   // (one from the initial frame creation, and one from swapping it into the
   // remote process).  FrameLoader might need a special initialization function
   // for this case to avoid that duplicate navigation.
-  child->initializeCoreFrame(frame()->host(), owner, name, uniqueName);
+  child->initializeCoreFrame(frame()->host(), owner, name);
   // Partially related with the above FIXME--the init() call may trigger JS
   // dispatch. However,
   // if the parent is remote, it should never be detached synchronously...
   DCHECK(child->frame());
   return child;
 }
 
 void WebRemoteFrameImpl::initializeCoreFrame(FrameHost* host,
                                              FrameOwner* owner,
-                                             const AtomicString& name,
-                                             const AtomicString& uniqueName) {
+                                             const AtomicString& name) {
   setCoreFrame(RemoteFrame::create(m_frameClient.get(),
                                    host ? &host->page() : nullptr, owner));
   frame()->createView();
-  m_frame->tree().setPrecalculatedName(name, uniqueName);
+  m_frame->tree().setName(name);
 }
 
 WebRemoteFrame* WebRemoteFrameImpl::createRemoteChild(
     WebTreeScopeType scope,
     const WebString& name,
-    const WebString& uniqueName,
     WebSandboxFlags sandboxFlags,
     WebRemoteFrameClient* client,
     WebFrame* opener) {
   WebRemoteFrameImpl* child = WebRemoteFrameImpl::create(scope, client, opener);
   appendChild(child);
   RemoteFrameOwner* owner = RemoteFrameOwner::create(
       static_cast<SandboxFlags>(sandboxFlags), WebFrameOwnerProperties());
-  child->initializeCoreFrame(frame()->host(), owner, name, uniqueName);
+  child->initializeCoreFrame(frame()->host(), owner, name);
   return child;
 }
 
 void WebRemoteFrameImpl::setWebLayer(WebLayer* layer) {
   if (!frame())
     return;
 
   frame()->setWebLayer(layer);
 }
 
 void WebRemoteFrameImpl::setCoreFrame(RemoteFrame* frame) {
   m_frame = frame;
 }
 
 WebRemoteFrameImpl* WebRemoteFrameImpl::fromFrame(RemoteFrame& frame) {
   if (!frame.client())
     return nullptr;
   return static_cast<RemoteFrameClientImpl*>(frame.client())->webFrame();
 }
 
-void WebRemoteFrameImpl::setReplicatedOrigin(
-    const WebSecurityOrigin& origin) const {
+void WebRemoteFrameImpl::setReplicatedOrigin(const WebSecurityOrigin& origin) {
   DCHECK(frame());
   frame()->securityContext()->setReplicatedOrigin(origin);
 
   // If the origin of a remote frame changed, the accessibility object for the
   // owner element now points to a different child.
   //
   // TODO(dmazzoni, dcheng): there's probably a better way to solve this.
   // Run SitePerProcessAccessibilityBrowserTest.TwoCrossSiteNavigations to
   // ensure an alternate fix works.  http://crbug.com/566222
   FrameOwner* owner = frame()->owner();
   if (owner && owner->isLocal()) {
     HTMLElement* ownerElement = toHTMLFrameOwnerElement(owner);
     AXObjectCache* cache = ownerElement->document().existingAXObjectCache();
     if (cache)
       cache->childrenChanged(ownerElement);
   }
 }
 
-void WebRemoteFrameImpl::setReplicatedSandboxFlags(
-    WebSandboxFlags flags) const {
+void WebRemoteFrameImpl::setReplicatedSandboxFlags(WebSandboxFlags flags) {
   DCHECK(frame());
   frame()->securityContext()->enforceSandboxFlags(
       static_cast<SandboxFlags>(flags));
 }
 
-void WebRemoteFrameImpl::setReplicatedName(const WebString& name,
-                                           const WebString& uniqueName) const {
+void WebRemoteFrameImpl::setReplicatedName(const WebString& name) {
   DCHECK(frame());
-  frame()->tree().setPrecalculatedName(name, uniqueName);
+  frame()->tree().setName(name);
 }
 
 void WebRemoteFrameImpl::setReplicatedFeaturePolicyHeader(
-    const WebParsedFeaturePolicy& parsedHeader) const {
+    const WebParsedFeaturePolicy& parsedHeader) {
   if (RuntimeEnabledFeatures::featurePolicyEnabled()) {
     WebFeaturePolicy* parentFeaturePolicy = nullptr;
     if (parent()) {
       Frame* parentFrame = frame()->client()->parent();
       parentFeaturePolicy = parentFrame->securityContext()->getFeaturePolicy();
     }
     WebParsedFeaturePolicy containerPolicy;
     if (frame() && frame()->owner()) {
       containerPolicy = getContainerPolicyFromAllowedFeatures(
           frame()->owner()->allowedFeatures(),
           frame()->securityContext()->getSecurityOrigin());
     }
     frame()->securityContext()->initializeFeaturePolicy(
         parsedHeader, containerPolicy, parentFeaturePolicy);
   }
 }
 
 void WebRemoteFrameImpl::addReplicatedContentSecurityPolicyHeader(
     const WebString& headerValue,
     WebContentSecurityPolicyType type,
-    WebContentSecurityPolicySource source) const {
+    WebContentSecurityPolicySource source) {
   frame()->securityContext()->contentSecurityPolicy()->addPolicyFromHeaderValue(
       headerValue, static_cast<ContentSecurityPolicyHeaderType>(type),
       static_cast<ContentSecurityPolicyHeaderSource>(source));
 }
 
-void WebRemoteFrameImpl::resetReplicatedContentSecurityPolicy() const {
+void WebRemoteFrameImpl::resetReplicatedContentSecurityPolicy() {
   frame()->securityContext()->resetReplicatedContentSecurityPolicy();
 }
 
 void WebRemoteFrameImpl::setReplicatedInsecureRequestPolicy(
-    WebInsecureRequestPolicy policy) const {
+    WebInsecureRequestPolicy policy) {
   DCHECK(frame());
   frame()->securityContext()->setInsecureRequestPolicy(policy);
 }
 
 void WebRemoteFrameImpl::setReplicatedPotentiallyTrustworthyUniqueOrigin(
-    bool isUniqueOriginPotentiallyTrustworthy) const {
+    bool isUniqueOriginPotentiallyTrustworthy) {
   DCHECK(frame());
   // If |isUniqueOriginPotentiallyTrustworthy| is true, then the origin must be
   // unique.
   DCHECK(!isUniqueOriginPotentiallyTrustworthy ||
          frame()->securityContext()->getSecurityOrigin()->isUnique());
   frame()
       ->securityContext()
       ->getSecurityOrigin()
       ->setUniqueOriginIsPotentiallyTrustworthy(
           isUniqueOriginPotentiallyTrustworthy);
 }
 
-void WebRemoteFrameImpl::dispatchLoadEventOnFrameOwner() const {
+void WebRemoteFrameImpl::dispatchLoadEventOnFrameOwner() {
   DCHECK(frame()->owner()->isLocal());
   frame()->owner()->dispatchLoad();
 }
 
 void WebRemoteFrameImpl::didStartLoading() {
   frame()->setIsLoading(true);
 }
 
 void WebRemoteFrameImpl::didStopLoading() {
   frame()->setIsLoading(false);
@@ skipping 48 matching lines @@
 }
 
 WebRemoteFrameImpl::WebRemoteFrameImpl(WebTreeScopeType scope,
                                        WebRemoteFrameClient* client)
     : WebRemoteFrame(scope),
       m_frameClient(RemoteFrameClientImpl::create(this)),
       m_client(client),
       m_selfKeepAlive(this) {}
 
 }  // namespace blink