aura: Add fullscreen/popups to RenderWidgetHostViewAura.

content/browser/renderer_host/render_widget_host_view_aura.cc

 // Copyright (c) 2011 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/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/logging.h"
 #include "content/browser/renderer_host/backing_store_skia.h"
 #include "content/browser/renderer_host/web_input_event_aura.h"
 #include "content/browser/renderer_host/render_widget_host.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebScreenInfo.h"
 #include "ui/aura/aura_constants.h"
 #include "ui/aura/desktop.h"
 #include "ui/aura/event.h"
 #include "ui/aura/hit_test.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/compositor/layer.h"
+#include "ui/gfx/screen.h"
+#include "views/widget/native_widget_aura.h"
+#include "views/widget/widget.h"
 
 #if defined(UI_COMPOSITOR_IMAGE_TRANSPORT)
 #include "base/bind.h"
 #include "content/browser/gpu/gpu_process_host_ui_shim.h"
 #include "content/browser/renderer_host/accelerated_surface_container_linux.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "ui/gfx/gl/gl_bindings.h"
 #endif
 
 using WebKit::WebTouchEvent;
@@ skipping 41 matching lines @@
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, public:
 
 RenderWidgetHostViewAura::RenderWidgetHostViewAura(RenderWidgetHost* host)
     : host_(host),
       ALLOW_THIS_IN_INITIALIZER_LIST(window_(new aura::Window(this))),
