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) {
+    return;
+  }
+  render_manager_.OnDidUpdateShouldEnforceStrictMixedContentChecking(
+      should_enforce);
+  replication_state_.should_enforce_strict_mixed_content_checking =

[nasko, 2015/12/17 17:16:32]

Is there a specific reason why the update is done after the notification to
proxies?

[estark, 2015/12/17 22:19:10]

Not that I know of. I was just following the example of the other similar
methods (SetFrameName(), SetCurrentOrigin(), etc.).

[nasko, 2015/12/18 18:27:12]

Acknowledged.

+      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