make menus, bubbles, etc. top level windows on aura

ui/views/widget/desktop_aura/desktop_root_window_host_win.cc

 // Copyright (c) 2012 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 "ui/views/widget/desktop_aura/desktop_root_window_host_win.h"
 
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/cursor/cursor_loader_win.h"
 #include "ui/base/ime/input_method_win.h"
 #include "ui/base/win/shell.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/path_win.h"
 #include "ui/native_theme/native_theme_aura.h"
 #include "ui/native_theme/native_theme_win.h"
 #include "ui/views/corewm/compound_event_filter.h"
 #include "ui/views/corewm/corewm_switches.h"
 #include "ui/views/corewm/cursor_manager.h"
 #include "ui/views/corewm/focus_controller.h"
 #include "ui/views/corewm/input_method_event_filter.h"
+#include "ui/views/corewm/window_animations.h"
 #include "ui/views/ime/input_method_bridge.h"
 #include "ui/views/widget/desktop_aura/desktop_activation_client.h"
 #include "ui/views/widget/desktop_aura/desktop_capture_client.h"
 #include "ui/views/widget/desktop_aura/desktop_dispatcher_client.h"
 #include "ui/views/widget/desktop_aura/desktop_drag_drop_client_win.h"
 #include "ui/views/widget/desktop_aura/desktop_focus_rules.h"
 #include "ui/views/widget/desktop_aura/desktop_native_cursor_manager.h"
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 #include "ui/views/widget/desktop_aura/desktop_screen_position_client.h"
 #include "ui/views/widget/root_view.h"
@@ skipping 12 matching lines @@
 
 DesktopRootWindowHostWin::DesktopRootWindowHostWin(
     internal::NativeWidgetDelegate* native_widget_delegate,
     DesktopNativeWidgetAura* desktop_native_widget_aura,
     const gfx::Rect& initial_bounds)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
           message_handler_(new HWNDMessageHandler(this))),
       native_widget_delegate_(native_widget_delegate),
       desktop_native_widget_aura_(desktop_native_widget_aura),
       root_window_host_delegate_(NULL),
-      content_window_(NULL) {
+      content_window_(NULL),
+      should_animate_window_close_(false),
+      pending_close_(false) {
 }
 
 DesktopRootWindowHostWin::~DesktopRootWindowHostWin() {
   if (corewm::UseFocusControllerOnDesktop()) {
     aura::client::SetFocusClient(root_window_, NULL);
     aura::client::SetActivationClient(root_window_, NULL);
   }
 }
 
 // static
@@ skipping 88 matching lines @@
 
   desktop_native_widget_aura_->InstallInputMethodEventFilter(root_window_);
 
   drag_drop_client_.reset(new DesktopDragDropClientWin(root_window_,
                                                        GetHWND()));
   aura::client::SetDragDropClient(root_window_, drag_drop_client_.get());
 
   focus_client_->FocusWindow(content_window_);
   root_window_->SetProperty(kContentWindowForRootWindow, content_window_);
 
+  aura::client::SetAnimationHost(content_window_, this);
+
+  should_animate_window_close_ =
+      content_window_->type() != aura::client::WINDOW_TYPE_NORMAL &&
+      !views::corewm::WindowAnimationsDisabled(content_window_);
+
   return root_window_;
 }
 
+void DesktopRootWindowHostWin::InitFocus(aura::Window* window) {
+  focus_client_->FocusWindow(window);
+}
+
 void DesktopRootWindowHostWin::Close() {
-  message_handler_->Close();
+  if (should_animate_window_close_) {
+    pending_close_ = true;
+    // OnWindowHidingAnimationCompleted does the actual Close.
+    content_window_->Hide();
+  } else {
+    message_handler_->Close();
+  }
 }
 
 void DesktopRootWindowHostWin::CloseNow() {
   message_handler_->CloseNow();
 }
 
 aura::RootWindowHost* DesktopRootWindowHostWin::AsRootWindowHost() {
   return this;
 }
 
