Replicate sandbox flags for OOPIF (Blink part 2)

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 23 matching lines @@
     static PassOwnPtrWillBeRawPtr<RemoteBridgeFrameOwner> create(PassRefPtrWillBeRawPtr<WebLocalFrameImpl> frame, SandboxFlags flags)
     {
         return adoptPtrWillBeNoop(new RemoteBridgeFrameOwner(frame, flags));
     }
 
     virtual bool isLocal() const override
     {
         return false;
     }
 
-    virtual SandboxFlags sandboxFlags() const override
-    {
-        return m_sandboxFlags;
-    }
+    virtual SandboxFlags sandboxFlags() const override;
 
     void setSandboxFlags(SandboxFlags flags)
     {
         m_sandboxFlags = flags;
     }
 
     virtual void dispatchLoad() override;
 
     virtual void trace(Visitor*);
 
 private:
     explicit RemoteBridgeFrameOwner(PassRefPtrWillBeRawPtr<WebLocalFrameImpl>, SandboxFlags);
 
     RefPtrWillBeMember<WebLocalFrameImpl> m_frame;
     SandboxFlags m_sandboxFlags;
 };
 
 RemoteBridgeFrameOwner::RemoteBridgeFrameOwner(PassRefPtrWillBeRawPtr<WebLocalFrameImpl> frame, SandboxFlags flags)
     : m_frame(frame)
     , m_sandboxFlags(flags)
 {
 }
 
+SandboxFlags RemoteBridgeFrameOwner::sandboxFlags() const
+{
+    SandboxFlags flags = m_sandboxFlags;
+    // Frames need to inherit the sandbox flags of their parent frame.

[dcheng, 2015/01/16 19:11:19]

It this covered by any of our current tests?

[alexmos, 2015/01/17 02:54:42]

LayoutTests/http/tests/security/sandbox-inherit-to-initial-document.html seems
to cover it.

The cross-site case will also be covered by a browser test I'm adding here:
https://codereview.chromium.org/797813006/

+    Frame* parentFrame = m_frame->frame()->tree().parent();
+    if (parentFrame) {
+        ASSERT(parentFrame->isRemoteFrame());
+        flags |= toRemoteFrame(parentFrame)->securityContext()->sandboxFlags();
+    }
+    return flags;
+}
+
 void RemoteBridgeFrameOwner::trace(Visitor* visitor)
 {
     visitor->trace(m_frame);
     FrameOwner::trace(visitor);
 }
 
 void RemoteBridgeFrameOwner::dispatchLoad()
 {
     // FIXME: Implement. Most likely goes through m_frame->client().
 }
@@ skipping 710 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, 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.
@@ skipping 62 matching lines @@
 {
     frame()->setIsLoading(false);
     if (parent() && parent()->isWebLocalFrame()) {
         WebLocalFrameImpl* parentFrame =
             toWebLocalFrameImpl(parent()->toWebLocalFrame());
         parentFrame->frame()->loader().checkCompleted();
     }
 }
 
 } // namespace blink