Implicit animations through Layer.

ui/aura/window.cc

 // Copyright (c) 2011 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/aura/window.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "ui/aura/desktop.h"
 #include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window_delegate.h"
+#include "ui/base/animation/multi_animation.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/compositor/layer.h"
 
 namespace aura {
 
 using internal::RootWindow;
 
 Window::Window(WindowDelegate* delegate)
     : delegate_(delegate),
@@ skipping 51 matching lines @@
       (visibility_ == VISIBILITY_HIDDEN &&
        !Desktop::GetInstance()->active_window())) {
     Desktop::GetInstance()->ActivateTopmostWindow();
   }
 }
 
 void Window::SetLayoutManager(LayoutManager* layout_manager) {
   layout_manager_.reset(layout_manager);
 }
 
-void Window::SetBounds(const gfx::Rect& bounds, int anim_ms) {
-  // TODO: support anim_ms
+void Window::SetBounds(const gfx::Rect& new_bounds) {
   // TODO: funnel this through the Desktop.
-  bool was_move = bounds_.size() == bounds.size();
-  gfx::Rect old_bounds = bounds_;
-  bounds_ = bounds;
-  layer_->SetBounds(bounds);
+  gfx::Rect old_bounds = bounds();
+  bool was_move = old_bounds.size() == new_bounds.size();
+  layer_->SetBounds(new_bounds);
+
   if (layout_manager_.get())
     layout_manager_->OnWindowResized();
   if (delegate_)
-    delegate_->OnBoundsChanged(old_bounds, bounds_);
+    delegate_->OnBoundsChanged(old_bounds, new_bounds);
   if (was_move)
     SchedulePaintInRect(gfx::Rect());
   else
     SchedulePaint();
 }
 
+const gfx::Rect& Window::bounds() const {
+  return layer_->bounds();
+}
+
 void Window::SchedulePaintInRect(const gfx::Rect& rect) {
   layer_->SchedulePaint(rect);
 }
 
 void Window::SetCanvas(const SkCanvas& canvas, const gfx::Point& origin) {
   // TODO: figure out how this is going to work when animating the layer. In
   // particular if we're animating the size then the underlying Texture is going
   // to be unhappy if we try to set a texture on a size bigger than the size of
   // the texture.
   layer_->SetCanvas(canvas, origin);
@@ skipping 110 matching lines @@
     return;
 
   root->ReleaseCapture(this);
 }
 
 bool Window::HasCapture() {
   RootWindow* root = GetRoot();
   return root && root->capture_window() == this;
 }
 
+// static
+ui::Animation* Window::CreateDefaultAnimation() {
+  std::vector<ui::MultiAnimation::Part> parts;
+  parts.push_back(ui::MultiAnimation::Part(200, ui::Tween::LINEAR));
+  ui::MultiAnimation* multi_animation = new ui::MultiAnimation(parts);
+  multi_animation->set_continuous(false);
+  return multi_animation;
+}
+
 internal::RootWindow* Window::GetRoot() {
   return parent_ ? parent_->GetRoot() : NULL;
 }
 
 void Window::SchedulePaint() {
-  SchedulePaintInRect(gfx::Rect(0, 0, bounds_.width(), bounds_.height()));
+  SchedulePaintInRect(gfx::Rect(0, 0, bounds().width(), bounds().height()));
 }
 
 void Window::OnPaintLayer(gfx::Canvas* canvas) {
   delegate_->OnPaint(canvas);
 }
 
 }  // namespace aura