+      is_fullscreen_(false),
+      popup_parent_host_view_(NULL),
       is_loading_(false) {
   host_->SetView(this);
 }
 
 RenderWidgetHostViewAura::~RenderWidgetHostViewAura() {
 }
 
 void RenderWidgetHostViewAura::Init() {
   window_->Init(ui::Layer::LAYER_HAS_TEXTURE);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, RenderWidgetHostView implementation:
 
 void RenderWidgetHostViewAura::InitAsPopup(
     RenderWidgetHostView* parent_host_view,
     const gfx::Rect& pos) {
-  NOTIMPLEMENTED();
-  // TODO(ivankr): there has to be an Init() call, otherwise |window_|
-  // is left uninitialized and will eventually crash.
   Init();
+  popup_parent_host_view_ =
+      static_cast<RenderWidgetHostViewAura*>(parent_host_view);
+  window_->SetProperty(

[Daniel Erat, 2011/10/28 14:56:16]

Thoughts about whether this should be exposed by a method in aura::Window?  My
main concern is that it'll get confused with Window::type_; the current progress
wrt getting rid of that is unclear to me.

[Ben Goodger (Google), 2011/10/28 16:27:53]

I would like to get rid of Window::type_, mostly because type-specific
functionality is something we should try and keep out of Window (normally
type-specific behavior is restricted to things like stacking, parenting, etc,
all of which are done in the shell.)

[Daniel Erat, 2011/10/28 17:04:25]

I agree with the sentiment, but it seems like we still need some way for the
code that's creating these windows to pass a type to the shell so the shell
knows what to do with them.

+      views::NativeWidgetAura::kWindowTypeKey,
+      reinterpret_cast<void*>(views::Widget::InitParams::TYPE_MENU));

[Ben Goodger (Google), 2011/10/28 16:27:53]

However, you can't use views types here, because src/content does not depend on
src/views.

Despite wanting to get rid of Window::type_ above, I do wonder if we should
define some basic types in aura that users (like this code) can set.

This would resolve the DEPs issues. What do you think?

[Daniel Erat, 2011/10/28 17:04:25]

Of the values currently in ui/aura/window_types.h, kWindowType_Control appears
to be the only one that's used, and just so that
NativeWidgetAura::InitNativeWidget() can ask Window::Init() to call
layer_->SetVisible(true).  It seems like that could be removed in favor of
adding an initially_visible param to Window::Init().

The duplication between views::Widget::InitParams::Type and whatever type would
live in aura::Window is problematic, though.  That being said, it looks like we
have effectively just two types of windows right now from the shell's
perspective (menu/tooltip and everything else), so maybe we could do what you're
suggesting.  It seems reasonable to me to put a few types in
ui/aura/window_types.h, make NativeWidgetAura set it appropriately based on the
widget's type, and make the shell check the Window's type instead of the
views::NativeWidgetAura::kWindowTypeKey property.

+  window_->SetParent(NULL);
+  Show();
+  SetBounds(pos);
 }
 
 void RenderWidgetHostViewAura::InitAsFullscreen(
     RenderWidgetHostView* reference_host_view) {
-  NOTIMPLEMENTED();
-  // TODO(ivankr): there has to be an Init() call, otherwise |window_|
-  // is left uninitialized and will eventually crash.
   Init();
+  is_fullscreen_ = true;
+  window_->SetProperty(
+      views::NativeWidgetAura::kWindowTypeKey,
+      reinterpret_cast<void*>(views::Widget::InitParams::TYPE_POPUP));
+  window_->SetParent(NULL);
+  window_->Fullscreen();
+  Show();
+  Focus();
+  // TODO(derat): The window is visible but it's not being updated.  Figure out
+  // why.
 }
 
 RenderWidgetHost* RenderWidgetHostViewAura::GetRenderWidgetHost() const {
   return host_;
 }
 
 void RenderWidgetHostViewAura::DidBecomeSelected() {
   host_->WasRestored();
 }
 
 void RenderWidgetHostViewAura::WasHidden() {
   host_->WasHidden();
 }
 
 void RenderWidgetHostViewAura::SetSize(const gfx::Size& size) {
   SetBounds(gfx::Rect(window_->bounds().origin(), size));
 }
 
 void RenderWidgetHostViewAura::SetBounds(const gfx::Rect& rect) {
-  window_->SetBounds(rect);
+  gfx::Rect adjusted_rect = rect;
+
+  if (popup_parent_host_view_) {
+    gfx::Point translated_origin = adjusted_rect.origin();
+    // |rect| is relative to |popup_parent_host_view_|; translate it for the
+    // window's container.
+    aura::Window::ConvertPointToWindow(
+        popup_parent_host_view_->window_,
+        window_->parent(),
+        &translated_origin);
+    adjusted_rect.set_origin(translated_origin);
+  }
+
+  window_->SetBounds(adjusted_rect);
   host_->WasResized();
 }
 
 gfx::NativeView RenderWidgetHostViewAura::GetNativeView() const {
   return window_;
 }
 
 gfx::NativeViewId RenderWidgetHostViewAura::GetNativeViewId() const {
   return static_cast<gfx::NativeViewId>(NULL);
 }
@@ skipping 138 matching lines @@
   RenderWidgetHostView::SetBackground(background);
   host_->SetBackground(background);
 #if defined(UI_COMPOSITOR_IMAGE_TRANSPORT)
   window_->layer()->SetFillsBoundsOpaquely(background.isOpaque());
 #endif
 }
 
 #if defined(OS_POSIX)
 void RenderWidgetHostViewAura::GetDefaultScreenInfo(
     WebKit::WebScreenInfo* results) {
-  NOTIMPLEMENTED();
+  GetScreenInfo(results);
 }
 
 void RenderWidgetHostViewAura::GetScreenInfo(WebKit::WebScreenInfo* results) {
-  NOTIMPLEMENTED();
+  const gfx::Size size = gfx::Screen::GetPrimaryMonitorSize();
+  results->rect = WebKit::WebRect(0, 0, size.width(), size.height());
+  results->availableRect = results->rect;
+  // TODO(derat): Don't hardcode this?
+  results->depth = 24;
+  results->depthPerComponent = 8;
 }
 
 gfx::Rect RenderWidgetHostViewAura::GetRootWindowBounds() {
-  NOTIMPLEMENTED();
-  return gfx::Rect();
+  return aura::Desktop::GetInstance()->bounds();
 }
 #endif
 
 void RenderWidgetHostViewAura::SetVisuallyDeemphasized(const SkColor* color,
                                                        bool animate) {
   NOTIMPLEMENTED();
 }
 
 void RenderWidgetHostViewAura::UnhandledWheelEvent(
     const WebKit::WebMouseWheelEvent& event) {
@@ skipping 59 matching lines @@
 
 void RenderWidgetHostViewAura::OnFocus() {
   host_->GotFocus();
 }
 
 void RenderWidgetHostViewAura::OnBlur() {
   host_->Blur();
 }
 
 bool RenderWidgetHostViewAura::OnKeyEvent(aura::KeyEvent* event) {
-  NativeWebKeyboardEvent webkit_event(event);
-  host_->ForwardKeyboardEvent(webkit_event);
+  // We need to handle the Escape key for Pepper Flash.
+  if (is_fullscreen_ && event->key_code() == ui::VKEY_ESCAPE) {
+    host_->Shutdown();
+  } else {
+    NativeWebKeyboardEvent webkit_event(event);
+    host_->ForwardKeyboardEvent(webkit_event);
+  }
   return true;
 }
 
 gfx::NativeCursor RenderWidgetHostViewAura::GetCursor(const gfx::Point& point) {
   // TODO(beng): talk to beng before implementing this.
   //NOTIMPLEMENTED();
   return gfx::kNullCursor;
 }
 
 int RenderWidgetHostViewAura::GetNonClientComponent(
@@ skipping 79 matching lines @@
 }
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, private:
 
 void RenderWidgetHostViewAura::UpdateCursorIfOverSelf() {
   //NOTIMPLEMENTED();
   // TODO(beng): See RenderWidgetHostViewWin.
 }