Removes/promotes functions from WmWindowMus to WmWindowAura

ash/aura/wm_window_aura.cc

 // Copyright 2016 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 "ash/aura/wm_window_aura.h"
 
 #include "ash/aura/aura_layout_manager_adapter.h"
 #include "ash/aura/wm_root_window_controller_aura.h"
 #include "ash/aura/wm_shell_aura.h"
 #include "ash/common/ash_constants.h"
@@ skipping 68 matching lines @@
   void SetBounds(aura::Window* window, const gfx::Rect& bounds) {
     SetChildBoundsDirect(window, bounds);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoundsSetter);
 };
 
 }  // namespace
 
+// static
+bool WmWindowAura::default_use_empty_minimum_size_for_testing_ = false;
+
 WmWindowAura::~WmWindowAura() {
   if (added_transient_observer_)
     ::wm::TransientWindowManager::Get(window_)->RemoveObserver(this);
 
   window_->RemoveObserver(this);
 }
 
 // static
 const WmWindow* WmWindowAura::Get(const aura::Window* window) {
   if (!window)
@@ skipping 25 matching lines @@
     result[i] = WmWindowAura::GetAuraWindow(windows[i]);
   return result;
 }
 
 // static
 const aura::Window* WmWindowAura::GetAuraWindow(const WmWindow* wm_window) {
   return wm_window ? static_cast<const WmWindowAura*>(wm_window)->aura_window()
                    : nullptr;
 }
 
+bool WmWindowAura::ShouldUseExtendedHitRegion() const {
+  const WmWindow* parent = Get(window_->parent());
+  return parent &&
+         static_cast<const WmWindowAura*>(parent)
+             ->children_use_extended_hit_region_;
+}
+
 void WmWindowAura::Destroy() {
   delete window_;
   // WARNING: this has been deleted.
 }
 
 const WmWindow* WmWindowAura::GetRootWindow() const {
   return Get(window_->GetRootWindow());
 }
 
 WmRootWindowController* WmWindowAura::GetRootWindowController() {
@@ skipping 34 matching lines @@
 }
 
 int WmWindowAura::GetAppType() const {
   return window_->GetProperty(aura::client::kAppType);
 }
 
 void WmWindowAura::SetAppType(int app_type) const {
   window_->SetProperty(aura::client::kAppType, app_type);
 }
 
-bool WmWindowAura::IsBubble() {
-  views::Widget* widget = views::Widget::GetWidgetForNativeView(window_);
-  return widget->widget_delegate()->AsBubbleDialogDelegate() != nullptr;
-}
-
 ui::Layer* WmWindowAura::GetLayer() {
   return window_->layer();
 }
 
 bool WmWindowAura::GetLayerTargetVisibility() {
   return GetLayer()->GetTargetVisibility();
 }
 
 bool WmWindowAura::GetLayerVisible() {
   return GetLayer()->visible();
@@ skipping 34 matching lines @@
 
 gfx::Rect WmWindowAura::ConvertRectToScreen(const gfx::Rect& rect) const {
   return ScreenUtil::ConvertRectToScreen(window_, rect);
 }
 
 gfx::Rect WmWindowAura::ConvertRectFromScreen(const gfx::Rect& rect) const {
   return ScreenUtil::ConvertRectFromScreen(window_, rect);
 }
 
 gfx::Size WmWindowAura::GetMinimumSize() const {
-  return window_->delegate() ? window_->delegate()->GetMinimumSize()
-                             : gfx::Size();
+  return window_->delegate() && !use_empty_minimum_size_for_testing_
+             ? window_->delegate()->GetMinimumSize()
+             : gfx::Size();
 }
 
 gfx::Size WmWindowAura::GetMaximumSize() const {
   return window_->delegate() ? window_->delegate()->GetMaximumSize()
                              : gfx::Size();
 }
 
 bool WmWindowAura::GetTargetVisibility() const {
   return window_->TargetVisibility();
 }
@@ skipping 428 matching lines @@
 
 void WmWindowAura::Hide() {
   window_->Hide();
 }
 
 void WmWindowAura::Show() {
   window_->Show();
 }
 
 views::Widget* WmWindowAura::GetInternalWidget() {
-  return views::Widget::GetWidgetForNativeView(window_);
+  return window_->GetProperty(kWidgetCreationTypeKey) ==
+                 WidgetCreationType::INTERNAL
+             ? views::Widget::GetWidgetForNativeView(window_)
+             : nullptr;
 }
 
 void WmWindowAura::CloseWidget() {
   DCHECK(GetInternalWidget());
   GetInternalWidget()->Close();
 }
 
 void WmWindowAura::SetFocused() {
   aura::client::GetFocusClient(window_)->FocusWindow(window_);
 }
@@ skipping 70 matching lines @@
 
 void WmWindowAura::SetSnapsChildrenToPhysicalPixelBoundary() {
   wm::SetSnapsChildrenToPhysicalPixelBoundary(window_);
 }
 
 void WmWindowAura::SnapToPixelBoundaryIfNecessary() {
   wm::SnapWindowToPixelBoundary(window_);
 }
 
 void WmWindowAura::SetChildrenUseExtendedHitRegion() {
+  children_use_extended_hit_region_ = true;
+  if (aura::Env::GetInstance()->mode() == aura::Env::Mode::MUS)
+    return;
+
   gfx::Insets mouse_extend(-kResizeOutsideBoundsSize, -kResizeOutsideBoundsSize,
                            -kResizeOutsideBoundsSize,
                            -kResizeOutsideBoundsSize);
   gfx::Insets touch_extend =
       mouse_extend.Scale(kResizeOutsideBoundsScaleForTouch);
   window_->SetEventTargeter(base::MakeUnique<::wm::EasyResizeWindowTargeter>(
       window_, mouse_extend, touch_extend));
 }
 
 std::unique_ptr<views::View> WmWindowAura::CreateViewWithRecreatedLayers() {
@@ skipping 36 matching lines @@
   window_->AddPreTargetHandler(handler);
 }
 
 void WmWindowAura::RemoveLimitedPreTargetHandler(ui::EventHandler* handler) {
   window_->RemovePreTargetHandler(handler);
 }
 
 WmWindowAura::WmWindowAura(aura::Window* window)
     : window_(window),
       // Mirrors that of aura::Window.
-      observers_(base::ObserverList<WmWindowObserver>::NOTIFY_EXISTING_ONLY) {
+      observers_(base::ObserverList<WmWindowObserver>::NOTIFY_EXISTING_ONLY),
+      use_empty_minimum_size_for_testing_(
+          default_use_empty_minimum_size_for_testing_) {
   window_->AddObserver(this);
   window_->SetProperty(kWmWindowKey, this);
 }
 
 // static
 bool WmWindowAura::HasInstance(const aura::Window* window) {
   return window->GetProperty(kWmWindowKey) != nullptr;
 }
 
 void WmWindowAura::OnWindowHierarchyChanging(
@@ skipping 97 matching lines @@
     observer.OnTransientChildAdded(this, Get(transient));
 }
 
 void WmWindowAura::OnTransientChildRemoved(aura::Window* window,
                                            aura::Window* transient) {
   for (auto& observer : transient_observers_)
     observer.OnTransientChildRemoved(this, Get(transient));
 }
 
 }  // namespace ash