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 22 matching lines @@
 public:
     static PassOwnPtrWillBeRawPtr<RemoteBridgeFrameOwner> create(PassRefPtrWillBeRawPtr<WebLocalFrameImpl> frame)
     {
         return adoptPtrWillBeNoop(new RemoteBridgeFrameOwner(frame));
     }
 
     virtual bool isLocal() const override;
     virtual SandboxFlags sandboxFlags() const override;
     virtual void dispatchLoad() override;
 
+    void setSandboxFlags(SandboxFlags);
+
     virtual void trace(Visitor*);
 
 private:
     explicit RemoteBridgeFrameOwner(PassRefPtrWillBeRawPtr<WebLocalFrameImpl>);
 
     RefPtrWillBeMember<WebLocalFrameImpl> m_frame;
+    SandboxFlags m_sandboxFlags;

[dcheng, 2015/01/09 22:46:12]

Since this can't change after creation, let's mark this const and initialize it
in the constructor.

[alexmos, 2015/01/09 23:12:30]

As we just discussed, the flags are mutable, with updates taking effect on next
navigation, so we may need to update them after creation.  I'm planning to add
the plumbing to handle dynamic updates in a later CL.

 };
 
 RemoteBridgeFrameOwner::RemoteBridgeFrameOwner(PassRefPtrWillBeRawPtr<WebLocalFrameImpl> frame)
     : m_frame(frame)
+    , m_sandboxFlags(0)
 {
 }
 
 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;
+    return m_sandboxFlags;
+}
+
+void RemoteBridgeFrameOwner::setSandboxFlags(SandboxFlags flags)
+{
+    m_sandboxFlags = flags;

[dcheng, 2015/01/10 00:01:00]

Nit: just inline this into the declaration.

[alexmos, 2015/01/10 00:51:54]

Done.  Inlined setSandboxFlags(), sandboxFlags(), and isLocal().

 }
 
 void RemoteBridgeFrameOwner::dispatchLoad()
 {
     // FIXME: Implement. Most likely goes through m_frame->client().
 }
 
 } // namespace
 
 bool PlaceholderFrameOwner::isLocal() const
@@ skipping 706 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));
+    OwnPtrWillBeRawPtr<RemoteBridgeFrameOwner> owner = RemoteBridgeFrameOwner::create(child);

[dcheng, 2015/01/10 00:01:00]

Nit: it's probably still nicer to pass this in the constructor, since we have to
initialize it anyway.

[alexmos, 2015/01/10 00:51:54]

Done.

+    owner->setSandboxFlags(static_cast<SandboxFlags>(sandboxFlags));
+    WillBeHeapHashMap<WebFrame*, OwnPtrWillBeMember<FrameOwner>>::AddResult result = m_ownersForChildren.add(child, owner.release());
     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