Now that RenderFrame is 1:1 with WebFrame, add the associated getters and start cleaning up assumpt…

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 97 matching lines @@
 RenderFrameImpl* RenderFrameImpl::Create(RenderViewImpl* render_view,
                                          int32 routing_id) {
   DCHECK(routing_id != MSG_ROUTING_NONE);
 
   if (g_create_render_frame_impl)
     return g_create_render_frame_impl(render_view, routing_id);
   else
     return new RenderFrameImpl(render_view, routing_id);
 }
 
-RenderFrameImpl* RenderFrameImpl::FindByWebFrame(blink::WebFrame* web_frame) {
-  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess)) {
-    FrameMap::iterator iter = g_frame_map.Get().find(web_frame);
-    if (iter != g_frame_map.Get().end())
-      return iter->second;
-  }
+// static
+RenderFrame* RenderFrame::FromWebFrame(blink::WebFrame* web_frame) {
+  return RenderFrameImpl::FromWebFrame(web_frame);
+}
 
+RenderFrameImpl* RenderFrameImpl::FromWebFrame(blink::WebFrame* web_frame) {
+  FrameMap::iterator iter = g_frame_map.Get().find(web_frame);
+  if (iter != g_frame_map.Get().end())
+    return iter->second;
   return NULL;
 }
 
 // static
 void RenderFrameImpl::InstallCreateHook(
     RenderFrameImpl* (*create_render_frame_impl)(RenderViewImpl*, int32)) {
   CHECK(!g_create_render_frame_impl);
   g_create_render_frame_impl = create_render_frame_impl;
 }
 
 // RenderFrameImpl ----------------------------------------------------------
 RenderFrameImpl::RenderFrameImpl(RenderViewImpl* render_view, int routing_id)
     : frame_(NULL),
       render_view_(render_view),
       routing_id_(routing_id),
       is_swapped_out_(false),
       is_detaching_(false),
       cookie_jar_(this) {
   RenderThread::Get()->AddRoute(routing_id_, this);
-#if defined(ENABLE_PLUGINS)
-  new PepperBrowserConnection(this);
-#endif
-  new SharedWorkerRepository(this);
-
-  GetContentClient()->renderer()->RenderFrameCreated(this);
 }
 
 RenderFrameImpl::~RenderFrameImpl() {
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, RenderFrameGone());
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, OnDestruct());
   RenderThread::Get()->RemoveRoute(routing_id_);
 }
 
 // TODO(nasko): Overload the delete operator to overwrite the freed
 // RenderFrameImpl object and help detect potential use-after-free bug.
 // See https://crbug.com/245126#c34.
 void RenderFrameImpl::operator delete(void* ptr) {
   memset(ptr, 0xAF, sizeof(RenderFrameImpl));
 }
 
-void RenderFrameImpl::MainWebFrameCreated(blink::WebFrame* frame) {
-  std::pair<FrameMap::iterator, bool> result = g_frame_map.Get().insert(
-      std::make_pair(frame, this));
-  CHECK(result.second) << "Inserting a duplicate item.";
-
-  FOR_EACH_OBSERVER(RenderFrameObserver, observers_,
-                    WebFrameCreated(frame));
-}
-
 void RenderFrameImpl::SetWebFrame(blink::WebFrame* web_frame) {
   DCHECK(!frame_);
-  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess))
-    frame_ = web_frame;
+
+  std::pair<FrameMap::iterator, bool> result = g_frame_map.Get().insert(
+      std::make_pair(web_frame, this));
+  CHECK(result.second) << "Inserting a duplicate item.";
+
+  frame_ = web_frame;
+ 
+#if defined(ENABLE_PLUGINS)
+  new PepperBrowserConnection(this);
+#endif
+  new SharedWorkerRepository(this);
+
+  // We delay calling this until we have the WebFrame so that any observer or
+  // embedder can call GetWebFrame on any RenderFrame.
+  GetContentClient()->renderer()->RenderFrameCreated(this);
 }
 
 RenderWidget* RenderFrameImpl::GetRenderWidget() {
   return render_view_;
 }
 
 #if defined(ENABLE_PLUGINS)
 void RenderFrameImpl::PepperPluginCreated(RendererPpapiHost* host) {
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_,
                     DidCreatePepperPlugin(host));
@@ skipping 245 matching lines @@
 }
 
 RenderView* RenderFrameImpl::GetRenderView() {
   return render_view_;
 }
 
 int RenderFrameImpl::GetRoutingID() {
   return routing_id_;
 }
 
+blink::WebFrame* RenderFrameImpl::GetWebFrame() {
+  DCHECK(frame_);
+  return frame_;
+}
+
 WebPreferences& RenderFrameImpl::GetWebkitPreferences() {
   return render_view_->GetWebkitPreferences();
 }
 
 int RenderFrameImpl::ShowContextMenu(ContextMenuClient* client,
                                      const ContextMenuParams& params) {
   return render_view_->ShowContextMenu(client, params);
 }
 
 void RenderFrameImpl::CancelContextMenu(int request_id) {
@@ skipping 127 matching lines @@
   RenderFrameImpl* child_render_frame = RenderFrameImpl::Create(render_view_,
                                                                 routing_id);
   // TODO(nasko): Over-conservative check for debugging.
   CHECK(child_render_frame);
   blink::WebFrame* web_frame = WebFrame::create(child_render_frame,
                                                 child_frame_identifier);
   // TODO(nasko): Over-conservative check for debugging.
   CHECK(web_frame);
   child_render_frame->SetWebFrame(web_frame);
 
-  std::pair<FrameMap::iterator, bool> result = g_frame_map.Get().insert(
-      std::make_pair(web_frame, child_render_frame));
-  CHECK(result.second) << "Inserting a duplicate item.";
-
-  FOR_EACH_OBSERVER(RenderFrameObserver, observers_,
-                    WebFrameCreated(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
@@ skipping 828 matching lines @@
 void RenderFrameImpl::AddObserver(RenderFrameObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void RenderFrameImpl::RemoveObserver(RenderFrameObserver* observer) {
   observer->RenderFrameGone();
   observers_.RemoveObserver(observer);
 }
 
 }  // namespace content