Add support for entering/exiting HTML fullscreen from OOPIFs.

content/browser/frame_host/render_frame_host_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/browser/frame_host/render_frame_host_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 1769 matching lines @@
       AXContentTreeDataToAXTreeData(&dst_snapshot.tree_data);
       dst_snapshot.has_tree_data = true;
     }
     it->second.Run(dst_snapshot);
     ax_tree_snapshot_callbacks_.erase(it);
   } else {
     NOTREACHED() << "Received AX tree snapshot response for unknown id";
   }
 }
 
+// TODO(alexmos): When the allowFullscreen flag is known in the browser
+// process, use it to double-check that fullscreen can be entered here.
 void RenderFrameHostImpl::OnToggleFullscreen(bool enter_fullscreen) {
+  // Entering fullscreen from a cross-process subframe also affects all
+  // renderers for ancestor frames, which will need to apply fullscreen CSS to
+  // appropriate ancestor <iframe> elements, fire fullscreenchange events, etc.
+  // Thus, walk through the ancestor chain of this frame and send a message
+  // about the pending fullscreen change, providing the routing ID of the
+  // remote child frame that contains the fullscreened element.  The renderer

[Charlie Reis, 2016/05/12 22:59:23]

nit: renderer process

[alexmos, 2016/05/13 07:21:03]

Done.

+  // will use this to find the <iframe> element that will need fullscreen
+  // styles.  This is done at most once per SiteInstance: for example, with a
+  // A-B-A-B hierarchy, if the bottom frame goes fullscreen, this only needs to
+  // notify its parent, and Blink-side logic will take care of applying
+  // necessary changes to the other two ancestors.

[alexmos, 2016/05/10 21:36:24]

I considered whether this should be per-widget or per-frame, rather than
per-ancestor-SiteInstance.  One reason for doing it this way is that it
simplifies changes in Blink's FullscreenController, which tracks fullscreen
state per page.  Another reason is that currently, JS can synchronously observe
results of document.requestFullscreen() by checking
document.webkitCurrentFullScreenElement.  So, with A-B-A, the bottom frame could
do 
  element.requestFullscreen();
  use parent.parent.webkitCurrentFullScreenElement
And at that point, parent.parent.webkitCurrentFullScreenElement returns the
<iframe> element for B (even though fullscreenchange hasn't yet fired, and
fullscreen hasn't been entered).

So, to keep this sane, I've decided to let Blink code walk through all local
ancestors in each SiteInstance.  

[Charlie Reis, 2016/05/12 22:59:23]

Acknowledged.

+  if (enter_fullscreen &&
+      SiteIsolationPolicy::AreCrossProcessFramesPossible()) {
+    std::set<SiteInstance*> notified_instances;
+    notified_instances.insert(GetSiteInstance());
+    for (FrameTreeNode* node = frame_tree_node_; node->parent();
+         node = node->parent()) {
+      RenderFrameHostImpl* parent_rfh = node->parent()->current_frame_host();
+      if (ContainsKey(notified_instances, parent_rfh->GetSiteInstance()))
+        continue;
+
+      int child_routing_id =
+          node->render_manager()->GetRoutingIdForSiteInstance(
+              parent_rfh->GetSiteInstance());
+      parent_rfh->Send(new FrameMsg_WillEnterFullscreen(
+          parent_rfh->GetRoutingID(), child_routing_id));

[Charlie Reis, 2016/05/12 22:59:23]

Nick was wondering if this should just go to child_routing_id instead, and let
the proxy handle it?  (I left a comment in RenderFrameImpl as well.)

[alexmos, 2016/05/13 07:21:03]

This is a great idea!  Done.

+      notified_instances.insert(parent_rfh->GetSiteInstance());
+    }
+  }
+
+  // TODO(alexmos): See if this can use the last committed origin instead.
   if (enter_fullscreen)
     delegate_->EnterFullscreenMode(last_committed_url().GetOrigin());
   else
     delegate_->ExitFullscreenMode(/* will_cause_resize */ true);
 
   // The previous call might change the fullscreen state. We need to make sure
-  // the renderer is aware of that, which is done via the resize message.
+  // the renderer is aware of that, which is done via the resize message. We
+  // always send this to the main frame's widget, and if there are any OOPIF
+  // widgets, this will also trigger them to resize via frameRectsChanged.

[alexmos, 2016/05/10 21:36:24]

My doc (https://goo.gl/Y5wdqi) has some more info about why I ended up keeping
fullscreen triggering in ViewMsg_Resize, but basically this avoids firing the
fullscreenchange event too early, before the fullscreen resizing is complete,
and allows the widget to process all the fullscreen resizing and restyling as
part of a single IPC.

[Charlie Reis, 2016/05/12 22:59:23]

Acknowledged.

   render_view_host_->GetWidget()->WasResized();
 }
 
 void RenderFrameHostImpl::OnDidStartLoading(bool to_different_document) {
   if (IsBrowserSideNavigationEnabled() && to_different_document) {
     bad_message::ReceivedBadMessage(GetProcess(),
                                     bad_message::RFH_UNEXPECTED_LOAD_START);
     return;
   }
   bool was_previously_loading = frame_tree_node_->frame_tree()->IsLoading();
@@ skipping 956 matching lines @@
   // handler after it's destroyed so it can't run after the RFHI is destroyed.
   web_bluetooth_service_->SetClientConnectionErrorHandler(base::Bind(
       &RenderFrameHostImpl::DeleteWebBluetoothService, base::Unretained(this)));
 }
 
 void RenderFrameHostImpl::DeleteWebBluetoothService() {
   web_bluetooth_service_.reset();
 }
 
 }  // namespace content