Revert 132856 - Aura/ash split: Remove hacks and get chrome linking without ash.

ui/views/widget/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/native_widget_aura.h"
 
 #include "base/bind.h"
 #include "base/string_util.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
+#include "ui/aura/client/dispatcher_client.h"
 #include "ui/aura/client/drag_drop_client.h"
 #include "ui/aura/client/window_move_client.h"
 #include "ui/aura/client/window_types.h"
+#include "ui/aura/desktop/desktop_activation_client.h"
+#include "ui/aura/desktop/desktop_dispatcher_client.h"
+#include "ui/aura/desktop/desktop_root_window_event_filter.h"
 #include "ui/aura/env.h"
 #include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/drag_utils.h"
 #include "ui/views/ime/input_method_bridge.h"
-#include "ui/views/views_delegate.h"
 #include "ui/views/widget/drop_helper.h"
 #include "ui/views/widget/native_widget_delegate.h"
-#include "ui/views/widget/native_widget_helper_aura.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/tooltip_manager_aura.h"
 #include "ui/views/widget/widget_delegate.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/win_util.h"
 #include "ui/base/l10n/l10n_util_win.h"
 #endif
 
 #if defined(ENABLE_DIP)
 #include "ui/aura/monitor.h"
 #include "ui/aura/monitor_manager.h"
 #endif
 
 namespace views {
 
+bool NativeWidgetAura::g_aura_desktop_hax = false;
+
 namespace {
 
 aura::client::WindowType GetAuraWindowTypeForWidgetType(
     Widget::InitParams::Type type) {
   switch (type) {
     case Widget::InitParams::TYPE_WINDOW:
       return aura::client::WINDOW_TYPE_NORMAL;
     case Widget::InitParams::TYPE_PANEL:
       return aura::client::WINDOW_TYPE_PANEL;
     case Widget::InitParams::TYPE_CONTROL:
@@ skipping 69 matching lines @@
   NativeWidgetAura* host_;
 
   DISALLOW_COPY_AND_ASSIGN(ActiveWindowObserver);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetAura, public:
 
 NativeWidgetAura::NativeWidgetAura(internal::NativeWidgetDelegate* delegate)
     : delegate_(delegate),
-      ALLOW_THIS_IN_INITIALIZER_LIST(desktop_helper_(
-          ViewsDelegate::views_delegate ?
-          ViewsDelegate::views_delegate->CreateNativeWidgetHelper(this) :
-          NULL)),
+      root_window_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(window_(new aura::Window(this))),
       ownership_(Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET),
       ALLOW_THIS_IN_INITIALIZER_LIST(close_widget_factory_(this)),
       can_activate_(true),
       cursor_(gfx::kNullCursor),
       saved_window_state_(ui::SHOW_STATE_DEFAULT) {
 }
 
 NativeWidgetAura::~NativeWidgetAura() {
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
@@ skipping 13 matching lines @@
 #else
   return gfx::Font();
 #endif
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetAura, internal::NativeWidgetPrivate implementation:
 
 void NativeWidgetAura::InitNativeWidget(const Widget::InitParams& params) {
   ownership_ = params.ownership;
+  // TODO(erg): What kind of windows do we want to have their own root windows?
+  if (g_aura_desktop_hax) {
+    gfx::Rect bounds = params.bounds;
+    if (bounds.IsEmpty()) {
+      // We must pass some non-zero value when we initialize a RootWindow. This
+      // will probably be SetBounds()ed soon.
+      bounds.set_size(gfx::Size(100, 100));
+    }
+    root_window_.reset(new aura::RootWindow(bounds));
+    root_window_->SetEventFilter(
+        new aura::DesktopRootWindowEventFilter(root_window_.get()));
+    root_window_->AddRootWindowObserver(this);
 
-  if (desktop_helper_.get())
-    desktop_helper_->PreInitialize(params);
+    aura::client::SetActivationClient(
+        root_window_.get(),
+        new aura::DesktopActivationClient(root_window_.get()));
+    aura::client::SetDispatcherClient(root_window_.get(),
+                                      new aura::DesktopDispatcherClient);
+  }
 
   window_->set_user_data(this);
   window_->SetType(GetAuraWindowTypeForWidgetType(params.type));
   window_->SetProperty(aura::client::kShowStateKey, params.show_state);
   if (params.type == Widget::InitParams::TYPE_BUBBLE)
     aura::client::SetHideOnDeactivate(window_, true);
   window_->SetTransparent(params.transparent);
   window_->Init(params.layer_type);
   if (params.type == Widget::InitParams::TYPE_CONTROL)
     window_->Show();
 
   delegate_->OnNativeWidgetCreated();
-  if (desktop_helper_.get() && desktop_helper_->GetRootWindow()) {
-    window_->SetParent(desktop_helper_->GetRootWindow());
+  if (root_window_.get()) {
+    window_->SetParent(root_window_.get());
   } else if (params.child) {
     window_->SetParent(params.GetParent());
   } else {
     // Set up the transient child before the window is added. This way the
     // LayoutManager knows the window has a transient parent.
     gfx::NativeView parent = params.GetParent();
     if (parent && parent->type() != aura::client::WINDOW_TYPE_UNKNOWN) {
       parent->AddTransientChild(window_);
 
       // TODO(erg): The StackingClient interface implies that there is only a
       // single root window. Solving this would require setting a stacking
       // client per root window instead. For now, we hax our way around this by
       // forcing the parent to be the root window instead of passing NULL as
       // the parent which will dispatch to the stacking client.
-      if (desktop_helper_.get())
+      if (g_aura_desktop_hax)
         parent = parent->GetRootWindow();
       else
         parent = NULL;
     }
     // SetAlwaysOnTop before SetParent so that always-on-top container is used.
     SetAlwaysOnTop(params.keep_on_top);
     window_->SetParent(parent);
   }
 
   // Wait to set the bounds until we have a parent. That way we can know our
@@ skipping 12 matching lines @@
 #endif  // !defined(OS_MACOSX)
 
   drop_helper_.reset(new DropHelper(GetWidget()->GetRootView()));
   if (params.type != Widget::InitParams::TYPE_TOOLTIP &&
       params.type != Widget::InitParams::TYPE_POPUP) {
     aura::client::SetDragDropDelegate(window_, this);
   }
 
   aura::client::SetActivationDelegate(window_, this);
 
-  // TODO(erg): Move this somewhere else?
-  if (desktop_helper_.get())
-    desktop_helper_->ShowRootWindow();
+  if (root_window_.get())
+    root_window_->ShowRootWindow();
 }
 
 NonClientFrameView* NativeWidgetAura::CreateNonClientFrameView() {
   return NULL;
 }
 
 void NativeWidgetAura::UpdateFrameAfterFrameChange() {
 }
 
 bool NativeWidgetAura::ShouldUseNativeFrame() const {
@@ skipping 196 matching lines @@
   return ConvertRectFromMonitor(
       restore_bounds ? *restore_bounds : window_->bounds());
 #else
   return restore_bounds ? *restore_bounds : window_->bounds();
 #endif
 }
 
 void NativeWidgetAura::SetBounds(const gfx::Rect& in_bounds) {
   gfx::Rect bounds = in_bounds;
 
-  if (desktop_helper_.get())
-    bounds = desktop_helper_->ModifyAndSetBounds(bounds);
+  if (root_window_.get() && !bounds.IsEmpty()) {
+    root_window_->SetHostBounds(bounds);
+    bounds.set_x(0);
+    bounds.set_y(0);
+  }
 #if defined(ENABLE_DIP)
   bounds = ConvertRectToMonitor(bounds);
 #endif
   window_->SetBounds(bounds);
 }
 
 void NativeWidgetAura::SetSize(const gfx::Size& size) {
 #if defined(ENABLE_DIP)
   gfx::Size monitor_size = ConvertSizeToMonitor(size);
   window_->SetBounds(gfx::Rect(window_->bounds().origin(), monitor_size));
@@ skipping 377 matching lines @@
   delegate_->OnNativeWidgetDestroyed();
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
     delete this;
 }
 
 void NativeWidgetAura::OnWindowVisibilityChanged(bool visible) {
   delegate_->OnNativeWidgetVisibilityChanged(visible);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// NativeWidgetAura, aura::RootWindowObserver implementation:
+
+void NativeWidgetAura::OnRootWindowResized(const aura::RootWindow* root,
+                                           const gfx::Size& old_size) {
+  // This case can only happen if we have our own aura::RootWindow*. When that
+  // happens, our main window should be at the origin and sized to the
+  // RootWindow.
+  DCHECK_EQ(root, root_window_.get());
+  SetBounds(gfx::Rect(root->GetHostSize()));
+}
+
+void NativeWidgetAura::OnRootWindowHostClosed(const aura::RootWindow* root) {
+  DCHECK_EQ(root, root_window_.get());
+  GetWidget()->Close();
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetAura, aura::ActivationDelegate implementation:
 
 bool NativeWidgetAura::ShouldActivate(const aura::Event* event) {
   return can_activate_ && delegate_->CanActivate();
 }
 
 void NativeWidgetAura::OnActivated() {
   if (GetWidget()->HasFocusManager())
     GetWidget()->GetFocusManager()->RestoreFocusedView();
   delegate_->OnNativeWidgetActivationChanged(true);
@@ skipping 182 matching lines @@
   }
 }
 
 // static
 bool NativeWidgetPrivate::IsMouseButtonDown() {
   return aura::Env::GetInstance()->is_mouse_button_down();
 }
 
 }  // namespace internal
 }  // namespace views