Converts overview to use common ash 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/screen_util.h"
 #include "ash/shelf/shelf_util.h"
 #include "ash/shell.h"
 #include "ash/wm/aura/aura_layout_manager_adapter.h"
@@ skipping 11 matching lines @@
 #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/views/widget/widget.h"
 #include "ui/wm/core/coordinate_conversion.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);
 
@@ skipping 29 matching lines @@
 
 WmWindowAura::WmWindowAura(aura::Window* window)
     : window_(window),
       // Mirrors that of aura::Window.
       observers_(base::ObserverList<WmWindowObserver>::NOTIFY_EXISTING_ONLY) {
   window_->AddObserver(this);
   window_->SetProperty(kWmWindowKey, this);
 }
 
 // static
-WmWindow* WmWindowAura::Get(aura::Window* window) {
+const WmWindow* WmWindowAura::Get(const aura::Window* window) {
   if (!window)
     return nullptr;
 
-  WmWindow* wm_window = window->GetProperty(kWmWindowKey);
+  const WmWindow* wm_window = window->GetProperty(kWmWindowKey);
   if (wm_window)
     return wm_window;
   // WmWindowAura is owned by the aura::Window.
-  return new WmWindowAura(window);
+  // TODO(sky): fix constness.
+  return new WmWindowAura(const_cast<aura::Window*>(window));
 }
 
 // static
 std::vector<WmWindow*> WmWindowAura::FromAuraWindows(
     const std::vector<aura::Window*>& aura_windows) {
   std::vector<WmWindow*> result(aura_windows.size());
   for (size_t i = 0; i < aura_windows.size(); ++i)
     result[i] = Get(aura_windows[i]);
   return result;
 }
@@ skipping 10 matching lines @@
 
 WmRootWindowController* WmWindowAura::GetRootWindowController() {
   aura::Window* root = window_->GetRootWindow();
   return root ? WmRootWindowControllerAura::Get(root) : nullptr;
 }
 
 WmGlobals* WmWindowAura::GetGlobals() const {
   return WmGlobals::Get();
 }
 
+base::string16 WmWindowAura::GetTitle() const {
+  return window_->title();
+}
+
 void WmWindowAura::SetShellWindowId(int id) {
   window_->set_id(id);
 }
 
 int WmWindowAura::GetShellWindowId() const {
   return window_->id();
 }
 
 ui::wm::WindowType WmWindowAura::GetType() const {
   return window_->type();
@@ skipping 55 matching lines @@
 }
 
 bool WmWindowAura::GetTargetVisibility() const {
   return window_->TargetVisibility();
 }
 
 bool WmWindowAura::IsVisible() const {
   return window_->IsVisible();
 }
 
+void WmWindowAura::SetOpacity(float opacity) {
+  window_->layer()->SetOpacity(opacity);
+}
+
+float WmWindowAura::GetTargetOpacity() const {
+  return window_->layer()->GetTargetOpacity();
+}
+
+void WmWindowAura::SetTransform(const gfx::Transform& transform) {
+  window_->SetTransform(transform);
+}
+
+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:
       return window_->GetProperty(kSnapChildrenToPixelBoundary);
 
     case WmWindowProperty::ALWAYS_ON_TOP:
       return window_->GetProperty(aura::client::kAlwaysOnTopKey);
 
     default:
       NOTREACHED();
       break;
   }
 
   return false;
 }
 
 int WmWindowAura::GetIntProperty(WmWindowProperty key) {
   if (key == WmWindowProperty::SHELF_ID)
     return GetShelfIDForWindow(window_);
 
+  if (key == WmWindowProperty::TOP_VIEW_INSET)
+    return window_->GetProperty(aura::client::kTopViewInset);
+
   NOTREACHED();
   return 0;
 }
 
 const WindowState* WmWindowAura::GetWindowState() const {
   return ash::wm::GetWindowState(window_);
 }
 
 WmWindow* WmWindowAura::GetToplevelWindow() {
   return Get(window_->GetToplevelWindow());
@@ skipping 34 matching lines @@
 }
 
 void WmWindowAura::SetVisibilityAnimationType(int type) {
   ::wm::SetWindowVisibilityAnimationType(window_, type);
 }
 
 void WmWindowAura::SetVisibilityAnimationDuration(base::TimeDelta delta) {
   ::wm::SetWindowVisibilityAnimationDuration(window_, delta);
 }
 
+void WmWindowAura::SetVisibilityAnimationTransition(
+    ::wm::WindowVisibilityAnimationTransition transition) {
+  ::wm::SetWindowVisibilityAnimationTransition(window_, transition);
+}
+
 void WmWindowAura::Animate(::wm::WindowAnimationType type) {
   ::wm::AnimateWindow(window_, type);
 }
 
+void WmWindowAura::StopAnimatingProperty(
+    ui::LayerAnimationElement::AnimatableProperty property) {
+  window_->layer()->GetAnimator()->StopAnimatingProperty(property);
+}
+
 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 156 matching lines @@
 }
 
 void WmWindowAura::Hide() {
   window_->Hide();
 }
 
 void WmWindowAura::Show() {
   window_->Show();
 }
 
+void WmWindowAura::Close() {
+  views::Widget::GetWidgetForNativeView(window_)->Close();

[James Cook, 2016/05/27 00:02:51]

This seems a little dangerous to me, since not every aura::Window is going to be
registered with a widget. Maybe the method should be called CloseWidget()? Or
DCHECK? Both?

[sky, 2016/05/27 03:18:03]

Both it is.

+}
+
 bool WmWindowAura::IsFocused() const {
   return window_->HasFocus();
 }
 
 bool WmWindowAura::IsActive() const {
   return IsActiveWindow(window_);
 }
 
 void WmWindowAura::Activate() {
   ActivateWindow(window_);
@@ skipping 83 matching lines @@
     ash::wm::GetWindowState(window_)->OnWindowShowStateChanged();
     return;
   }
   WmWindowProperty wm_property;
   if (key == kSnapChildrenToPixelBoundary) {
     wm_property = WmWindowProperty::SNAP_CHILDREN_TO_PIXEL_BOUDARY;
   } 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_,
                     OnWindowPropertyChanged(this, wm_property));
 }
 
 void WmWindowAura::OnWindowBoundsChanged(aura::Window* window,
                                          const gfx::Rect& old_bounds,
                                          const gfx::Rect& new_bounds) {
   FOR_EACH_OBSERVER(WmWindowObserver, observers_,
                     OnWindowBoundsChanged(this, old_bounds, new_bounds));
 }
 
 void WmWindowAura::OnWindowDestroying(aura::Window* window) {
   FOR_EACH_OBSERVER(WmWindowObserver, observers_, OnWindowDestroying(this));
 }
 
 void WmWindowAura::OnWindowVisibilityChanging(aura::Window* window,
                                               bool visible) {
   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