Unify frame IDs with RenderFrameHost routing IDs.

content/renderer/render_frame_impl.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/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 947 matching lines @@
       make_scoped_ptr(client));
 }
 
 void RenderFrameImpl::didAccessInitialDocument(blink::WebFrame* frame) {
   render_view_->didAccessInitialDocument(frame);
 }
 
 blink::WebFrame* RenderFrameImpl::createChildFrame(
     blink::WebFrame* parent,
     const blink::WebString& name) {
-  long long child_frame_identifier = WebFrame::generateEmbedderIdentifier();
   // Synchronously notify the browser of a child frame creation to get the
   // routing_id for the RenderFrame.
-  int routing_id = MSG_ROUTING_NONE;
+  int child_routing_id = MSG_ROUTING_NONE;
   Send(new FrameHostMsg_CreateChildFrame(routing_id_,
-                                         parent->identifier(),
-                                         child_frame_identifier,
                                          base::UTF16ToUTF8(name),
-                                         &routing_id));
+                                         &child_routing_id));
   // Allocation of routing id failed, so we can't create a child frame. This can
   // happen if this RenderFrameImpl's IPCs are being filtered when in swapped
   // out state.
-  if (routing_id == MSG_ROUTING_NONE) {
+  if (child_routing_id == MSG_ROUTING_NONE) {
     base::debug::Alias(parent);
     base::debug::Alias(&routing_id_);
     bool render_view_is_swapped_out = GetRenderWidget()->is_swapped_out();
     base::debug::Alias(&render_view_is_swapped_out);
     bool render_view_is_closing = GetRenderWidget()->closing();
     base::debug::Alias(&render_view_is_closing);
     base::debug::Alias(&is_swapped_out_);
     base::debug::DumpWithoutCrashing();
     return NULL;
   }
 
   RenderFrameImpl* child_render_frame = RenderFrameImpl::Create(
-      render_view_.get(), routing_id);
+      render_view_.get(), child_routing_id);
   blink::WebFrame* web_frame = WebFrame::create(child_render_frame,
-                                                child_frame_identifier);
+                                                child_routing_id);
   parent->appendChild(web_frame);
   child_render_frame->SetWebFrame(web_frame);
 
   return web_frame;
 }
 
 void RenderFrameImpl::didDisownOpener(blink::WebFrame* frame) {
   render_view_->didDisownOpener(frame);
 }
 
 void RenderFrameImpl::frameDetached(blink::WebFrame* frame) {
   // NOTE: This function is called on the frame that is being detached and not
   // the parent frame.  This is different from createChildFrame() which is
   // called on the parent frame.
   CHECK(!is_detaching_);
 
   bool is_subframe = !!frame->parent();
 
-  int64 parent_frame_id = -1;
-  if (is_subframe)
-    parent_frame_id = frame->parent()->identifier();
-
-  Send(new FrameHostMsg_Detach(routing_id_, parent_frame_id,
-                               frame->identifier()));
+  Send(new FrameHostMsg_Detach(routing_id_));
 
   render_view_->UnregisterSwappedOutChildFrame(this);
 
   // The |is_detaching_| flag disables Send(). FrameHostMsg_Detach must be
   // sent before setting |is_detaching_| to true. In contrast, Observers
   // should only be notified afterwards so they cannot call back into here and
   // have IPCs fired off.
   is_detaching_ = true;
 
   // Call back to RenderViewImpl for observers to be notified.
@@ skipping 1174 matching lines @@
 
 void RenderFrameImpl::didStartLoading() {
   Send(new FrameHostMsg_DidStartLoading(routing_id_));
 }
 
 void RenderFrameImpl::didStopLoading() {
   Send(new FrameHostMsg_DidStopLoading(routing_id_));
 }
 
 }  // namespace content