Snapshot of all changes to get jumbo in blink and content.

content/renderer/render_frame_proxy.cc

 // Copyright 2014 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_proxy.h"
 
 #include <stdint.h>
 #include <map>
 #include <utility>
 
@@ skipping 30 matching lines @@
 namespace content {
 
 namespace {
 
 // Facilitates lookup of RenderFrameProxy by routing_id.
 typedef std::map<int, RenderFrameProxy*> RoutingIDProxyMap;
 static base::LazyInstance<RoutingIDProxyMap>::DestructorAtExit
     g_routing_id_proxy_map = LAZY_INSTANCE_INITIALIZER;
 
 // Facilitates lookup of RenderFrameProxy by WebRemoteFrame.
-typedef std::map<blink::WebRemoteFrame*, RenderFrameProxy*> FrameMap;
-base::LazyInstance<FrameMap>::DestructorAtExit g_frame_map =
+typedef std::map<blink::WebRemoteFrame*, RenderFrameProxy*> FrameProxyMap;
+base::LazyInstance<FrameProxyMap>::DestructorAtExit g_frame_proxy_map =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 // static
 RenderFrameProxy* RenderFrameProxy::CreateProxyToReplaceFrame(
     RenderFrameImpl* frame_to_replace,
     int routing_id,
     blink::WebTreeScopeType scope) {
   CHECK_NE(routing_id, MSG_ROUTING_NONE);
@@ skipping 91 matching lines @@
   RoutingIDProxyMap* proxies = g_routing_id_proxy_map.Pointer();
   RoutingIDProxyMap::iterator it = proxies->find(routing_id);
   return it == proxies->end() ? NULL : it->second;
 }
 
 // static
 RenderFrameProxy* RenderFrameProxy::FromWebFrame(
     blink::WebRemoteFrame* web_frame) {
   // TODO(dcheng): Turn this into a DCHECK() if it doesn't crash on canary.
   CHECK(web_frame);
-  FrameMap::iterator iter = g_frame_map.Get().find(web_frame);
-  if (iter != g_frame_map.Get().end()) {
+  FrameProxyMap::iterator iter = g_frame_proxy_map.Get().find(web_frame);
+  if (iter != g_frame_proxy_map.Get().end()) {
     RenderFrameProxy* proxy = iter->second;
     DCHECK_EQ(web_frame, proxy->web_frame());
     return proxy;
   }
   // Reaching this is not expected: this implies that the |web_frame| in
   // question is not managed by the content API, or the associated
   // RenderFrameProxy is already deleted--in which case, it's not safe to touch
   // |web_frame|.
   NOTREACHED();
   return NULL;
@@ skipping 25 matching lines @@
   CHECK(web_frame);
   CHECK(render_view);
   CHECK(render_widget);
 
   web_frame_ = web_frame;
   render_view_ = render_view;
   render_widget_ = render_widget;
 
   render_widget_->RegisterRenderFrameProxy(this);
 
-  std::pair<FrameMap::iterator, bool> result =
-      g_frame_map.Get().insert(std::make_pair(web_frame_, this));
+  std::pair<FrameProxyMap::iterator, bool> result =
+      g_frame_proxy_map.Get().insert(std::make_pair(web_frame_, this));
   CHECK(result.second) << "Inserted a duplicate item.";
 }
 
 void RenderFrameProxy::WillBeginCompositorFrame() {
   if (compositing_helper_) {
     FrameHostMsg_HittestData_Params params;
     params.surface_id = compositing_helper_->surface_id();
     params.ignored_for_hittest = web_frame_->IsIgnoredForHitTest();
     render_widget_->QueueMessage(
         new FrameHostMsg_HittestData(render_widget_->routing_id(), params),
@@ skipping 213 matching lines @@
     // |provisional_frame| should always exist.  If it was deleted via
     // FrameMsg_Delete right before this proxy was removed,
     // RenderFrameImpl::frameDetached would've cleared this proxy's
     // |provisional_frame_routing_id_| and we wouldn't get here.
     CHECK(provisional_frame);
     provisional_frame->GetWebFrame()->Detach();
   }
 
   // Remove the entry in the WebFrame->RenderFrameProxy map, as the |web_frame_|
   // is no longer valid.
-  FrameMap::iterator it = g_frame_map.Get().find(web_frame_);
-  CHECK(it != g_frame_map.Get().end());
+  FrameProxyMap::iterator it = g_frame_proxy_map.Get().find(web_frame_);
+  CHECK(it != g_frame_proxy_map.Get().end());
   CHECK_EQ(it->second, this);
-  g_frame_map.Get().erase(it);
+  g_frame_proxy_map.Get().erase(it);
 
   web_frame_ = nullptr;
 
   delete this;
 }
 
 void RenderFrameProxy::ForwardPostMessage(
     blink::WebLocalFrame* source_frame,
     blink::WebRemoteFrame* target_frame,
     blink::WebSecurityOrigin target_origin,
@@ skipping 84 matching lines @@
                                     blink::WebLocalFrame* source) {
   int source_routing_id = RenderFrameImpl::FromWebFrame(source)->GetRoutingID();
   Send(new FrameHostMsg_AdvanceFocus(routing_id_, type, source_routing_id));
 }
 
 void RenderFrameProxy::FrameFocused() {
   Send(new FrameHostMsg_FrameFocused(routing_id_));
 }
 
 }  // namespace