Prepare to replicate sandbox flags for OOPIF

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 "config.h"
 #include "web/WebRemoteFrameImpl.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/RemoteFrame.h"
 #include "core/frame/Settings.h"
@@ skipping 13 matching lines @@
 namespace {
 
 // Helper class to bridge communication for a local frame with a remote parent.
 // Currently, it serves two purposes:
 // 1. Allows the local frame's loader to retrieve sandbox flags associated with
 //    its owner element in another process.
 // 2. Trigger a load event on its owner element once it finishes a load.
 class RemoteBridgeFrameOwner : public NoBaseWillBeGarbageCollectedFinalized<RemoteBridgeFrameOwner>, public FrameOwner {
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(RemoteBridgeFrameOwner);
 public:
-    static PassOwnPtrWillBeRawPtr<RemoteBridgeFrameOwner> create(PassRefPtrWillBeRawPtr<WebLocalFrameImpl> frame)
+    static PassOwnPtrWillBeRawPtr<RemoteBridgeFrameOwner> create(PassRefPtrWillBeRawPtr<WebLocalFrameImpl> frame, SandboxFlags flags)
     {
-        return adoptPtrWillBeNoop(new RemoteBridgeFrameOwner(frame));
+        return adoptPtrWillBeNoop(new RemoteBridgeFrameOwner(frame, flags));
     }
 
-    virtual bool isLocal() const override;
-    virtual SandboxFlags sandboxFlags() const override;
+    virtual bool isLocal() const override
+    {
+        return false;
+    }
+
+    virtual SandboxFlags sandboxFlags() const override
+    {
+        return m_sandboxFlags;
+    }
+
+    void setSandboxFlags(SandboxFlags flags)
+    {
+        m_sandboxFlags = flags;
+    }
+
     virtual void dispatchLoad() override;
 
     virtual void trace(Visitor*);
 
 private:
-    explicit RemoteBridgeFrameOwner(PassRefPtrWillBeRawPtr<WebLocalFrameImpl>);
+    explicit RemoteBridgeFrameOwner(PassRefPtrWillBeRawPtr<WebLocalFrameImpl>, SandboxFlags);
 
     RefPtrWillBeMember<WebLocalFrameImpl> m_frame;
+    SandboxFlags m_sandboxFlags;
 };
 
-RemoteBridgeFrameOwner::RemoteBridgeFrameOwner(PassRefPtrWillBeRawPtr<WebLocalFrameImpl> frame)
+RemoteBridgeFrameOwner::RemoteBridgeFrameOwner(PassRefPtrWillBeRawPtr<WebLocalFrameImpl> frame, SandboxFlags flags)
     : m_frame(frame)
+    , m_sandboxFlags(flags)
 {
 }
 
 void RemoteBridgeFrameOwner::trace(Visitor* visitor)
 {
     visitor->trace(m_frame);
     FrameOwner::trace(visitor);
 }
 
-bool RemoteBridgeFrameOwner::isLocal() const
-{
-    return false;
-}
-
-SandboxFlags RemoteBridgeFrameOwner::sandboxFlags() const
-{
-    // FIXME: Implement. Most likely grab it from m_frame.
-    return 0;
-}
-
 void RemoteBridgeFrameOwner::dispatchLoad()
 {
     // FIXME: Implement. Most likely goes through m_frame->client().
 }
 
 } // namespace
 
 bool PlaceholderFrameOwner::isLocal() const
 {
     return false;
@@ skipping 704 matching lines @@
     ASSERT_NOT_REACHED();
     return false;
 }
 
 WebString WebRemoteFrameImpl::layerTreeAsText(bool showDebugInfo) const
 {
     ASSERT_NOT_REACHED();
     return WebString();
 }
 
+// FIXME(alexmos): This will go away once the Chromium side is updated to pass sandbox flags.
 WebLocalFrame* WebRemoteFrameImpl::createLocalChild(const WebString& name, WebFrameClient* client)
 {
+    return createLocalChild(name, WebSandboxFlags::None, client);
+}
+
+WebLocalFrame* WebRemoteFrameImpl::createLocalChild(const WebString& name, WebSandboxFlags sandboxFlags, WebFrameClient* client)
+{
     WebLocalFrameImpl* child = toWebLocalFrameImpl(WebLocalFrame::create(client));
-    WillBeHeapHashMap<WebFrame*, OwnPtrWillBeMember<FrameOwner>>::AddResult result =
-        m_ownersForChildren.add(child, RemoteBridgeFrameOwner::create(child));
+    WillBeHeapHashMap<WebFrame*, OwnPtrWillBeMember<FrameOwner> >::AddResult result =
+        m_ownersForChildren.add(child, RemoteBridgeFrameOwner::create(child, static_cast<SandboxFlags>(sandboxFlags)));
     appendChild(child);
     // 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(), result.storedValue->value.get(), name, nullAtom);
     // 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...
     ASSERT(child->frame());
     return child;
@@ skipping 35 matching lines @@
         localFrameImpl->frame()->view()->frameRect(),
         localFrameImpl->frame()->view()->visibleContentScaleFactor());
 }
 
 void WebRemoteFrameImpl::setReplicatedOrigin(const WebSecurityOrigin& origin) const
 {
     ASSERT(frame());
     frame()->securityContext()->setReplicatedOrigin(origin);
 }
 
+void WebRemoteFrameImpl::setReplicatedSandboxFlags(WebSandboxFlags flags) const
+{
+    ASSERT(frame());
+    frame()->securityContext()->enforceSandboxFlags(static_cast<SandboxFlags>(flags));
+}
+
 void WebRemoteFrameImpl::didStartLoading()
 {
     frame()->setIsLoading(true);
 }
 
 void WebRemoteFrameImpl::didStopLoading()
 {
     frame()->setIsLoading(false);
     if (parent() && parent()->isWebLocalFrame()) {
         WebLocalFrameImpl* parentFrame =
             toWebLocalFrameImpl(parent()->toWebLocalFrame());
         parentFrame->frame()->loader().checkCompleted();
     }
 }
 
 } // namespace blink