Makes RootWindowController window creation in terms of common types

ash/wm/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/wm/aura/wm_window_aura.h"
 
+#include "ash/ash_constants.h"
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf_util.h"
 #include "ash/shell.h"
 #include "ash/wm/aura/aura_layout_manager_adapter.h"
 #include "ash/wm/aura/wm_globals_aura.h"
 #include "ash/wm/aura/wm_root_window_controller_aura.h"
 #include "ash/wm/common/window_state.h"
 #include "ash/wm/common/wm_layout_manager.h"
 #include "ash/wm/common/wm_window_observer.h"
 #include "ash/wm/common/wm_window_property.h"
 #include "ash/wm/resize_shadow_controller.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
+#include "base/memory/ptr_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer_tree_owner.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/display/screen.h"
+#include "ui/gfx/geometry/insets.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/coordinate_conversion.h"
+#include "ui/wm/core/easy_resize_window_targeter.h"
+#include "ui/wm/core/visibility_controller.h"
 #include "ui/wm/core/window_util.h"
 
 DECLARE_WINDOW_PROPERTY_TYPE(ash::wm::WmWindowAura*);
 
 namespace ash {
 namespace wm {
 
 DEFINE_OWNED_WINDOW_PROPERTY_KEY(ash::wm::WmWindowAura, kWmWindowKey, nullptr);
 
 namespace {
@@ skipping 68 matching lines @@
 
 WmRootWindowController* WmWindowAura::GetRootWindowController() {
   aura::Window* root = window_->GetRootWindow();
   return root ? WmRootWindowControllerAura::Get(root) : nullptr;
 }
 
 WmGlobals* WmWindowAura::GetGlobals() const {
   return WmGlobals::Get();
 }
 
+void WmWindowAura::SetName(const char* name) {
+  window_->SetName(name);
+}
+
 base::string16 WmWindowAura::GetTitle() const {
   return window_->title();
 }
 
 void WmWindowAura::SetShellWindowId(int id) {
   window_->set_id(id);
 }
 
 int WmWindowAura::GetShellWindowId() const {
   return window_->id();
@@ skipping 81 matching lines @@
 gfx::Transform WmWindowAura::GetTargetTransform() const {
   return window_->layer()->GetTargetTransform();
 }
 
 bool WmWindowAura::IsSystemModal() const {
   return window_->GetProperty(aura::client::kModalKey) == ui::MODAL_TYPE_SYSTEM;
 }
 
 bool WmWindowAura::GetBoolProperty(WmWindowProperty key) {
   switch (key) {
-    case WmWindowProperty::SNAP_CHILDREN_TO_PIXEL_BOUDARY:
+    case WmWindowProperty::SNAP_CHILDREN_TO_PIXEL_BOUNDARY:
       return window_->GetProperty(kSnapChildrenToPixelBoundary);
 
     case WmWindowProperty::ALWAYS_ON_TOP:
       return window_->GetProperty(aura::client::kAlwaysOnTopKey);
 
     default:
       NOTREACHED();
       break;
   }
 
@@ skipping 68 matching lines @@
 
 void WmWindowAura::Animate(::wm::WindowAnimationType type) {
   ::wm::AnimateWindow(window_, type);
 }
 
 void WmWindowAura::StopAnimatingProperty(
     ui::LayerAnimationElement::AnimatableProperty property) {
   window_->layer()->GetAnimator()->StopAnimatingProperty(property);
 }
 
+void WmWindowAura::SetChildWindowVisibilityChangesAnimated() {
+  ::wm::SetChildWindowVisibilityChangesAnimated(window_);
+}
+
+void WmWindowAura::SetMasksToBounds(bool value) {
+  window_->layer()->SetMasksToBounds(value);
+}
+
 void WmWindowAura::SetBounds(const gfx::Rect& bounds) {
   window_->SetBounds(bounds);
 }
 
 void WmWindowAura::SetBoundsWithTransitionDelay(const gfx::Rect& bounds,
                                                 base::TimeDelta delta) {
   if (::wm::WindowAnimationsDisabled(window_)) {
     window_->SetBounds(bounds);
     return;
   }
@@ skipping 219 matching lines @@
     resize_shadow_controller->ShowShadow(window_, component);
 }
 
 void WmWindowAura::HideResizeShadow() {
   ResizeShadowController* resize_shadow_controller =
       Shell::GetInstance()->resize_shadow_controller();
   if (resize_shadow_controller)
     resize_shadow_controller->HideShadow(window_);
 }
 
+void WmWindowAura::SetBoundsInScreenBehaviorForChildren(
+    BoundsInScreenBehavior behavior) {
+  window_->SetProperty(
+      kUsesScreenCoordinatesKey,
+      behavior == BoundsInScreenBehavior::USE_SCREEN_COORDINATES);
+}
+
+void WmWindowAura::SetSnapsChildrenToPhysicalPixelBoundary() {
+  wm::SetSnapsChildrenToPhysicalPixelBoundary(window_);
+}
+
 void WmWindowAura::SnapToPixelBoundaryIfNecessary() {
   SnapWindowToPixelBoundary(window_);
 }
 
+void WmWindowAura::SetChildrenUseExtendedHitRegion() {
+  gfx::Insets mouse_extend(-kResizeOutsideBoundsSize, -kResizeOutsideBoundsSize,
+                           -kResizeOutsideBoundsSize,
+                           -kResizeOutsideBoundsSize);
+  gfx::Insets touch_extend =
+      mouse_extend.Scale(kResizeOutsideBoundsScaleForTouch);
+  window_->SetEventTargeter(base::WrapUnique(
+      new ::wm::EasyResizeWindowTargeter(window_, mouse_extend, touch_extend)));
+}
+
+void WmWindowAura::SetDescendantsStayInSameRootWindow(bool value) {
+  window_->SetProperty(kStayInSameRootWindowKey, true);
+}
+
 void WmWindowAura::AddObserver(WmWindowObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WmWindowAura::RemoveObserver(WmWindowObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 WmWindowAura::~WmWindowAura() {
   window_->RemoveObserver(this);
@@ skipping 16 matching lines @@
 
 void WmWindowAura::OnWindowPropertyChanged(aura::Window* window,
                                            const void* key,
                                            intptr_t old) {
   if (key == aura::client::kShowStateKey) {
     ash::wm::GetWindowState(window_)->OnWindowShowStateChanged();
     return;
   }
   WmWindowProperty wm_property;
   if (key == kSnapChildrenToPixelBoundary) {
-    wm_property = WmWindowProperty::SNAP_CHILDREN_TO_PIXEL_BOUDARY;
+    wm_property = WmWindowProperty::SNAP_CHILDREN_TO_PIXEL_BOUNDARY;
   } else if (key == aura::client::kAlwaysOnTopKey) {
     wm_property = WmWindowProperty::ALWAYS_ON_TOP;
   } else if (key == kShelfID) {
     wm_property = WmWindowProperty::SHELF_ID;
   } else if (key == aura::client::kTopViewInset) {
     wm_property = WmWindowProperty::TOP_VIEW_INSET;
   } else {
     return;
   }
   FOR_EACH_OBSERVER(WmWindowObserver, observers_,
@@ skipping 16 matching lines @@
   FOR_EACH_OBSERVER(WmWindowObserver, observers_,
                     OnWindowVisibilityChanging(this, visible));
 }
 
 void WmWindowAura::OnWindowTitleChanged(aura::Window* window) {
   FOR_EACH_OBSERVER(WmWindowObserver, observers_, OnWindowTitleChanged(this));
 }
 
 }  // namespace wm
 }  // namespace ash