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

ui/views/widget/desktop_aura/desktop_native_widget_aura.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_native_widget_aura.h"
 
 #include "base/bind.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/stacking_client.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/root_window_host.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/canvas.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/corewm/compound_event_filter.h"
 #include "ui/views/corewm/corewm_switches.h"
 #include "ui/views/corewm/input_method_event_filter.h"
 #include "ui/views/corewm/shadow_controller.h"
 #include "ui/views/corewm/shadow_types.h"
 #include "ui/views/corewm/tooltip_controller.h"
+#include "ui/views/corewm/visibility_controller.h"
+#include "ui/views/corewm/window_animations.h"
 #include "ui/views/drag_utils.h"
 #include "ui/views/ime/input_method.h"
 #include "ui/views/ime/input_method_bridge.h"
 #include "ui/views/widget/desktop_aura/desktop_root_window_host.h"
 #include "ui/views/widget/drop_helper.h"
 #include "ui/views/widget/native_widget_aura_window_observer.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/tooltip_manager_aura.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_aura_utils.h"
@@ skipping 115 matching lines @@
 
 DesktopNativeWidgetAura::DesktopNativeWidgetAura(
     internal::NativeWidgetDelegate* delegate)
     : ownership_(Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET),
       ALLOW_THIS_IN_INITIALIZER_LIST(close_widget_factory_(this)),
       can_activate_(true),
       desktop_root_window_host_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(window_(new aura::Window(this))),
       native_widget_delegate_(delegate),
       last_drop_operation_(ui::DragDropTypes::DRAG_NONE),