@@ skipping 177 matching lines @@
 
 gfx::AcceleratedWidget DesktopRootWindowHostWin::GetAcceleratedWidget() {
   return message_handler_->hwnd();
 }
 
 void DesktopRootWindowHostWin::Show() {
   message_handler_->Show();
 }
 
 void DesktopRootWindowHostWin::Hide() {
-  message_handler_->Hide();
+  if (!pending_close_)
+    message_handler_->Hide();
 }
 
 void DesktopRootWindowHostWin::ToggleFullScreen() {
 }
 
 gfx::Rect DesktopRootWindowHostWin::GetBounds() const {
   // Match the logic in HWNDMessageHandler::ClientAreaSizeChanged().
-  return WidgetSizeIsClientSize() ?
-      GetClientAreaBoundsInScreen() : GetWindowBoundsInScreen();
+  gfx::Rect bounds(WidgetSizeIsClientSize() ? GetClientAreaBoundsInScreen()
+                                            : GetWindowBoundsInScreen());
+  gfx::Rect without_expansion(bounds.x() - window_expansion_.x(),
+                              bounds.y() - window_expansion_.y(),
+                              bounds.width() - window_expansion_.width(),
+                              bounds.height() - window_expansion_.height());
+  return without_expansion;
 }
 
 void DesktopRootWindowHostWin::SetBounds(const gfx::Rect& bounds) {
-  message_handler_->SetBounds(bounds);
+  gfx::Rect expanded(bounds.x() + window_expansion_.x(),
+                     bounds.y() + window_expansion_.y(),
+                     bounds.width() + window_expansion_.width(),
+                     bounds.height() + window_expansion_.height());
+  message_handler_->SetBounds(expanded);
 }
 
 gfx::Insets DesktopRootWindowHostWin::GetInsets() const {
   return gfx::Insets();
 }
 
 void DesktopRootWindowHostWin::SetInsets(const gfx::Insets& insets) {
 }
 
 gfx::Point DesktopRootWindowHostWin::GetLocationOnNativeScreen() const {
@@ skipping 55 matching lines @@
 }
 
 void DesktopRootWindowHostWin::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
 }
 
 void DesktopRootWindowHostWin::PrepareForShutdown() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// DesktopRootWindowHostWin, aura::WindowAnimationHost implementation:
+
+void DesktopRootWindowHostWin::SetHostTransitionBounds(
+    const gfx::Rect& bounds) {
+  gfx::Rect bounds_without_expansion = GetBounds();
+  window_expansion_ = bounds;
+  SetBounds(bounds_without_expansion);
+}
+
+void DesktopRootWindowHostWin::OnWindowHidingAnimationCompleted() {
+  if (pending_close_)
+    message_handler_->Close();
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // DesktopRootWindowHostWin, HWNDMessageHandlerDelegate implementation:
 
 bool DesktopRootWindowHostWin::IsWidgetWindow() const {
   return true;
 }
 
 bool DesktopRootWindowHostWin::IsUsingCustomFrame() const {
   return !GetWidget()->ShouldUseNativeFrame();
 }
 
@@ skipping 181 matching lines @@
 void DesktopRootWindowHostWin::HandleWorkAreaChanged() {
   GetWidget()->widget_delegate()->OnWorkAreaChanged();
 }
 
 void DesktopRootWindowHostWin::HandleVisibilityChanged(bool visible) {
   native_widget_delegate_->OnNativeWidgetVisibilityChanged(visible);
 }
 
 void DesktopRootWindowHostWin::HandleClientSizeChanged(
     const gfx::Size& new_size) {
+  gfx::Size without_expansion(new_size.width() - window_expansion_.width(),
+                              new_size.height() - window_expansion_.height());
   if (root_window_host_delegate_)
     root_window_host_delegate_->OnHostResized(new_size);
   // TODO(beng): replace with a layout manager??
-  content_window_->SetBounds(gfx::Rect(new_size));
+  content_window_->SetBounds(gfx::Rect(without_expansion));
 }
 
 void DesktopRootWindowHostWin::HandleFrameChanged() {
   // Replace the frame and layout the contents.
   GetWidget()->non_client_view()->UpdateFrame(true);
 }
 
 void DesktopRootWindowHostWin::HandleNativeFocus(HWND last_focused_window) {
   // TODO(beng): inform the native_widget_delegate_.
   InputMethod* input_method = GetInputMethod();
@@ skipping 111 matching lines @@
 DesktopRootWindowHost* DesktopRootWindowHost::Create(
     internal::NativeWidgetDelegate* native_widget_delegate,
     DesktopNativeWidgetAura* desktop_native_widget_aura,
     const gfx::Rect& initial_bounds) {
   return new DesktopRootWindowHostWin(native_widget_delegate,
                                       desktop_native_widget_aura,
                                       initial_bounds);
 }
 
 }  // namespace views