OOPIF: Send page-level focus messages to all processes rendering a page.

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 <algorithm>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 14 matching lines @@
 #include "content/browser/frame_host/render_frame_host_factory.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/frame_host/render_frame_proxy_host.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_factory.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/browser/webui/web_ui_controller_factory_registry.h"
 #include "content/browser/webui/web_ui_impl.h"
 #include "content/common/frame_messages.h"
+#include "content/common/input_messages.h"
 #include "content/common/site_isolation_policy.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "content/public/browser/render_widget_host_iterator.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_ui_controller.h"
 #include "content/public/common/browser_plugin_guest_mode.h"
 #include "content/public/common/content_switches.h"
@@ skipping 31 matching lines @@
     // If this tree is already on our processing list *and* we have visited it,
     // then this node's opener is a back link.  This means the node will need
     // special treatment to process its opener.
     size_t position = std::distance(opener_trees->begin(), existing_tree_it);
     if (position < visited_index)
       nodes_with_back_links->insert(node);
   }
   return true;
 }
 
+// Helper function that can be used with FrameTree::ForEach to collect
+// SiteInstances involved in rendering a page, which is a subset of those in
+// proxy_hosts_ because of openers.
+bool CollectSiteInstances(std::set<SiteInstance*>* set,
+                          FrameTreeNode* node) {
+  set->insert(node->current_frame_host()->GetSiteInstance());
+  return true;
+}
+
 }  // namespace
 
 // A helper class to hold all frame proxies and register as a
 // RenderProcessHostObserver for them.
 class RenderFrameHostManager::RenderFrameProxyHostMap
     : public RenderProcessHostObserver {
  public:
   using MapType = base::hash_map<int32, RenderFrameProxyHost*>;
 
   RenderFrameProxyHostMap(RenderFrameHostManager* manager);
@@ skipping 1889 matching lines @@
       false /* is_loading */, FrameReplicationState()));
   proxy->set_render_frame_proxy_created(true);
 }
 
 void RenderFrameHostManager::SetRWHViewForInnerContents(
     RenderWidgetHostView* child_rwhv) {
   DCHECK(ForInnerDelegate() && frame_tree_node_->IsMainFrame());
   GetProxyToOuterDelegate()->SetChildRWHView(child_rwhv);
 }
 
+void RenderFrameHostManager::ReplicatePageFocus(bool is_focused) {

[nasko, 2015/10/16 21:43:44]

This doesn't seem to logically belong in this class. It is walking the frame
tree and doing update work on it. RenderFrameHostManager is supposed to be state
management for RFHs and RFPHs and cross-process navigations. Therefore it
shouldn't do work for the entire tree. The FrameTree class should be taking care
of these things.

[Charlie Reis, 2015/10/16 22:03:26]

I could see this going either way.  It's broadcasting to a set of proxies, which
tends to be something that we do from RFHM.

I agree that it could fit well in FrameTree, though, since it's only the proxies
in the frame tree, plus it's about focus.  Works for me.

[alexmos, 2015/10/16 22:56:06]

Good suggestion -- moved to FrameTree.

+  CHECK(frame_tree_node_->IsMainFrame());
+
+  std::set<SiteInstance*> frame_tree_site_instances;
+  frame_tree_node_->frame_tree()->ForEach(
+      base::Bind(&CollectSiteInstances, &frame_tree_site_instances));
+
+  // Notify the proxies for all SiteInstances of other frames in this
+  // FrameTree.  Note that the main frame might also know about proxies in
+  // SiteInstances for a frame in a different FrameTree (e.g., for
+  // window.open), so we can't just iterate over proxy_hosts_.
+  for (const auto& instance : frame_tree_site_instances) {
+    if (instance == render_frame_host_->GetSiteInstance())
+      continue;
+
+    RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance);
+    CHECK(proxy);

[nasko, 2015/10/16 21:44:21]

No need to CHECK here, as it will crash on the next line.

[alexmos, 2015/10/16 22:56:06]

Done.

+
+    proxy->Send(new InputMsg_SetFocus(proxy->GetRoutingID(), is_focused));
+  }
+}
+
 bool RenderFrameHostManager::InitRenderView(
     RenderViewHostImpl* render_view_host,
     int proxy_routing_id) {
   // Ensure the renderer process is initialized before creating the
   // RenderView.
   if (!render_view_host->GetProcess()->Init())
     return false;
 
   // We may have initialized this RenderViewHost for another RenderFrameHost.
   if (render_view_host->IsRenderViewLive())
@@ skipping 636 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);
 }
 
 }  // namespace content