Plumb document's strict mixed content checking for RemoteFrames

content/browser/frame_host/frame_tree_node.cc

 // Copyright 2013 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 "content/browser/frame_host/frame_tree_node.h"
 
 #include <queue>
 
 #include "base/command_line.h"
 #include "base/profiler/scoped_tracker.h"
@@ skipping 72 matching lines @@
       render_manager_(this,
                       render_frame_delegate,
                       render_view_delegate,
                       render_widget_delegate,
                       manager_delegate),
       frame_tree_node_id_(next_frame_tree_node_id_++),
       parent_(NULL),
       opener_(nullptr),
       opener_observer_(nullptr),
       has_committed_real_load_(false),
-      replication_state_(scope, name, sandbox_flags),
+      replication_state_(
+          scope,
+          name,
+          sandbox_flags,
+          false /* should enforce strict mixed content checking */),
       // Effective sandbox flags also need to be set, since initial sandbox
       // flags should apply to the initial empty document in the frame.
       effective_sandbox_flags_(sandbox_flags),
       frame_owner_properties_(frame_owner_properties),
       loading_progress_(kLoadingProgressNotStarted) {
   std::pair<FrameTreeNodeIDMap::iterator, bool> result =
       g_frame_tree_node_id_map.Get().insert(
           std::make_pair(frame_tree_node_id_, this));
   CHECK(result.second);
 }
@@ skipping 93 matching lines @@
     render_manager_.OnDidUpdateOrigin(origin);
   replication_state_.origin = origin;
 }
 
 void FrameTreeNode::SetFrameName(const std::string& name) {
   if (name != replication_state_.name)
     render_manager_.OnDidUpdateName(name);
   replication_state_.name = name;
 }
 
+void FrameTreeNode::SetShouldEnforceStrictMixedContentChecking(
+    bool should_enforce) {
+  if (should_enforce !=
+      replication_state_.should_enforce_strict_mixed_content_checking) {
+    render_manager_.OnDidUpdateShouldEnforceStrictMixedContentChecking(
+        should_enforce);
+  }
+  replication_state_.should_enforce_strict_mixed_content_checking =

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

What's the lifetime of this flag in Blink?  Does it get reset to false on each
frame navigation?  If it does (and I think it does), then we would need to reset
it in the replication state for each navigation, since replication state (and
FrameTreeNode in general) stays around across navigations (both same-site and
cross-site) of the same frame.

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

Ah, yes, it should be reset on navigation. I've now done this by resetting it in
RFHManager::DidNavigateFrame() -- does that seem correct?

[alexmos, 2015/12/04 23:41:11]

Yes, that seems fine.  Well, to make sure I understand: does the bit always get
set after a frame has committed a navigation?  Just want to verify that we won't
ever try to set the bit and then clear it when we receive
DidCommitProvisionalLoad.

[estark, 2015/12/07 20:39:33]

Ah, no, you're right, there's probably no guarantee that it gets set after
commit. In fact, the flag is attached to the Document, so it's also maybe
possible (?) for a new Document to get created and the flag to be unset even
without a navigation happening at all.

Right now when a Document is created, I'm sending an update if
shouldEnforceStrictMixedContentChecking() is true; I think I should be sending
an update either way, so that the frame replication state gets updated to true
if the Document is enforcing strict mixed content checking and false if it
isn't. WDYT of that approach?

[alexmos, 2015/12/08 01:06:36]

Yes, I agree that we should send the update from Blink regardless of whether the
flag is true or false, but I think we might not want to tie it to Document
creation, as in that case we might accidentally set/reset the flag for a
Document that ends up not committing.

I've just discussed this with Nasko to be sure, and we think the right approach
is probably to set/reset the browser-side bit at commit time.  At that point in
time, it's guaranteed that the bit (whatever it is) has taken effect for a
particular Document and is safe to use for any future subframes that want to
inherit it, etc.  

So I think you could just pass it in
FrameHostMsg_DidCommitProvisionalLoad_Params, whether it's true or false, just
like the replicated origin.  It sounds like you will still need your
renderer->browser IPC though, to allow for dynamic
updates that may happen later.

+      should_enforce;
+}
+
 bool FrameTreeNode::IsDescendantOf(FrameTreeNode* other) const {
   if (!other || !other->child_count())
     return false;
 
   for (FrameTreeNode* node = parent(); node; node = node->parent()) {
     if (node == other)
       return true;
   }
 
   return false;
@@ skipping 163 matching lines @@
   render_manager_.Stop();
   return true;
 }
 
 void FrameTreeNode::DidFocus() {
   last_focus_time_ = base::TimeTicks::Now();
   FOR_EACH_OBSERVER(Observer, observers_, OnFrameTreeNodeFocused(this));
 }
 
 }  // namespace content