Reland: Add support for entering/exiting HTML fullscreen from OOPIFs.

Reland: Add support for entering/exiting HTML fullscreen from OOPIFs.

Currently, entering HTML fullscreen utilizes a number of ancestor
frame walks.  This is because entering fullscreen for an element (1)
alters layout for all its ancestor <iframes> (by applying
:-webkit-full-screen styles to them, which applies some UA CSS rules),
(2) fires fullscreenchange in all ancestor documents on <iframe>
elements along the ancestor chain, and (3) makes
document.webkitFullscreenElement return the <iframe> element
containing the fullscreened element in ancestor frames.

Currently, the logic behind this assumes that all ancestor frames are
local and does nothing when it encounters a remote frame.  This CL
takes the first step to fix this.

The existing flow for entering HTML fullscreen goes like this:
1. JS on the page calls element.webkitRequestFullscreen()
2. Fullscreen::requestFullscreen():
   a. Checks if fullscreen is allowed by ancestors (allowFullscreen)
   b. Creates fullscreenchange events for |element| and its ancestor
      <iframes> and saves them in its m_eventQueue.
   c. Puts |element| on its fullscreen element stack.
3. FullscreenController::enterFullScreenForElement(element)
   a. Saves |element| as provisional fullscreen element.
   b. Saves some page sizing info (to be restored after fullscreen)
4. RenderFrameImpl::enterFullscreen sends a FrameHostMsg_ToggleFullscreen
   to browser process.
5. RenderFrameHostImpl::OnToggleFullscreen() asks the current tab to
   enter fullscreen.
6. After the tab is resized for fullscreen, browser process generates a
   ViewMsg_Resize to the main frame renderer, with
   is_fullscreen_granted=1 in ResizeParams.
7. RenderWidget::Resize realizes there's a fullscreen change and calls
   into FullscreenController::didEnterFullScreen().
8. FullscreenController::didEnterFullScreen picks up the stored
   provisional fullscreen element and calls
   Fullscreen::didEnterFullScreenForElement on it.
9. Fullscreen::didEnterFullScreenForElement(element):
   a. Adjusts layout on |element| for fullscreen
   b. Sets fullscreen CSS styles on the fullscreen element and all
      ancestor elements.
   c. Fires fullscreenchange events from step 2b.

The main changes in this CL are:

- in step 5, before entering fullscreen for tab, we will send an IPC
  to ancestor OOPIFs so that they do steps 2 and 3 for their
  respective ancestor <iframe> elements (i.e., set up provisional
  fullscreen elements and prepare their share of the fullscreenchange
  events).
- ViewMsg_Resize will trigger fullscreen in subframe widgets in
  addition to main frame ones.  When fullscreen is entered,
  ViewMsg_Resize is sent to all widgets on the page.  WebFrameWidgets
  now also support picking up the fullscreen change and calling into
  the page's FullscreenController.
- blink::Fullscreen and FullscreenController now support entering
  fullscreen for <iframe> elements which contain out-of-process
  fullscreen elements.

There are still various issues to be dealt with in followup CLs:
- further refactoring ancestor walks in Fullscreen::requestFullscreen
  and exitFullscreen to be compatible with hierarchies with a
  RemoteFrame between LocalFrames (such as A-B-A).  This is needed to
  fire all ancestor fullscreenchange events properly in such cases.
- dealing with nested fullscreen elements.
- optimizing fullscreen layout in ancestor processes.
- correcting background color when fullscreening an OOP <iframe>
  element.

More info in design doc: https://goo.gl/Y5wdqi

This is a reland of https://codereview.chromium.org/1914643005/, with
the tests fixed for Mac by introducing an observer that waits for the
browser to finish the fullscreen transition (see issue 614304).

BUG=550497
TBR=dcheng@chromium.org
CQ_INCLUDE_TRYBOTS=tryserver.chromium.linux:linux_site_isolation

