Plumb document's strict mixed content checking for RemoteFrames

third_party/WebKit/Source/core/frame/RemoteFrame.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 "core/frame/RemoteFrame.h"
 
 #include "bindings/core/v8/WindowProxy.h"
 #include "bindings/core/v8/WindowProxyManager.h"
 #include "core/dom/RemoteSecurityContext.h"
@@ skipping 12 matching lines @@
 
 namespace blink {
 
 inline RemoteFrame::RemoteFrame(RemoteFrameClient* client, FrameHost* host, FrameOwner* owner)
     : Frame(client, host, owner)
     , m_view(nullptr)
     , m_securityContext(RemoteSecurityContext::create())
     , m_domWindow(RemoteDOMWindow::create(*this))
     , m_windowProxyManager(WindowProxyManager::create(*this))
     , m_remotePlatformLayer(nullptr)
+    , m_shouldEnforceStrictMixedContentChecking(false)

[alexmos, 2015/12/03 20:43:26]

Would it make sense to store m_shouldEnforceStrictMixedContentChecking in
SecurityContext instead, similar to sandbox flags?  That would avoid having to
store it in two different places for local and remote frames (since
RemoteSecurityContext inherits from SecurityContext).

[estark, 2015/12/04 00:19:32]

Sure, that seems reasonable to me. Done.

 {
 }
 
 PassRefPtrWillBeRawPtr<RemoteFrame> RemoteFrame::create(RemoteFrameClient* client, FrameHost* host, FrameOwner* owner)
 {
     return adoptRefWillBeNoop(new RemoteFrame(client, host, owner));
 }
 
 RemoteFrame::~RemoteFrame()
 {
@@ skipping 80 matching lines @@
     Frame::disconnectOwnerElement();
 }
 
 bool RemoteFrame::shouldClose()
 {
     // TODO(nasko): Implement running the beforeunload handler in the actual
     // LocalFrame running in a different process and getting back a real result.
     return true;
 }
 
+bool RemoteFrame::shouldEnforceStrictMixedContentChecking() const
+{
+    return m_shouldEnforceStrictMixedContentChecking;
+}
+
 void RemoteFrame::forwardInputEvent(Event* event)
 {
     remoteFrameClient()->forwardInputEvent(event);
 }
 
 void RemoteFrame::frameRectsChanged(const IntRect& frameRect)
 {
     remoteFrameClient()->frameRectsChanged(frameRect);
 }
 
@@ skipping 12 matching lines @@
         return;
 
     ASSERT(!deprecatedLocalOwner()->ownedWidget());
 
     setView(RemoteFrameView::create(this));
 
     if (ownerLayoutObject())
         deprecatedLocalOwner()->setWidget(m_view);
 }
 
+void RemoteFrame::setShouldEnforceStrictMixedContentChecking(bool shouldEnforce)
+{
+    m_shouldEnforceStrictMixedContentChecking = shouldEnforce;
+}
+
 RemoteFrameClient* RemoteFrame::remoteFrameClient() const
 {
     return static_cast<RemoteFrameClient*>(client());
 }
 
 void RemoteFrame::setRemotePlatformLayer(WebLayer* layer)
 {
     if (m_remotePlatformLayer)
         GraphicsLayer::unregisterContentsLayer(m_remotePlatformLayer);
     m_remotePlatformLayer = layer;
     if (m_remotePlatformLayer)
         GraphicsLayer::registerContentsLayer(layer);
 
     ASSERT(owner());
     toHTMLFrameOwnerElement(owner())->setNeedsCompositingUpdate();
 }
 
 } // namespace blink