Reland r107720 - Enable the new layer animation framework.

ui/aura/desktop.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/desktop.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "ui/aura/aura_switches.h"
 #include "ui/aura/desktop_delegate.h"
 #include "ui/aura/desktop_host.h"
 #include "ui/aura/desktop_observer.h"
 #include "ui/aura/event.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/screen_aura.h"
+#include "ui/aura/screen_rotation.h"
 #include "ui/aura/toplevel_window_container.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/compositor/layer.h"
+#include "ui/gfx/compositor/layer_animation_sequence.h"
+#include "ui/gfx/compositor/layer_animator.h"
+#include "ui/gfx/interpolated_transform.h"
 
 using std::string;
 using std::vector;
 
 namespace aura {
 
 namespace {
 
 // Default bounds for the host window.
 static const int kDefaultHostWindowX = 200;
 static const int kDefaultHostWindowY = 200;
 static const int kDefaultHostWindowWidth = 1280;
 static const int kDefaultHostWindowHeight = 1024;
 
+#if !defined(NDEBUG)
+// Converts degrees to an angle in the range [-180, 180).
+int NormalizeAngle(int degrees) {
+  while (degrees <= -180) degrees += 360;
+  while (degrees > 180) degrees -= 360;
+  return degrees;
+}
+
+static int SymmetricRound(float x) {
+  return static_cast<int>(
+    x > 0
+      ? std::floor(x + 0.5f)
+      : std::ceil(x - 0.5f));
+}
+#endif
+
 class DefaultDesktopDelegate : public DesktopDelegate {
  public:
   explicit DefaultDesktopDelegate(Desktop* desktop) : desktop_(desktop) {}
   virtual ~DefaultDesktopDelegate() {}
 
  private:
   virtual void AddChildToDefaultParent(Window* window) OVERRIDE {
     desktop_->AddChild(window);
   }
 
@@ skipping 126 matching lines @@
   }
   if (target && target->delegate()) {
     MouseEvent translated_event(*event, this, target);
     return target->OnMouseEvent(&translated_event);
   }
   return false;
 }
 
 bool Desktop::DispatchKeyEvent(KeyEvent* event) {
 #if !defined(NDEBUG)
-  // Press Home key to rotate the screen. Primarily used for testing.
   if (event->type() == ui::ET_KEY_PRESSED &&
-      (event->flags() & ui::EF_CONTROL_DOWN) &&
-      event->key_code() == ui::VKEY_HOME) {
-    ui::Transform transform;
-    static int count = 0;
-    gfx::Size size = host_->GetSize();
-    switch (count) {
-      case 0:
-        transform.ConcatRotate(-90.0f);
-        transform.ConcatTranslate(0, size.height());
-        break;
-      case 1:
-        transform.ConcatRotate(180.0f);
-        transform.ConcatTranslate(size.width(), size.height());
-        break;
-      case 2:
-        transform.ConcatRotate(90.0f);
-        transform.ConcatTranslate(size.width(), 0);
-        break;
+      (event->flags() & ui::EF_SHIFT_DOWN) &&
+      (event->flags() & ui::EF_ALT_DOWN) &&
+      event->is_char()) {
+
+    bool should_rotate = true;
+    int new_degrees = 0;
+    switch (event->key_code()) {
+      case ui::VKEY_UP: new_degrees = 0; break;
+      case ui::VKEY_DOWN: new_degrees = 180; break;
+      case ui::VKEY_RIGHT: new_degrees = 90; break;
+      case ui::VKEY_LEFT: new_degrees = -90; break;
+      default: should_rotate = false; break;
     }
-    layer()->SetAnimation(CreateDefaultAnimation());
-    SetTransform(transform);
-    count = (count + 1) % 4;
-    return true;
+
+    if (should_rotate) {
+      float rotation = 0.0f;
+      int degrees = 0;
+      const ui::Transform& transform = layer()->GetTargetTransform();
+      if (ui::InterpolatedTransform::FactorTRS(transform,
+                                               NULL, &rotation, NULL))
+        degrees = NormalizeAngle(new_degrees - SymmetricRound(rotation));
+
+      if (degrees != 0) {
+        layer()->GetAnimator()->set_preemption_strategy(
+            ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
+        layer()->GetAnimator()->ScheduleAnimationElement(
+            new ScreenRotation(degrees));
+        return true;
+      }
+    }
   }
 #endif
 
   if (focused_window_) {
     KeyEvent translated_event(*event);
     return focused_window_->OnKeyEvent(&translated_event);
   }
   return false;
 }
 
@@ skipping 138 matching lines @@
   if (capture_window_ && capture_window_->delegate())
     capture_window_->delegate()->OnCaptureLost();
   capture_window_ = NULL;
 }
 
 void Desktop::SetTransform(const ui::Transform& transform) {
   Window::SetTransform(transform);
 
   // If the layer is not animating, then we need to update the host size
   // immediately.
-  if (!layer()->has_animation())
+  if (!layer()->GetAnimator()->is_animating())
     OnHostResized(host_->GetSize());
 }
 
 void Desktop::HandleMouseMoved(const MouseEvent& event, Window* target) {
   if (target == mouse_moved_handler_)
     return;
 
   // Send an exited event.
   if (mouse_moved_handler_ && mouse_moved_handler_->delegate()) {
     MouseEvent translated_event(event, this, mouse_moved_handler_,
@@ skipping 22 matching lines @@
 }
 
 internal::FocusManager* Desktop::GetFocusManager() {
   return this;
 }
 
 Desktop* Desktop::GetDesktop() {
   return this;
 }
 
-void Desktop::OnLayerAnimationEnded(const ui::Animation* animation) {
+void Desktop::OnLayerAnimationEnded(
+    const ui::LayerAnimationSequence* animation) {
   OnHostResized(host_->GetSize());
 }
 
 void Desktop::SetFocusedWindow(Window* focused_window) {
   if (focused_window == focused_window_ ||
       (focused_window && !focused_window->CanFocus())) {
     return;
   }
   if (focused_window_ && focused_window_->delegate())
     focused_window_->delegate()->OnBlur();
@@ skipping 31 matching lines @@
       base::StringToInt(parts[1], &parsed_height) && parsed_height > 0) {
     bounds.set_size(gfx::Size(parsed_width, parsed_height));
   } else if (use_fullscreen_host_window_) {
     bounds = gfx::Rect(DesktopHost::GetNativeDisplaySize());
   }
 
   return bounds;
 }
 
 }  // namespace aura