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::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 39 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_);

[sky, 2013/03/15 03:15:05]

What is the focus needed for?

[scottmg, 2013/03/15 22:23:46]

The window_->Show has to be deferred until after the VisibilityController is
created, so that it fades in. Initial focus setting is currently rolled into
DRWH::Init, but because the window's not visible it's not focusable. So, this is
just to split the focus setting after VisibilityController creation and the
window is shown.

The VisibilityController can't be created earlier because it's implemented as a
root window property.

+
   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;
+      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_)

[sky, 2013/03/15 03:15:05]

Ugh, this also means if you Hide() a window then ask if its visible it will
return true.

[scottmg, 2013/03/15 22:23:46]

I believe Hide() still works as before (or that's the intention at least). This
just affects the Host, nothing at the aura::Window level.

The change in behaviour is that Close() is not immediate, and there's an
intermediate period where the Hide is in progress before the Host is actually
closed.

+    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 118 matching lines @@
 // DesktopNativeWidgetAura, aura::WindowDelegate implementation:
 
 gfx::Size DesktopNativeWidgetAura::GetMinimumSize() const {
   return native_widget_delegate_->GetMinimumSize();
 }
 
 gfx::Size DesktopNativeWidgetAura::GetMaximumSize() const {
   return native_widget_delegate_->GetMaximumSize();
 }
 
+void DesktopNativeWidgetAura::SetHostTransitionBounds(const gfx::Rect& bounds) {
+  desktop_root_window_host_->AsRootWindowHost()->SetHostWindowExpansion(bounds);
+}
+
 void DesktopNativeWidgetAura::OnBoundsChanged(const gfx::Rect& old_bounds,
                                               const gfx::Rect& new_bounds) {
   if (old_bounds.origin() != new_bounds.origin())
     native_widget_delegate_->OnNativeWidgetMove();
   if (old_bounds.size() != new_bounds.size())
     native_widget_delegate_->OnNativeWidgetSizeChanged(new_bounds.size());
 }
 
 gfx::NativeCursor DesktopNativeWidgetAura::GetCursor(const gfx::Point& point) {
   return gfx::kNullCursor;
@@ skipping 41 matching lines @@
   }
 }
 
 void DesktopNativeWidgetAura::OnWindowDestroyed() {
   window_ = NULL;
   native_widget_delegate_->OnNativeWidgetDestroyed();
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
     delete this;
 }
 
+void DesktopNativeWidgetAura::OnWindowHidingAnimationCompleted() {
+  if (pending_close_)
+    desktop_root_window_host_->Close();
+}
+
 void DesktopNativeWidgetAura::OnWindowTargetVisibilityChanged(bool visible) {
 }
 
 bool DesktopNativeWidgetAura::HasHitTestMask() const {
   return native_widget_delegate_->HasHitTestMask();
 }
 
 void DesktopNativeWidgetAura::GetHitTestMask(gfx::Path* mask) const {
   native_widget_delegate_->GetHitTestMask(mask);
 }
@@ skipping 164 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