Replicating WebFrame::uniqueName across renderers.

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 <utility>
 
 #include "base/macros.h"
@@ skipping 60 matching lines @@
 
 FrameTreeNode::FrameTreeNode(
     FrameTree* frame_tree,
     Navigator* navigator,
     RenderFrameHostDelegate* render_frame_delegate,
     RenderViewHostDelegate* render_view_delegate,
     RenderWidgetHostDelegate* render_widget_delegate,
     RenderFrameHostManager::Delegate* manager_delegate,
     blink::WebTreeScopeType scope,
     const std::string& name,
+    const std::string& unique_name,
     const blink::WebFrameOwnerProperties& frame_owner_properties)
     : frame_tree_(frame_tree),
       navigator_(navigator),
       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,
+          unique_name,
           blink::WebSandboxFlags::None,
           false /* should enforce strict mixed content checking */),
       pending_sandbox_flags_(blink::WebSandboxFlags::None),
       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 89 matching lines @@
     has_committed_real_load_ = true;
   current_url_ = url;
 }
 
 void FrameTreeNode::SetCurrentOrigin(const url::Origin& origin) {
   if (!origin.IsSameOriginWith(replication_state_.origin))
     render_manager_.OnDidUpdateOrigin(origin);
   replication_state_.origin = origin;
 }
 
-void FrameTreeNode::SetFrameName(const std::string& name) {
+void FrameTreeNode::SetFrameName(const std::string& name,
+                                 const std::string& unique_name) {
   if (name != replication_state_.name)
     render_manager_.OnDidUpdateName(name);

[Charlie Reis, 2016/01/27 23:48:49]

Don't we need to broadcast the new unique_name to the proxies?  Or is there a
reason that's not needed?

Also, is it possible for the name to stay the same and the unique name to
change?  If so, we might need to broadcast the change in those cases as well.

[Łukasz Anforowicz, 2016/01/28 01:21:19]

Ooops.  Good catch - I looked at RenderFrameHostImpl::OnDidChangeName, but
didn't notice that we broadcast the change above.  

Done.
No - the unique name changes are tied to name changes (in blink::FrameTree).

   replication_state_.name = name;
+  replication_state_.unique_name = unique_name;
 }
 
 void FrameTreeNode::SetEnforceStrictMixedContentChecking(bool should_enforce) {
   if (should_enforce ==
       replication_state_.should_enforce_strict_mixed_content_checking) {
     return;
   }
   render_manager_.OnEnforceStrictMixedContentChecking(should_enforce);
   replication_state_.should_enforce_strict_mixed_content_checking =
       should_enforce;
@@ skipping 179 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