-      restore_focus_on_activate_(false) {
+      restore_focus_on_activate_(false),
+      pending_close_(false) {
   window_->SetProperty(kDesktopNativeWidgetAuraKey, this);
+  aura::client::SetAnimationHost(window_, this);
   aura::client::SetFocusChangeObserver(window_, this);
   aura::client::SetActivationChangeObserver(window_, this);
 }
 
 DesktopNativeWidgetAura::~DesktopNativeWidgetAura() {
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
     delete native_widget_delegate_;
   else
     CloseNow();
 
@@ skipping 38 matching lines @@
 
 void DesktopNativeWidgetAura::InitNativeWidget(
     const Widget::InitParams& params) {
   ownership_ = params.ownership;
 
   window_->set_user_data(this);
   window_->SetType(GetAuraWindowTypeForWidgetType(params.type));
   window_->SetTransparent(true);
   window_->Init(params.layer_type);
   corewm::SetShadowType(window_, corewm::SHADOW_TYPE_NONE);
-  window_->Show();
 
   desktop_root_window_host_ = params.desktop_root_window_host ?
       params.desktop_root_window_host :
       DesktopRootWindowHost::Create(native_widget_delegate_,
                                     this, params.bounds);
   root_window_.reset(
       desktop_root_window_host_->Init(window_, params));
   stacking_client_.reset(
       new DesktopNativeWidgetAuraStackingClient(root_window_.get()));
   drop_helper_.reset(new DropHelper(
       static_cast<internal::RootView*>(GetWidget()->GetRootView())));
   aura::client::SetDragDropDelegate(window_, this);
 
   tooltip_manager_.reset(new views::TooltipManagerAura(window_, GetWidget()));
   tooltip_controller_.reset(
       new corewm::TooltipController(gfx::SCREEN_TYPE_NATIVE));
   aura::client::SetTooltipClient(root_window_.get(),
                                  tooltip_controller_.get());
   root_window_->AddPreTargetHandler(tooltip_controller_.get());
 
+  if (params.type != Widget::InitParams::TYPE_WINDOW) {
+    visibility_controller_.reset(new views::corewm::VisibilityController);
+    aura::client::SetVisibilityClient(GetNativeView()->GetRootWindow(),
+                                      visibility_controller_.get());
+    views::corewm::SetChildWindowVisibilityChangesAnimated(
+        GetNativeView()->GetRootWindow());
+  }
+  window_->Show();
+  desktop_root_window_host_->InitFocus(window_);
+
   aura::client::SetActivationDelegate(window_, this);
 
   shadow_controller_.reset(
       new corewm::ShadowController(
           aura::client::GetActivationClient(root_window_.get())));
 }
 
 NonClientFrameView* DesktopNativeWidgetAura::CreateNonClientFrameView() {
   return desktop_root_window_host_->CreateNonClientFrameView();
 }
@@ skipping 141 matching lines @@
 }
 
 void DesktopNativeWidgetAura::StackBelow(gfx::NativeView native_view) {
 }
 
 void DesktopNativeWidgetAura::SetShape(gfx::NativeRegion shape) {
   desktop_root_window_host_->SetShape(shape);
 }
 
 void DesktopNativeWidgetAura::Close() {
-  desktop_root_window_host_->Close();
-  if (window_)
+  if (window_) {
     window_->SuppressPaint();
+    if (window_->type() == aura::client::WINDOW_TYPE_NORMAL ||
+        views::corewm::WindowAnimationsDisabled(window_)) {
+      desktop_root_window_host_->Close();
+    } else {
+      pending_close_ = true;

[sky, 2013/03/18 15:49:42]

Do you end up in this code path on linux?

+      Hide();  // OnWindowHidingAnimationCompleted does the actual Close.
+    }
+  }
 }
 
 void DesktopNativeWidgetAura::CloseNow() {
   desktop_root_window_host_->CloseNow();
 }
 
 void DesktopNativeWidgetAura::Show() {
   desktop_root_window_host_->AsRootWindowHost()->Show();
   window_->Show();
 }
 
 void DesktopNativeWidgetAura::Hide() {
-  desktop_root_window_host_->AsRootWindowHost()->Hide();
+  if (!pending_close_)
+    desktop_root_window_host_->AsRootWindowHost()->Hide();
   if (window_)
     window_->Hide();
 }
 
 void DesktopNativeWidgetAura::ShowMaximizedWithBounds(
       const gfx::Rect& restored_bounds) {
   desktop_root_window_host_->ShowMaximizedWithBounds(restored_bounds);
 }
 
 void DesktopNativeWidgetAura::ShowWithWindowState(ui::WindowShowState state) {
@@ skipping 198 matching lines @@
 }
 
 scoped_refptr<ui::Texture> DesktopNativeWidgetAura::CopyTexture() {
   // The layer we create doesn't have an external texture, so this should never
   // get invoked.
   NOTREACHED();
   return scoped_refptr<ui::Texture>();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// DesktopNativeWidgetAura, aura::WindowAnimationHost implementation:
+
+void DesktopNativeWidgetAura::SetHostTransitionBounds(const gfx::Rect& bounds) {

[sky, 2013/03/18 15:49:42]

If this is only applicable to windows, should we implement this in
DesktopRootWindowHostWin?

[scottmg, 2013/03/18 21:47:48]

Ah, that seems better, removes all the empty/NOTIMPLEMENTED functions. Done.

+  desktop_root_window_host_->AsRootWindowHost()->SetHostWindowExpansion(bounds);
+}
+
+void DesktopNativeWidgetAura::OnWindowHidingAnimationCompleted() {
+  if (pending_close_)
+    desktop_root_window_host_->Close();
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // DesktopNativeWidgetAura, ui::EventHandler implementation:
 
 void DesktopNativeWidgetAura::OnKeyEvent(ui::KeyEvent* event) {
   if (event->is_char()) {
     // If a ui::InputMethod object is attached to the root window, character
     // events are handled inside the object and are not passed to this function.
     // If such object is not attached, character events might be sent (e.g. on
     // Windows). In this case, we just skip these.
     return;
   }
@@ skipping 145 matching lines @@
   drop_helper_->OnDragExit();
 }
 
 int DesktopNativeWidgetAura::OnPerformDrop(const ui::DropTargetEvent& event) {
   DCHECK(drop_helper_.get() != NULL);
   return drop_helper_->OnDrop(event.data(), event.location(),
       last_drop_operation_);
 }
 
 }  // namespace views