Reland r107720 - Enable the new layer animation framework.

chrome/browser/ui/touch/animation/screen_rotation.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 "chrome/browser/ui/touch/animation/screen_rotation.h"
 
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "ui/base/animation/slide_animation.h"
 #include "ui/gfx/compositor/layer.h"
+#include "ui/gfx/compositor/layer_animation_delegate.h"
 #include "ui/gfx/interpolated_transform.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
 #include "views/paint_lock.h"
 #include "views/view.h"
 #include "views/widget/widget.h"
 
 namespace {
 const int kDefaultTransitionDurationMs = 350;
-
 } // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // ScreenRotationListener public:
 //
 
 ScreenRotationListener::~ScreenRotationListener() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ScreenRotation public:
 //
 
 ScreenRotation::ScreenRotation(views::View* view,
+                               ui::LayerAnimationDelegate* delegate,
                                ScreenRotationListener* listener,
                                float old_degrees,
                                float new_degrees)
     : view_(view),
+      delegate_(delegate),
       widget_(view->GetWidget()),
       listener_(listener),
       old_degrees_(old_degrees),
       new_degrees_(new_degrees),
       duration_(kDefaultTransitionDurationMs),
       animation_started_(false),
       animation_stopped_(false) {
   DCHECK(view);
   DCHECK(listener);
 
   if (!view->layer() || !widget_) {
     Finalize();
   } else {
     // Screen rotations are trigged as a result of a call to SetTransform which
     // causes a paint to be scheduled to occur. At this point, the paint has
     // been scheduled, but has not yet been started. We will listen for this
     // paint to be completed before we start animating.
     view->layer()->GetCompositor()->AddObserver(this);
   }
 }
 
 ScreenRotation::~ScreenRotation() {
   if (view_->layer())
     view_->layer()->GetCompositor()->RemoveObserver(this);
 }
 
 void ScreenRotation::Stop() {
   animation_.reset();
-  if (view_->layer()) {
+  if (delegate_) {
     if (!interpolated_transform_.get()) {
       // attempt to initialize.
       Init();
     }
     if (interpolated_transform_.get()) {
-      view_->layer()->SetTransform(interpolated_transform_->Interpolate(1.0));
-      view_->GetWidget()->SchedulePaintInRect(
-          view_->GetWidget()->GetClientAreaScreenBounds());
+      delegate_->SetTransformFromAnimation(
+          interpolated_transform_->Interpolate(1.0));
+      delegate_->ScheduleDrawForAnimation();
     }
   }
   Finalize();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ScreenRotation private:
 //
 
 void ScreenRotation::AnimationProgressed(const ui::Animation* anim) {
   TRACE_EVENT0("ScreenRotation", "step");
-  view_->layer()->SetTransform(interpolated_transform_->Interpolate(
-      anim->GetCurrentValue()));
-  widget_->SchedulePaintInRect(widget_->GetClientAreaScreenBounds());
+  delegate_->SetTransformFromAnimation(
+      interpolated_transform_->Interpolate(anim->GetCurrentValue()));
+  delegate_->ScheduleDrawForAnimation();
 }
 
 void ScreenRotation::AnimationEnded(const ui::Animation* anim) {
   TRACE_EVENT_END0("ScreenRotation", "ScreenRotation");
   // TODO(vollick) massage matrix so that entries sufficiently close
   // to 0, 1, or -1 are clamped to these values. The idea is to fight
   // accumulated numeric error due to successive rotations.
   ui::Transform xform = view_->layer()->transform();
   gfx::Point origin;
   xform.TransformPoint(origin);
   ui::Transform translation;
   translation.SetTranslate(new_origin_.x() - origin.x(),
                            new_origin_.y() - origin.y());
   xform.ConcatTransform(translation);
-  view_->layer()->SetTransform(xform);
-  widget_->SchedulePaintInRect(widget_->GetClientAreaScreenBounds());
+  delegate_->SetTransformFromAnimation(xform);
+  delegate_->ScheduleDrawForAnimation();
   animation_stopped_ = true;
 }
 
 void ScreenRotation::OnCompositingEnded(ui::Compositor* compositor) {
   DoPendingWork();
 }
 
 void ScreenRotation::Init() {
   TRACE_EVENT0("ScreenRotation", "init");
 
   ui::Transform current_transform = view_->layer()->transform();
   int degrees = new_degrees_ - old_degrees_;
   degrees = NormalizeAngle(degrees);
 
   // No rotation required.
   if (degrees == 0)
     return;
 
   gfx::Point old_pivot;
   gfx::Point new_pivot;
-  int width = view_->layer()->bounds().width();
-  int height = view_->layer()->bounds().height();
+  const gfx::Rect bounds = delegate_->GetBoundsForAnimation();

[sky, 2011/10/20 20:30:30]

const gfx::Rect&

+  int width = bounds.width();
+  int height = bounds.height();
 
   switch (degrees) {
     case 90:
       new_origin_ = new_pivot = gfx::Point(width, 0);
       new_size_.SetSize(height, width);
       break;
     case -90:
       new_origin_ = new_pivot = gfx::Point(0, height);
       new_size_.SetSize(height, width);
       break;
@@ skipping 65 matching lines @@
 }
 
 void ScreenRotation::DoPendingWork() {
   if (!animation_started_)
     Start();
   else if (animation_stopped_) {
     view_->layer()->GetCompositor()->RemoveObserver(this);
     Finalize();
   }
 }