Propagate window coordinates to out-of-process iframes renderers.

content/browser/frame_host/render_frame_host_manager.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/render_frame_host_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 730 matching lines @@
        iter++) {
     if (iter->get() == render_frame_host) {
       pending_delete_hosts_.erase(iter);
       return true;
     }
   }
   return false;
 }
 
 void RenderFrameHostManager::ResetProxyHosts() {
-  for (auto& pair : proxy_hosts_) {
+  for (const auto& pair : proxy_hosts_) {
     static_cast<SiteInstanceImpl*>(pair.second->GetSiteInstance())
         ->RemoveObserver(this);
   }
   proxy_hosts_.clear();
 }
 
 void RenderFrameHostManager::ClearRFHsPendingShutdown() {
   pending_delete_hosts_.clear();
 }
 
@@ skipping 242 matching lines @@
         proxy->PassFrameHostOwnership();
     MoveToPendingDeleteHosts(std::move(swapped_out_rfh));
   }
 
   DeleteRenderFrameProxyHost(site_instance);
 }
 
 RenderFrameProxyHost* RenderFrameHostManager::CreateRenderFrameProxyHost(
     SiteInstance* site_instance,
     RenderViewHostImpl* rvh) {
-  auto result = proxy_hosts_.add(site_instance->GetId(),
-                                 make_scoped_ptr(new RenderFrameProxyHost(
-                                     site_instance, rvh, frame_tree_node_)));
-  CHECK(result.second) << "A proxy already existed for this SiteInstance.";
+  int site_instance_id = site_instance->GetId();
+  CHECK(proxy_hosts_.find(site_instance_id) == proxy_hosts_.end())
+      << "A proxy already existed for this SiteInstance.";
+  RenderFrameProxyHost* proxy_host =
+      new RenderFrameProxyHost(site_instance, rvh, frame_tree_node_);
+  proxy_hosts_[site_instance_id] = make_scoped_ptr(proxy_host);

[nasko, 2016/02/12 18:14:08]

Why was this rewrite necessary? 

[lfg, 2016/03/02 18:29:08]

Moved to another CL.

   static_cast<SiteInstanceImpl*>(site_instance)->AddObserver(this);
-  return result.first->second;
+  return proxy_host;
 }
 
 void RenderFrameHostManager::DeleteRenderFrameProxyHost(
     SiteInstance* site_instance) {
   static_cast<SiteInstanceImpl*>(site_instance)->RemoveObserver(this);
   proxy_hosts_.erase(site_instance->GetId());
 }
 
 bool RenderFrameHostManager::ShouldTransitionCrossSite() {
   // The logic below is weaker than "are all sites isolated" -- it asks instead,
@@ skipping 719 matching lines @@
 
   return proxy->GetRoutingID();
 }
 
 void RenderFrameHostManager::CreateProxiesForChildFrame(FrameTreeNode* child) {
   RenderFrameProxyHost* outer_delegate_proxy =
       ForInnerDelegate() ? GetProxyToOuterDelegate() : nullptr;
   for (const auto& pair : proxy_hosts_) {
     // Do not create proxies for subframes in the outer delegate's process,
     // since the outer delegate does not need to interact with them.
-    if (pair.second == outer_delegate_proxy)
+    if (pair.second.get() == outer_delegate_proxy)
       continue;
 
     child->render_manager()->CreateRenderFrameProxy(
         pair.second->GetSiteInstance());
   }
 }
 
 void RenderFrameHostManager::EnsureRenderViewInitialized(
     RenderViewHostImpl* render_view_host,
     SiteInstance* instance) {
@@ skipping 555 matching lines @@
   RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance);
   if (proxy)
     return proxy->GetRenderViewHost();
   return nullptr;
 }
 
 RenderFrameProxyHost* RenderFrameHostManager::GetRenderFrameProxyHost(
     SiteInstance* instance) const {
   auto it = proxy_hosts_.find(instance->GetId());
   if (it != proxy_hosts_.end())
-    return it->second;
+    return it->second.get();
   return nullptr;
 }
 
 int RenderFrameHostManager::GetProxyCount() {
   return proxy_hosts_.size();
 }
 
-std::map<int, RenderFrameProxyHost*>
-RenderFrameHostManager::GetAllProxyHostsForTesting() {
-  std::map<int, RenderFrameProxyHost*> result;
-  for (const auto& pair : proxy_hosts_)
-    result[pair.first] = pair.second;
-  return result;
-}
-
 void RenderFrameHostManager::CollectOpenerFrameTrees(
     std::vector<FrameTree*>* opener_frame_trees,
     base::hash_set<FrameTreeNode*>* nodes_with_back_links) {
   CHECK(opener_frame_trees);
   opener_frame_trees->push_back(frame_tree_node_->frame_tree());
 
   // Add the FrameTree of the given node's opener to the list of
   // |opener_frame_trees| if it doesn't exist there already. |visited_index|
   // indicates which FrameTrees in |opener_frame_trees| have already been
   // visited (i.e., those at indices less than |visited_index|).
@@ skipping 122 matching lines @@
 
 int RenderFrameHostManager::GetOpenerRoutingID(SiteInstance* instance) {
   if (!frame_tree_node_->opener())
     return MSG_ROUTING_NONE;
 
   return frame_tree_node_->opener()
       ->render_manager()
       ->GetRoutingIdForSiteInstance(instance);
 }
 
+void RenderFrameHostManager::SendPageMsg(IPC::Message* msg) {
+  DCHECK(IPC_MESSAGE_CLASS(*msg) == PageMsgStart);

[nasko, 2016/02/12 18:14:08]

Should this method return if the IPC is not a PageMsg one?

[lfg, 2016/03/02 18:29:08]

Done.

+
+  // We should always deliver page messages through the main frame.
+  DCHECK(!frame_tree_node_->parent());

[nasko, 2016/02/12 18:14:08]

Same as above. What happens when the DCHECK is violated, but it is a release
build?

[lfg, 2016/03/02 18:29:08]

We shouldn't write code to violate the DCHECK ;)

But it's probably a good idea to just return if it's violated. Done.

+
+  for (const auto& pair : proxy_hosts_) {
+    RenderFrameProxyHost* proxy = pair.second.get();
+
+    IPC::Message* copy = new IPC::Message(*msg);
+    copy->set_routing_id(proxy->GetRoutingID());
+    proxy->Send(copy);
+  }
+
+  if (speculative_render_frame_host_) {
+    IPC::Message* copy = new IPC::Message(*msg);
+    copy->set_routing_id(speculative_render_frame_host_->GetRoutingID());
+    speculative_render_frame_host_->Send(copy);
+  }
+
+  if (pending_render_frame_host_) {

[nasko, 2016/02/12 18:14:08]

Speculative and pending cannot exist at the same time, so it should be an
if/else case.

[lfg, 2016/03/02 18:29:08]

Done.

+    IPC::Message* copy = new IPC::Message(*msg);
+    copy->set_routing_id(pending_render_frame_host_->GetRoutingID());
+    pending_render_frame_host_->Send(copy);
+  }
+
+  msg->set_routing_id(render_frame_host_->GetRoutingID());
+  render_frame_host_->Send(msg);
+}
+
 }  // namespace content