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) {
-  if (name != replication_state_.name)
-    render_manager_.OnDidUpdateName(name);
+void FrameTreeNode::SetFrameName(const std::string& name,
+                                 const std::string& unique_name) {
+  if (name == replication_state_.name) {
+    // |unique_name| shouldn't change unless |name| changes.
+    DCHECK_EQ(unique_name, replication_state_.unique_name);
+    return;
+  }
+  render_manager_.OnDidUpdateName(name, unique_name);
   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 205 matching lines @@
       speculative_frame_host->ResetLoadingState();
   } else {
     RenderFrameHostImpl* pending_frame_host =
         render_manager_.pending_frame_host();
     if (pending_frame_host)
       pending_frame_host->ResetLoadingState();
   }
 }
 
 }  // namespace content