Committed: https://crrev.com/1f7eac4a2affa46f6c7eb53aba6a5baa72375e4c
Cr-Commit-Position: refs/heads/master@{#396027}

[alexmos, 2016-05-25 17:17:16]

Description was changed from

==========
Reland: Add support for entering/exiting HTML fullscreen from OOPIFs.

Currently, entering HTML fullscreen utilizes a number of ancestor
frame walks.  This is because entering fullscreen for an element (1)
alters layout for all its ancestor <iframes> (by applying
:-webkit-full-screen styles to them, which applies some UA CSS rules),
(2) fires fullscreenchange in all ancestor documents on <iframe>
elements along the ancestor chain, and (3) makes
document.webkitFullscreenElement return the <iframe> element
containing the fullscreened element in ancestor frames.

Currently, the logic behind this assumes that all ancestor frames are
local and does nothing when it encounters a remote frame.  This CL
takes the first step to fix this.

The existing flow for entering HTML fullscreen goes like this:
1. JS on the page calls element.webkitRequestFullscreen()
2. Fullscreen::requestFullscreen():
   a. Checks if fullscreen is allowed by ancestors (allowFullscreen)
   b. Creates fullscreenchange events for |element| and its ancestor
      <iframes> and saves them in its m_eventQueue.
   c. Puts |element| on its fullscreen element stack.
3. FullscreenController::enterFullScreenForElement(element)
   a. Saves |element| as provisional fullscreen element.
   b. Saves some page sizing info (to be restored after fullscreen)
4. RenderFrameImpl::enterFullscreen sends a FrameHostMsg_ToggleFullscreen
   to browser process.
5. RenderFrameHostImpl::OnToggleFullscreen() asks the current tab to
   enter fullscreen.
6. After the tab is resized for fullscreen, browser process generates a
   ViewMsg_Resize to the main frame renderer, with
   is_fullscreen_granted=1 in ResizeParams.
7. RenderWidget::Resize realizes there's a fullscreen change and calls
   into FullscreenController::didEnterFullScreen().
8. FullscreenController::didEnterFullScreen picks up the stored
   provisional fullscreen element and calls
   Fullscreen::didEnterFullScreenForElement on it.
9. Fullscreen::didEnterFullScreenForElement(element):
   a. Adjusts layout on |element| for fullscreen
   b. Sets fullscreen CSS styles on the fullscreen element and all
      ancestor elements.
   c. Fires fullscreenchange events from step 2b.

The main changes in this CL are:

- in step 5, before entering fullscreen for tab, we will send an IPC
  to ancestor OOPIFs so that they do steps 2 and 3 for their
  respective ancestor <iframe> elements (i.e., set up provisional
  fullscreen elements and prepare their share of the fullscreenchange
  events).
- ViewMsg_Resize will trigger fullscreen in subframe widgets in
  addition to main frame ones.  When fullscreen is entered,
  ViewMsg_Resize is sent to all widgets on the page.  WebFrameWidgets
  now also support picking up the fullscreen change and calling into
  the page's FullscreenController.
- blink::Fullscreen and FullscreenController now support entering
  fullscreen for <iframe> elements which contain out-of-process
  fullscreen elements.

There are still various issues to be dealt with in followup CLs:
- further refactoring ancestor walks in Fullscreen::requestFullscreen
  and exitFullscreen to be compatible with hierarchies with a
  RemoteFrame between LocalFrames (such as A-B-A).  This is needed to
  fire all ancestor fullscreenchange events properly in such cases.
- dealing with nested fullscreen elements.
- optimizing fullscreen layout in ancestor processes.
- correcting background color when fullscreening an OOP <iframe>
  element.

More info in design doc: https://goo.gl/Y5wdqi

This is a reland of https://codereview.chromium.org/1914643005/, with
the tests disabled for Mac until issue 614304 is solved.

BUG=550497
CQ_INCLUDE_TRYBOTS=tryserver.chromium.linux:linux_site_isolation
==========

to

==========
Reland: Add support for entering/exiting HTML fullscreen from OOPIFs.

Currently, entering HTML fullscreen utilizes a number of ancestor
frame walks.  This is because entering fullscreen for an element (1)
alters layout for all its ancestor <iframes> (by applying
:-webkit-full-screen styles to them, which applies some UA CSS rules),
(2) fires fullscreenchange in all ancestor documents on <iframe>
elements along the ancestor chain, and (3) makes
document.webkitFullscreenElement return the <iframe> element
containing the fullscreened element in ancestor frames.

Currently, the logic behind this assumes that all ancestor frames are
local and does nothing when it encounters a remote frame.  This CL
takes the first step to fix this.

The existing flow for entering HTML fullscreen goes like this:
1. JS on the page calls element.webkitRequestFullscreen()
2. Fullscreen::requestFullscreen():
   a. Checks if fullscreen is allowed by ancestors (allowFullscreen)
   b. Creates fullscreenchange events for |element| and its ancestor
      <iframes> and saves them in its m_eventQueue.
   c. Puts |element| on its fullscreen element stack.
3. FullscreenController::enterFullScreenForElement(element)
   a. Saves |element| as provisional fullscreen element.
   b. Saves some page sizing info (to be restored after fullscreen)
4. RenderFrameImpl::enterFullscreen sends a FrameHostMsg_ToggleFullscreen
   to browser process.
5. RenderFrameHostImpl::OnToggleFullscreen() asks the current tab to
   enter fullscreen.
6. After the tab is resized for fullscreen, browser process generates a
   ViewMsg_Resize to the main frame renderer, with
   is_fullscreen_granted=1 in ResizeParams.
7. RenderWidget::Resize realizes there's a fullscreen change and calls
   into FullscreenController::didEnterFullScreen().
8. FullscreenController::didEnterFullScreen picks up the stored
   provisional fullscreen element and calls
   Fullscreen::didEnterFullScreenForElement on it.
9. Fullscreen::didEnterFullScreenForElement(element):
   a. Adjusts layout on |element| for fullscreen
   b. Sets fullscreen CSS styles on the fullscreen element and all
      ancestor elements.
   c. Fires fullscreenchange events from step 2b.

The main changes in this CL are:

- in step 5, before entering fullscreen for tab, we will send an IPC
  to ancestor OOPIFs so that they do steps 2 and 3 for their
  respective ancestor <iframe> elements (i.e., set up provisional
  fullscreen elements and prepare their share of the fullscreenchange
  events).
- ViewMsg_Resize will trigger fullscreen in subframe widgets in
  addition to main frame ones.  When fullscreen is entered,
  ViewMsg_Resize is sent to all widgets on the page.  WebFrameWidgets
  now also support picking up the fullscreen change and calling into
  the page's FullscreenController.
- blink::Fullscreen and FullscreenController now support entering
  fullscreen for <iframe> elements which contain out-of-process
  fullscreen elements.

There are still various issues to be dealt with in followup CLs:
- further refactoring ancestor walks in Fullscreen::requestFullscreen
  and exitFullscreen to be compatible with hierarchies with a
  RemoteFrame between LocalFrames (such as A-B-A).  This is needed to
  fire all ancestor fullscreenchange events properly in such cases.
- dealing with nested fullscreen elements.
- optimizing fullscreen layout in ancestor processes.
- correcting background color when fullscreening an OOP <iframe>
  element.

More info in design doc: https://goo.gl/Y5wdqi

This is a reland of https://codereview.chromium.org/1914643005/, with
the tests fixed for Mac by introducing an observer that waits for the
browser to finish the fullscreen transition (see issue 614304).

BUG=550497
CQ_INCLUDE_TRYBOTS=tryserver.chromium.linux:linux_site_isolation
==========

[alexmos, 2016-05-25 17:23:31]

alexmos@chromium.org changed reviewers:
+ creis@chromium.org, dcheng@chromium.org

[alexmos, 2016-05-25 17:23:32]

Charlie, can you please take a look?  I think I've fixed the tests for Mac: see
PS1->PS3.  I wrote up the problem in issue 614304: basically, Macs have a
one-second enter fullscreen animation, and if we tried to exit fullscreen during
that transition, the request would be dropped.  I added an observer that should
wait for that animation to finish; I saw that this observer is also used in
other fullscreen-related browser tests, so I just used it the same way.

[alexmos, 2016-05-25 17:25:22]

Description was changed from

==========
Reland: Add support for entering/exiting HTML fullscreen from OOPIFs.

Currently, entering HTML fullscreen utilizes a number of ancestor
frame walks.  This is because entering fullscreen for an element (1)
alters layout for all its ancestor <iframes> (by applying
:-webkit-full-screen styles to them, which applies some UA CSS rules),
(2) fires fullscreenchange in all ancestor documents on <iframe>
elements along the ancestor chain, and (3) makes
document.webkitFullscreenElement return the <iframe> element
containing the fullscreened element in ancestor frames.

Currently, the logic behind this assumes that all ancestor frames are
local and does nothing when it encounters a remote frame.  This CL
takes the first step to fix this.

The existing flow for entering HTML fullscreen goes like this:
1. JS on the page calls element.webkitRequestFullscreen()
2. Fullscreen::requestFullscreen():
   a. Checks if fullscreen is allowed by ancestors (allowFullscreen)
   b. Creates fullscreenchange events for |element| and its ancestor
      <iframes> and saves them in its m_eventQueue.
   c. Puts |element| on its fullscreen element stack.
3. FullscreenController::enterFullScreenForElement(element)
   a. Saves |element| as provisional fullscreen element.
   b. Saves some page sizing info (to be restored after fullscreen)
4. RenderFrameImpl::enterFullscreen sends a FrameHostMsg_ToggleFullscreen
   to browser process.
5. RenderFrameHostImpl::OnToggleFullscreen() asks the current tab to
   enter fullscreen.
6. After the tab is resized for fullscreen, browser process generates a
   ViewMsg_Resize to the main frame renderer, with
   is_fullscreen_granted=1 in ResizeParams.
7. RenderWidget::Resize realizes there's a fullscreen change and calls
   into FullscreenController::didEnterFullScreen().
8. FullscreenController::didEnterFullScreen picks up the stored
   provisional fullscreen element and calls
   Fullscreen::didEnterFullScreenForElement on it.
9. Fullscreen::didEnterFullScreenForElement(element):
   a. Adjusts layout on |element| for fullscreen
   b. Sets fullscreen CSS styles on the fullscreen element and all
      ancestor elements.
   c. Fires fullscreenchange events from step 2b.

The main changes in this CL are:

- in step 5, before entering fullscreen for tab, we will send an IPC
  to ancestor OOPIFs so that they do steps 2 and 3 for their
  respective ancestor <iframe> elements (i.e., set up provisional
  fullscreen elements and prepare their share of the fullscreenchange
  events).
- ViewMsg_Resize will trigger fullscreen in subframe widgets in
  addition to main frame ones.  When fullscreen is entered,
  ViewMsg_Resize is sent to all widgets on the page.  WebFrameWidgets
  now also support picking up the fullscreen change and calling into
  the page's FullscreenController.
- blink::Fullscreen and FullscreenController now support entering
  fullscreen for <iframe> elements which contain out-of-process
  fullscreen elements.

There are still various issues to be dealt with in followup CLs:
- further refactoring ancestor walks in Fullscreen::requestFullscreen
  and exitFullscreen to be compatible with hierarchies with a
  RemoteFrame between LocalFrames (such as A-B-A).  This is needed to
  fire all ancestor fullscreenchange events properly in such cases.
- dealing with nested fullscreen elements.
- optimizing fullscreen layout in ancestor processes.
- correcting background color when fullscreening an OOP <iframe>
  element.

More info in design doc: https://goo.gl/Y5wdqi

This is a reland of https://codereview.chromium.org/1914643005/, with
the tests fixed for Mac by introducing an observer that waits for the
browser to finish the fullscreen transition (see issue 614304).

BUG=550497
CQ_INCLUDE_TRYBOTS=tryserver.chromium.linux:linux_site_isolation
==========

to

==========
Reland: Add support for entering/exiting HTML fullscreen from OOPIFs.

Currently, entering HTML fullscreen utilizes a number of ancestor
frame walks.  This is because entering fullscreen for an element (1)
alters layout for all its ancestor <iframes> (by applying
:-webkit-full-screen styles to them, which applies some UA CSS rules),
(2) fires fullscreenchange in all ancestor documents on <iframe>
elements along the ancestor chain, and (3) makes
document.webkitFullscreenElement return the <iframe> element
containing the fullscreened element in ancestor frames.

Currently, the logic behind this assumes that all ancestor frames are
local and does nothing when it encounters a remote frame.  This CL
takes the first step to fix this.

The existing flow for entering HTML fullscreen goes like this:
1. JS on the page calls element.webkitRequestFullscreen()
2. Fullscreen::requestFullscreen():
   a. Checks if fullscreen is allowed by ancestors (allowFullscreen)
   b. Creates fullscreenchange events for |element| and its ancestor
      <iframes> and saves them in its m_eventQueue.
   c. Puts |element| on its fullscreen element stack.
3. FullscreenController::enterFullScreenForElement(element)
   a. Saves |element| as provisional fullscreen element.
   b. Saves some page sizing info (to be restored after fullscreen)
4. RenderFrameImpl::enterFullscreen sends a FrameHostMsg_ToggleFullscreen
   to browser process.
5. RenderFrameHostImpl::OnToggleFullscreen() asks the current tab to
   enter fullscreen.
6. After the tab is resized for fullscreen, browser process generates a
   ViewMsg_Resize to the main frame renderer, with
   is_fullscreen_granted=1 in ResizeParams.
7. RenderWidget::Resize realizes there's a fullscreen change and calls
   into FullscreenController::didEnterFullScreen().
8. FullscreenController::didEnterFullScreen picks up the stored
   provisional fullscreen element and calls
   Fullscreen::didEnterFullScreenForElement on it.
9. Fullscreen::didEnterFullScreenForElement(element):
   a. Adjusts layout on |element| for fullscreen
   b. Sets fullscreen CSS styles on the fullscreen element and all
      ancestor elements.
   c. Fires fullscreenchange events from step 2b.

The main changes in this CL are:

- in step 5, before entering fullscreen for tab, we will send an IPC
  to ancestor OOPIFs so that they do steps 2 and 3 for their
  respective ancestor <iframe> elements (i.e., set up provisional
  fullscreen elements and prepare their share of the fullscreenchange
  events).
- ViewMsg_Resize will trigger fullscreen in subframe widgets in
  addition to main frame ones.  When fullscreen is entered,
  ViewMsg_Resize is sent to all widgets on the page.  WebFrameWidgets
  now also support picking up the fullscreen change and calling into
  the page's FullscreenController.
- blink::Fullscreen and FullscreenController now support entering
  fullscreen for <iframe> elements which contain out-of-process
  fullscreen elements.

There are still various issues to be dealt with in followup CLs:
- further refactoring ancestor walks in Fullscreen::requestFullscreen
  and exitFullscreen to be compatible with hierarchies with a
  RemoteFrame between LocalFrames (such as A-B-A).  This is needed to
  fire all ancestor fullscreenchange events properly in such cases.
- dealing with nested fullscreen elements.
- optimizing fullscreen layout in ancestor processes.
- correcting background color when fullscreening an OOP <iframe>
  element.

More info in design doc: https://goo.gl/Y5wdqi

This is a reland of https://codereview.chromium.org/1914643005/, with
the tests fixed for Mac by introducing an observer that waits for the
browser to finish the fullscreen transition (see issue 614304).

BUG=550497
CQ_INCLUDE_TRYBOTS=tryserver.chromium.linux:linux_site_isolation
==========

[Charlie Reis, 2016-05-25 18:20:26]

Nice find.  Diff from patch 1 to 3 LGTM!

[alexmos, 2016-05-25 18:22:05]

Description was changed from

==========
Reland: Add support for entering/exiting HTML fullscreen from OOPIFs.

Currently, entering HTML fullscreen utilizes a number of ancestor
frame walks.  This is because entering fullscreen for an element (1)
alters layout for all its ancestor <iframes> (by applying
:-webkit-full-screen styles to them, which applies some UA CSS rules),
(2) fires fullscreenchange in all ancestor documents on <iframe>
elements along the ancestor chain, and (3) makes
document.webkitFullscreenElement return the <iframe> element
containing the fullscreened element in ancestor frames.

Currently, the logic behind this assumes that all ancestor frames are
local and does nothing when it encounters a remote frame.  This CL
takes the first step to fix this.

The existing flow for entering HTML fullscreen goes like this:
1. JS on the page calls element.webkitRequestFullscreen()
2. Fullscreen::requestFullscreen():
   a. Checks if fullscreen is allowed by ancestors (allowFullscreen)
   b. Creates fullscreenchange events for |element| and its ancestor
      <iframes> and saves them in its m_eventQueue.
   c. Puts |element| on its fullscreen element stack.
3. FullscreenController::enterFullScreenForElement(element)
   a. Saves |element| as provisional fullscreen element.
   b. Saves some page sizing info (to be restored after fullscreen)
4. RenderFrameImpl::enterFullscreen sends a FrameHostMsg_ToggleFullscreen
   to browser process.
5. RenderFrameHostImpl::OnToggleFullscreen() asks the current tab to
   enter fullscreen.
6. After the tab is resized for fullscreen, browser process generates a
   ViewMsg_Resize to the main frame renderer, with
   is_fullscreen_granted=1 in ResizeParams.
7. RenderWidget::Resize realizes there's a fullscreen change and calls
   into FullscreenController::didEnterFullScreen().
8. FullscreenController::didEnterFullScreen picks up the stored
   provisional fullscreen element and calls
   Fullscreen::didEnterFullScreenForElement on it.
9. Fullscreen::didEnterFullScreenForElement(element):
   a. Adjusts layout on |element| for fullscreen
   b. Sets fullscreen CSS styles on the fullscreen element and all
      ancestor elements.
   c. Fires fullscreenchange events from step 2b.

The main changes in this CL are:

- in step 5, before entering fullscreen for tab, we will send an IPC
  to ancestor OOPIFs so that they do steps 2 and 3 for their
  respective ancestor <iframe> elements (i.e., set up provisional
  fullscreen elements and prepare their share of the fullscreenchange
  events).
- ViewMsg_Resize will trigger fullscreen in subframe widgets in
  addition to main frame ones.  When fullscreen is entered,
  ViewMsg_Resize is sent to all widgets on the page.  WebFrameWidgets
  now also support picking up the fullscreen change and calling into
  the page's FullscreenController.
- blink::Fullscreen and FullscreenController now support entering
  fullscreen for <iframe> elements which contain out-of-process
  fullscreen elements.

There are still various issues to be dealt with in followup CLs:
- further refactoring ancestor walks in Fullscreen::requestFullscreen
  and exitFullscreen to be compatible with hierarchies with a
  RemoteFrame between LocalFrames (such as A-B-A).  This is needed to
  fire all ancestor fullscreenchange events properly in such cases.
- dealing with nested fullscreen elements.
- optimizing fullscreen layout in ancestor processes.
- correcting background color when fullscreening an OOP <iframe>
  element.

More info in design doc: https://goo.gl/Y5wdqi

This is a reland of https://codereview.chromium.org/1914643005/, with
the tests fixed for Mac by introducing an observer that waits for the
browser to finish the fullscreen transition (see issue 614304).

BUG=550497
CQ_INCLUDE_TRYBOTS=tryserver.chromium.linux:linux_site_isolation
==========

to

==========
Reland: Add support for entering/exiting HTML fullscreen from OOPIFs.

Currently, entering HTML fullscreen utilizes a number of ancestor
frame walks.  This is because entering fullscreen for an element (1)
alters layout for all its ancestor <iframes> (by applying
:-webkit-full-screen styles to them, which applies some UA CSS rules),
(2) fires fullscreenchange in all ancestor documents on <iframe>
elements along the ancestor chain, and (3) makes
document.webkitFullscreenElement return the <iframe> element
containing the fullscreened element in ancestor frames.

Currently, the logic behind this assumes that all ancestor frames are
local and does nothing when it encounters a remote frame.  This CL
takes the first step to fix this.

The existing flow for entering HTML fullscreen goes like this:
1. JS on the page calls element.webkitRequestFullscreen()
2. Fullscreen::requestFullscreen():
   a. Checks if fullscreen is allowed by ancestors (allowFullscreen)
   b. Creates fullscreenchange events for |element| and its ancestor
      <iframes> and saves them in its m_eventQueue.
   c. Puts |element| on its fullscreen element stack.
3. FullscreenController::enterFullScreenForElement(element)
   a. Saves |element| as provisional fullscreen element.
   b. Saves some page sizing info (to be restored after fullscreen)
4. RenderFrameImpl::enterFullscreen sends a FrameHostMsg_ToggleFullscreen
   to browser process.
5. RenderFrameHostImpl::OnToggleFullscreen() asks the current tab to
   enter fullscreen.
6. After the tab is resized for fullscreen, browser process generates a
   ViewMsg_Resize to the main frame renderer, with
   is_fullscreen_granted=1 in ResizeParams.
7. RenderWidget::Resize realizes there's a fullscreen change and calls
   into FullscreenController::didEnterFullScreen().
8. FullscreenController::didEnterFullScreen picks up the stored
   provisional fullscreen element and calls
   Fullscreen::didEnterFullScreenForElement on it.
9. Fullscreen::didEnterFullScreenForElement(element):
   a. Adjusts layout on |element| for fullscreen
   b. Sets fullscreen CSS styles on the fullscreen element and all
      ancestor elements.
   c. Fires fullscreenchange events from step 2b.

The main changes in this CL are:

- in step 5, before entering fullscreen for tab, we will send an IPC
  to ancestor OOPIFs so that they do steps 2 and 3 for their
  respective ancestor <iframe> elements (i.e., set up provisional
  fullscreen elements and prepare their share of the fullscreenchange
  events).
- ViewMsg_Resize will trigger fullscreen in subframe widgets in
  addition to main frame ones.  When fullscreen is entered,
  ViewMsg_Resize is sent to all widgets on the page.  WebFrameWidgets
  now also support picking up the fullscreen change and calling into
  the page's FullscreenController.
- blink::Fullscreen and FullscreenController now support entering
  fullscreen for <iframe> elements which contain out-of-process
  fullscreen elements.

There are still various issues to be dealt with in followup CLs:
- further refactoring ancestor walks in Fullscreen::requestFullscreen
  and exitFullscreen to be compatible with hierarchies with a
  RemoteFrame between LocalFrames (such as A-B-A).  This is needed to
  fire all ancestor fullscreenchange events properly in such cases.
- dealing with nested fullscreen elements.
- optimizing fullscreen layout in ancestor processes.
- correcting background color when fullscreening an OOP <iframe>
  element.

More info in design doc: https://goo.gl/Y5wdqi

This is a reland of https://codereview.chromium.org/1914643005/, with
the tests fixed for Mac by introducing an observer that waits for the
browser to finish the fullscreen transition (see issue 614304).

BUG=550497
TBR=dcheng@chromium.org
CQ_INCLUDE_TRYBOTS=tryserver.chromium.linux:linux_site_isolation
==========

[alexmos, 2016-05-25 18:24:22]

Thanks.  TBR-ing dcheng@ since other than the test update, there are no changes
compared to the original CL (https://codereview.chromium.org/1914643005/).

[alexmos, 2016-05-25 18:24:32]

The CQ bit was checked by alexmos@chromium.org

[commit-bot: I haz the power, 2016-05-25 18:25:12]

CQ is trying da patch. Follow status at
 https://chromium-cq-status.appspot.com/patch-status/2008873004/40001
View timeline at
 https://chromium-cq-status.appspot.com/patch-timeline/2008873004/40001

[dcheng, 2016-05-25 18:25:19]

lgtm

[commit-bot: I haz the power, 2016-05-25 20:37:50]

The CQ bit was unchecked by commit-bot@chromium.org

[commit-bot: I haz the power, 2016-05-25 20:37:52]

Try jobs failed on following builders:
  win_chromium_rel_ng on tryserver.chromium.win (JOB_FAILED,
http://build.chromium.org/p/tryserver.chromium.win/builders/win_chromium_rel_...)

[alexmos, 2016-05-25 20:39:06]

The CQ bit was checked by alexmos@chromium.org

[commit-bot: I haz the power, 2016-05-25 20:39:44]

CQ is trying da patch. Follow status at
 https://chromium-cq-status.appspot.com/patch-status/2008873004/40001
View timeline at
 https://chromium-cq-status.appspot.com/patch-timeline/2008873004/40001

[commit-bot: I haz the power, 2016-05-25 23:05:08]

Description was changed from

==========
Reland: Add support for entering/exiting HTML fullscreen from OOPIFs.

Currently, entering HTML fullscreen utilizes a number of ancestor
frame walks.  This is because entering fullscreen for an element (1)
alters layout for all its ancestor <iframes> (by applying
:-webkit-full-screen styles to them, which applies some UA CSS rules),
(2) fires fullscreenchange in all ancestor documents on <iframe>
elements along the ancestor chain, and (3) makes
document.webkitFullscreenElement return the <iframe> element
containing the fullscreened element in ancestor frames.

Currently, the logic behind this assumes that all ancestor frames are
local and does nothing when it encounters a remote frame.  This CL
takes the first step to fix this.

The existing flow for entering HTML fullscreen goes like this:
1. JS on the page calls element.webkitRequestFullscreen()
2. Fullscreen::requestFullscreen():
   a. Checks if fullscreen is allowed by ancestors (allowFullscreen)
   b. Creates fullscreenchange events for |element| and its ancestor
      <iframes> and saves them in its m_eventQueue.
   c. Puts |element| on its fullscreen element stack.
3. FullscreenController::enterFullScreenForElement(element)
   a. Saves |element| as provisional fullscreen element.
   b. Saves some page sizing info (to be restored after fullscreen)
4. RenderFrameImpl::enterFullscreen sends a FrameHostMsg_ToggleFullscreen
   to browser process.
5. RenderFrameHostImpl::OnToggleFullscreen() asks the current tab to
   enter fullscreen.
6. After the tab is resized for fullscreen, browser process generates a
   ViewMsg_Resize to the main frame renderer, with
   is_fullscreen_granted=1 in ResizeParams.
7. RenderWidget::Resize realizes there's a fullscreen change and calls
   into FullscreenController::didEnterFullScreen().
8. FullscreenController::didEnterFullScreen picks up the stored
   provisional fullscreen element and calls
   Fullscreen::didEnterFullScreenForElement on it.
9. Fullscreen::didEnterFullScreenForElement(element):
   a. Adjusts layout on |element| for fullscreen
   b. Sets fullscreen CSS styles on the fullscreen element and all
      ancestor elements.
   c. Fires fullscreenchange events from step 2b.

The main changes in this CL are:

- in step 5, before entering fullscreen for tab, we will send an IPC
  to ancestor OOPIFs so that they do steps 2 and 3 for their
  respective ancestor <iframe> elements (i.e., set up provisional
  fullscreen elements and prepare their share of the fullscreenchange
  events).
- ViewMsg_Resize will trigger fullscreen in subframe widgets in
  addition to main frame ones.  When fullscreen is entered,
  ViewMsg_Resize is sent to all widgets on the page.  WebFrameWidgets
  now also support picking up the fullscreen change and calling into
  the page's FullscreenController.
- blink::Fullscreen and FullscreenController now support entering
  fullscreen for <iframe> elements which contain out-of-process
  fullscreen elements.

There are still various issues to be dealt with in followup CLs:
- further refactoring ancestor walks in Fullscreen::requestFullscreen
  and exitFullscreen to be compatible with hierarchies with a
  RemoteFrame between LocalFrames (such as A-B-A).  This is needed to
  fire all ancestor fullscreenchange events properly in such cases.
- dealing with nested fullscreen elements.
- optimizing fullscreen layout in ancestor processes.
- correcting background color when fullscreening an OOP <iframe>
  element.

More info in design doc: https://goo.gl/Y5wdqi

This is a reland of https://codereview.chromium.org/1914643005/, with
the tests fixed for Mac by introducing an observer that waits for the
browser to finish the fullscreen transition (see issue 614304).

BUG=550497
TBR=dcheng@chromium.org
CQ_INCLUDE_TRYBOTS=tryserver.chromium.linux:linux_site_isolation
==========

to

==========
Reland: Add support for entering/exiting HTML fullscreen from OOPIFs.

Currently, entering HTML fullscreen utilizes a number of ancestor
frame walks.  This is because entering fullscreen for an element (1)
alters layout for all its ancestor <iframes> (by applying
:-webkit-full-screen styles to them, which applies some UA CSS rules),
(2) fires fullscreenchange in all ancestor documents on <iframe>
elements along the ancestor chain, and (3) makes
document.webkitFullscreenElement return the <iframe> element
containing the fullscreened element in ancestor frames.

Currently, the logic behind this assumes that all ancestor frames are
local and does nothing when it encounters a remote frame.  This CL
takes the first step to fix this.

The existing flow for entering HTML fullscreen goes like this:
1. JS on the page calls element.webkitRequestFullscreen()
2. Fullscreen::requestFullscreen():
   a. Checks if fullscreen is allowed by ancestors (allowFullscreen)
   b. Creates fullscreenchange events for |element| and its ancestor
      <iframes> and saves them in its m_eventQueue.
   c. Puts |element| on its fullscreen element stack.
3. FullscreenController::enterFullScreenForElement(element)
   a. Saves |element| as provisional fullscreen element.
   b. Saves some page sizing info (to be restored after fullscreen)
4. RenderFrameImpl::enterFullscreen sends a FrameHostMsg_ToggleFullscreen
   to browser process.
5. RenderFrameHostImpl::OnToggleFullscreen() asks the current tab to
   enter fullscreen.
6. After the tab is resized for fullscreen, browser process generates a
   ViewMsg_Resize to the main frame renderer, with
   is_fullscreen_granted=1 in ResizeParams.
7. RenderWidget::Resize realizes there's a fullscreen change and calls
   into FullscreenController::didEnterFullScreen().
8. FullscreenController::didEnterFullScreen picks up the stored
   provisional fullscreen element and calls
   Fullscreen::didEnterFullScreenForElement on it.
9. Fullscreen::didEnterFullScreenForElement(element):
   a. Adjusts layout on |element| for fullscreen
   b. Sets fullscreen CSS styles on the fullscreen element and all
      ancestor elements.
   c. Fires fullscreenchange events from step 2b.

The main changes in this CL are:

- in step 5, before entering fullscreen for tab, we will send an IPC
  to ancestor OOPIFs so that they do steps 2 and 3 for their
  respective ancestor <iframe> elements (i.e., set up provisional
  fullscreen elements and prepare their share of the fullscreenchange
  events).
- ViewMsg_Resize will trigger fullscreen in subframe widgets in
  addition to main frame ones.  When fullscreen is entered,
  ViewMsg_Resize is sent to all widgets on the page.  WebFrameWidgets
  now also support picking up the fullscreen change and calling into
  the page's FullscreenController.
- blink::Fullscreen and FullscreenController now support entering
  fullscreen for <iframe> elements which contain out-of-process
  fullscreen elements.

There are still various issues to be dealt with in followup CLs:
- further refactoring ancestor walks in Fullscreen::requestFullscreen
  and exitFullscreen to be compatible with hierarchies with a
  RemoteFrame between LocalFrames (such as A-B-A).  This is needed to
  fire all ancestor fullscreenchange events properly in such cases.
- dealing with nested fullscreen elements.
- optimizing fullscreen layout in ancestor processes.
- correcting background color when fullscreening an OOP <iframe>
  element.

More info in design doc: https://goo.gl/Y5wdqi

This is a reland of https://codereview.chromium.org/1914643005/, with
the tests fixed for Mac by introducing an observer that waits for the
browser to finish the fullscreen transition (see issue 614304).

BUG=550497
TBR=dcheng@chromium.org
CQ_INCLUDE_TRYBOTS=tryserver.chromium.linux:linux_site_isolation
==========

[commit-bot: I haz the power, 2016-05-25 23:05:10]

Committed patchset #3 (id:40001)

[commit-bot: I haz the power, 2016-05-25 23:06:27]

Description was changed from

==========
Reland: Add support for entering/exiting HTML fullscreen from OOPIFs.

Currently, entering HTML fullscreen utilizes a number of ancestor
frame walks.  This is because entering fullscreen for an element (1)
alters layout for all its ancestor <iframes> (by applying
:-webkit-full-screen styles to them, which applies some UA CSS rules),
(2) fires fullscreenchange in all ancestor documents on <iframe>
elements along the ancestor chain, and (3) makes
document.webkitFullscreenElement return the <iframe> element
containing the fullscreened element in ancestor frames.

Currently, the logic behind this assumes that all ancestor frames are
local and does nothing when it encounters a remote frame.  This CL
takes the first step to fix this.

The existing flow for entering HTML fullscreen goes like this:
1. JS on the page calls element.webkitRequestFullscreen()
2. Fullscreen::requestFullscreen():
   a. Checks if fullscreen is allowed by ancestors (allowFullscreen)
   b. Creates fullscreenchange events for |element| and its ancestor
      <iframes> and saves them in its m_eventQueue.
   c. Puts |element| on its fullscreen element stack.
3. FullscreenController::enterFullScreenForElement(element)
   a. Saves |element| as provisional fullscreen element.
   b. Saves some page sizing info (to be restored after fullscreen)
4. RenderFrameImpl::enterFullscreen sends a FrameHostMsg_ToggleFullscreen
   to browser process.
5. RenderFrameHostImpl::OnToggleFullscreen() asks the current tab to
   enter fullscreen.
6. After the tab is resized for fullscreen, browser process generates a
   ViewMsg_Resize to the main frame renderer, with
   is_fullscreen_granted=1 in ResizeParams.
7. RenderWidget::Resize realizes there's a fullscreen change and calls
   into FullscreenController::didEnterFullScreen().
8. FullscreenController::didEnterFullScreen picks up the stored
   provisional fullscreen element and calls
   Fullscreen::didEnterFullScreenForElement on it.
9. Fullscreen::didEnterFullScreenForElement(element):
   a. Adjusts layout on |element| for fullscreen
   b. Sets fullscreen CSS styles on the fullscreen element and all
      ancestor elements.
   c. Fires fullscreenchange events from step 2b.

The main changes in this CL are:

- in step 5, before entering fullscreen for tab, we will send an IPC
  to ancestor OOPIFs so that they do steps 2 and 3 for their
  respective ancestor <iframe> elements (i.e., set up provisional
  fullscreen elements and prepare their share of the fullscreenchange
  events).
- ViewMsg_Resize will trigger fullscreen in subframe widgets in
  addition to main frame ones.  When fullscreen is entered,
  ViewMsg_Resize is sent to all widgets on the page.  WebFrameWidgets
  now also support picking up the fullscreen change and calling into
  the page's FullscreenController.
- blink::Fullscreen and FullscreenController now support entering
  fullscreen for <iframe> elements which contain out-of-process
  fullscreen elements.

There are still various issues to be dealt with in followup CLs:
- further refactoring ancestor walks in Fullscreen::requestFullscreen
  and exitFullscreen to be compatible with hierarchies with a
  RemoteFrame between LocalFrames (such as A-B-A).  This is needed to
  fire all ancestor fullscreenchange events properly in such cases.
- dealing with nested fullscreen elements.
- optimizing fullscreen layout in ancestor processes.
- correcting background color when fullscreening an OOP <iframe>
  element.

More info in design doc: https://goo.gl/Y5wdqi

This is a reland of https://codereview.chromium.org/1914643005/, with
the tests fixed for Mac by introducing an observer that waits for the
browser to finish the fullscreen transition (see issue 614304).

BUG=550497
TBR=dcheng@chromium.org
CQ_INCLUDE_TRYBOTS=tryserver.chromium.linux:linux_site_isolation
==========

to

==========
Reland: Add support for entering/exiting HTML fullscreen from OOPIFs.

Currently, entering HTML fullscreen utilizes a number of ancestor
frame walks.  This is because entering fullscreen for an element (1)
alters layout for all its ancestor <iframes> (by applying
:-webkit-full-screen styles to them, which applies some UA CSS rules),
(2) fires fullscreenchange in all ancestor documents on <iframe>
elements along the ancestor chain, and (3) makes
document.webkitFullscreenElement return the <iframe> element
containing the fullscreened element in ancestor frames.

Currently, the logic behind this assumes that all ancestor frames are
local and does nothing when it encounters a remote frame.  This CL
takes the first step to fix this.

The existing flow for entering HTML fullscreen goes like this:
1. JS on the page calls element.webkitRequestFullscreen()
2. Fullscreen::requestFullscreen():
   a. Checks if fullscreen is allowed by ancestors (allowFullscreen)
   b. Creates fullscreenchange events for |element| and its ancestor
      <iframes> and saves them in its m_eventQueue.
   c. Puts |element| on its fullscreen element stack.
3. FullscreenController::enterFullScreenForElement(element)
   a. Saves |element| as provisional fullscreen element.
   b. Saves some page sizing info (to be restored after fullscreen)
4. RenderFrameImpl::enterFullscreen sends a FrameHostMsg_ToggleFullscreen
   to browser process.
5. RenderFrameHostImpl::OnToggleFullscreen() asks the current tab to
   enter fullscreen.
6. After the tab is resized for fullscreen, browser process generates a
   ViewMsg_Resize to the main frame renderer, with
   is_fullscreen_granted=1 in ResizeParams.
7. RenderWidget::Resize realizes there's a fullscreen change and calls
   into FullscreenController::didEnterFullScreen().
8. FullscreenController::didEnterFullScreen picks up the stored
   provisional fullscreen element and calls
   Fullscreen::didEnterFullScreenForElement on it.
9. Fullscreen::didEnterFullScreenForElement(element):
   a. Adjusts layout on |element| for fullscreen
   b. Sets fullscreen CSS styles on the fullscreen element and all
      ancestor elements.
   c. Fires fullscreenchange events from step 2b.

The main changes in this CL are:

- in step 5, before entering fullscreen for tab, we will send an IPC
  to ancestor OOPIFs so that they do steps 2 and 3 for their
  respective ancestor <iframe> elements (i.e., set up provisional
  fullscreen elements and prepare their share of the fullscreenchange
  events).
- ViewMsg_Resize will trigger fullscreen in subframe widgets in
  addition to main frame ones.  When fullscreen is entered,
  ViewMsg_Resize is sent to all widgets on the page.  WebFrameWidgets
  now also support picking up the fullscreen change and calling into
  the page's FullscreenController.
- blink::Fullscreen and FullscreenController now support entering
  fullscreen for <iframe> elements which contain out-of-process
  fullscreen elements.

There are still various issues to be dealt with in followup CLs:
- further refactoring ancestor walks in Fullscreen::requestFullscreen
  and exitFullscreen to be compatible with hierarchies with a
  RemoteFrame between LocalFrames (such as A-B-A).  This is needed to
  fire all ancestor fullscreenchange events properly in such cases.
- dealing with nested fullscreen elements.
- optimizing fullscreen layout in ancestor processes.
- correcting background color when fullscreening an OOP <iframe>
  element.

More info in design doc: https://goo.gl/Y5wdqi

This is a reland of https://codereview.chromium.org/1914643005/, with
the tests fixed for Mac by introducing an observer that waits for the
browser to finish the fullscreen transition (see issue 614304).

BUG=550497
TBR=dcheng@chromium.org
CQ_INCLUDE_TRYBOTS=tryserver.chromium.linux:linux_site_isolation

Committed: https://crrev.com/1f7eac4a2affa46f6c7eb53aba6a5baa72375e4c
Cr-Commit-Position: refs/heads/master@{#396027}
==========

[commit-bot: I haz the power, 2016-05-25 23:06:29]

Patchset 3 (id:??) landed as
https://crrev.com/1f7eac4a2affa46f6c7eb53aba6a5baa72375e4c
Cr-Commit-Position: refs/heads/master@{#396027}