Implemented screen rotation animation experiment.

ash/rotator/screen_rotation_animator.cc

Index: ash/rotator/screen_rotation_animator.cc
diff --git a/ash/rotator/screen_rotation_animator.cc b/ash/rotator/screen_rotation_animator.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ef5ab46bb125279d316aa9a1bac39877bbd0b5e1
--- /dev/null
+++ b/ash/rotator/screen_rotation_animator.cc
@@ -0,0 +1,325 @@
+// Copyright 2015 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/rotator/screen_rotation_animator.h"
+
+#include <string>
+#include <vector>
+
+#include "ash/ash_switches.h"
+#include "ash/display/display_controller.h"
+#include "ash/display/display_info.h"
+#include "ash/display/display_manager.h"
+#include "ash/rotator/screen_rotation_animation.h"
+#include "ash/shell.h"
+#include "base/command_line.h"
+#include "base/time/time.h"
+#include "ui/aura/window.h"
+#include "ui/compositor/layer.h"
+#include "ui/compositor/layer_animation_observer.h"
+#include "ui/compositor/layer_animation_sequence.h"
+#include "ui/compositor/layer_animator.h"
+#include "ui/compositor/layer_owner.h"
+#include "ui/compositor/layer_tree_owner.h"
+#include "ui/gfx/animation/tween.h"
+#include "ui/gfx/display.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/transform.h"
+#include "ui/gfx/transform_util.h"
+#include "ui/wm/core/window_util.h"
+
+namespace ash {
+
+namespace {
+
+// Switch value for an animation that will rotate the initial orientation's
+// layer towards the new orientation and the new orientation's layer in to
+// position from the initial orientation through an arc of
+// |kPartialRotationDegrees| degrees. The initial orientation's layer will be
+// faded out as well.
+const char kPartialRotation[] = "partial-rotation";
+
+// Switch value for the same animation as |kPartialRotation| but with a much
+// longer duration.
+const char kPartialRotationSlow[] = "partial-rotation-slow";
+
+// Switch value for an animation that will rotate both the initial and target
+// orientation's layers from the initial orientation into the target
+// orientation. The initial orientation's layer will be faded out as well and an
+// interpolated scaling factor is applied to the animation so that the initial
+// and target layers are both the same size throughout the animation.
+const char kFullRotation[] = "full-rotation";
+
+// Switch value for the same animation as |kFullRotation| but with a much longer
+// duration.
+const char kFullRotationSlow[] = "full-rotation-slow";
+
+// The number of degrees the partial rotation animations animate through.
+const int kPartialRotationDegrees = 20;
+
+// The time it takes for the normal speed rotation animations to run.
+const int kRotationDurationInMs = 250;
+
+// The time it takes for the slow speed rotation animations to run.
+const int kRotationDurationSlowInMs = 2500;
+
+// Gets the current display rotation for the display with the specified
+// |display_id|.
+gfx::Display::Rotation GetCurrentRotation(int64 display_id) {
+  return Shell::GetInstance()
+      ->display_manager()
+      ->GetDisplayInfo(display_id)
+      .rotation();
+}
+
+// Returns true if the rotation between |initial_rotation| and |new_rotation| is
+// 180 degrees.
+bool Is180DegreeFlip(gfx::Display::Rotation initial_rotation,
+                     gfx::Display::Rotation new_rotation) {
+  return (initial_rotation + 2) % 4 == new_rotation;
+}
+
+// A LayerAnimationObserver that will destroy the contained LayerTreeOwner when
+// notified that a layer animation has ended or was aborted.
+class LayerCleanupObserver : public ui::LayerAnimationObserver {
+ public:
+  explicit LayerCleanupObserver(
+      scoped_ptr<ui::LayerTreeOwner> layer_tree_owner);
+  ~LayerCleanupObserver() override;
+
+  // Get the root layer of the owned layer tree.
+  ui::Layer* GetRootLayer();
+
+  // ui::LayerAnimationObserver:
+  void OnLayerAnimationEnded(ui::LayerAnimationSequence* sequence) override;
+  void OnLayerAnimationAborted(ui::LayerAnimationSequence* sequence) override;
+  void OnLayerAnimationScheduled(
+      ui::LayerAnimationSequence* sequence) override {}
+
+ protected:
+  // ui::LayerAnimationObserver:
+  bool RequiresNotificationWhenAnimatorDestroyed() const override {
+    return true;
+  }
+  void OnAttachedToSequence(ui::LayerAnimationSequence* sequence) override;
+  void OnDetachedFromSequence(ui::LayerAnimationSequence* sequence) override;
+
+ private:
+  // The owned layer tree.
+  scoped_ptr<ui::LayerTreeOwner> layer_tree_owner_;
+
+  // The LayerAnimationSequence that |this| has been attached to. Defaults to
+  // nullptr.
+  ui::LayerAnimationSequence* sequence_;
+
+  DISALLOW_COPY_AND_ASSIGN(LayerCleanupObserver);
+};
+
+LayerCleanupObserver::LayerCleanupObserver(
+    scoped_ptr<ui::LayerTreeOwner> layer_tree_owner)
+    : layer_tree_owner_(layer_tree_owner.Pass()), sequence_(nullptr) {
+}
+
+LayerCleanupObserver::~LayerCleanupObserver() {
+  // We must eplicitly detach from |sequence_| because we return true from
+  // RequiresNotificationWhenAnimatorDestroyed.
+  if (sequence_)
+    sequence_->RemoveObserver(this);
+}
+
+ui::Layer* LayerCleanupObserver::GetRootLayer() {
+  return layer_tree_owner_->root();
+}
+
+void LayerCleanupObserver::OnLayerAnimationEnded(
+    ui::LayerAnimationSequence* sequence) {
+  delete this;
+}
+
+void LayerCleanupObserver::OnLayerAnimationAborted(
+    ui::LayerAnimationSequence* sequence) {
+  delete this;
+}
+
+void LayerCleanupObserver::OnAttachedToSequence(
+    ui::LayerAnimationSequence* sequence) {
+  sequence_ = sequence;
+}
+
+void LayerCleanupObserver::OnDetachedFromSequence(
+    ui::LayerAnimationSequence* sequence) {
+  DCHECK(sequence == sequence_);

[oshima, 2015/03/06 20:59:32]

nit: DCHECK_EQ

[bruthig, 2015/03/09 21:04:27]

Done.

+  sequence_ = nullptr;
+}
+
+// Set the screen orientation for the given |display| to |new_rotation| and
+// animate the change.
+void RotateScreen(gfx::Display display,
+                  gfx::Display::Rotation new_rotation,
+                  base::TimeDelta duration,
+                  int rotation_degrees,
+                  int rotation_degree_offset,
+                  gfx::Tween::Type tween_type,
+                  bool should_scale) {
+  aura::Window* root_window =
+      Shell::GetInstance()->display_controller()->GetRootWindowForDisplayId(
+          display.id());
+
+  const gfx::Display::Rotation initial_orientation =
+      GetCurrentRotation(display.id());
+
+  const gfx::RectF original_screen_bounds = root_window->GetTargetBounds();
+  // 180 degree rotations should animate clock-wise.
+  const int rotation_factor =
+      (initial_orientation + 3) % 4 == new_rotation ? 1 : -1;
+
+  scoped_ptr<ui::LayerTreeOwner> old_layer_tree =
+      wm::RecreateLayers(root_window);
+
+  // Add the cloned layer tree in to the root, so it will be rendered.
+  root_window->layer()->Add(old_layer_tree->root());
+  root_window->layer()->StackAtTop(old_layer_tree->root());
+
+  scoped_ptr<LayerCleanupObserver> layer_cleanup_observer(
+      new LayerCleanupObserver(old_layer_tree.Pass()));
+
+  Shell::GetInstance()->display_manager()->SetDisplayRotation(display.id(),
+                                                              new_rotation);
+
+  const gfx::RectF rotated_screen_bounds = root_window->GetTargetBounds();
+  const gfx::Point pivot = gfx::Point(rotated_screen_bounds.width() / 2,
+                                      rotated_screen_bounds.height() / 2);
+
+  gfx::Point3F new_layer_initial_scale = gfx::Point3F(1.0f, 1.0f, 1.0f);
+  gfx::Point3F old_layer_target_scale = gfx::Point3F(1.0f, 1.0f, 1.0f);
+
+  if (should_scale) {
+    new_layer_initial_scale = gfx::Point3F(
+        original_screen_bounds.width() / rotated_screen_bounds.width(),
+        original_screen_bounds.height() / rotated_screen_bounds.height(), 1.0f);
+
+    old_layer_target_scale = gfx::Point3F(
+        rotated_screen_bounds.width() / original_screen_bounds.width(),
+        rotated_screen_bounds.height() / original_screen_bounds.height(), 1.0f);
+  }
+
+  // We must animate each non-cloned child layer individually because the cloned
+  // layer was added as a child to |root_window|'s layer so that it will be
+  // rendered.

[oshima, 2015/03/06 20:59:32]

instead, can't we simply apply the transform to the root, but apply the
transform that cancel it to the old layer?

[bruthig, 2015/03/09 21:04:27]

I'm hesitant to implement it like that for a couple of reasons.

1) The benefit is unclear to me.

2) To implement it as suggested the old_layer animation sequence would have to
apply the inverse transform of the interpolated transform from the root's
animation sequence at each call to ScreenRotationAnimation::OnProgress(...).  I
feel like from a code maintenance and understand-ability perspective this is not
a win.

3) This would couple the two animations and would make it impossible to animate
the opacity of the new and old layer trees independently.

4) I consider having to add the old_layer as a child (instead of a sibling) is a
work-around in the first place.  I wish there was, or I knew how, to get the
old_layer to render without having to add it as a child.

[oshima, 2015/03/10 22:20:38]

We can actually have a layer with NOT_DRAWN under root window, and move children
there.
This way, you can just apply transform to one layer.

It's a cheaper and simpler. If you still don't like it, I'm fine as is.

[bruthig, 2015/03/11 14:40:07]

Added a TODO to implement this.

+  for (ui::Layer* child_layer : root_window->layer()->children()) {
+    // Skip the cloned layer because it has a different animation.
+    if (child_layer == layer_cleanup_observer->GetRootLayer())
+      continue;

[oshima, 2015/03/10 22:20:38]

can you add old layer after animations are applied?

[bruthig, 2015/03/11 14:40:07]

Am I correct to assume that this was an alternative suggestion to the NOT_DRAWN
layer above?

[oshima, 2015/03/11 22:43:43]

Yes. If you're going to change, you may leave it as is.

+
+    scoped_ptr<ScreenRotationAnimation> screen_rotation(
+        new ScreenRotationAnimation(
+            child_layer, rotation_degrees * rotation_factor,
+            0 /* end_degrees */, child_layer->opacity(),
+            1.0f /* target_opacity */, new_layer_initial_scale,
+            gfx::Point3F(1.0f, 1.0f, 1.0f), pivot, duration, tween_type));
+
+    ui::LayerAnimator* animator = child_layer->GetAnimator();
+    animator->set_preemption_strategy(
+        ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
+    scoped_ptr<ui::LayerAnimationSequence> animation_sequence(
+        new ui::LayerAnimationSequence(screen_rotation.release()));
+    animator->StartAnimation(animation_sequence.release());
+  }
+
+  // The old layer will also be transformed into the new orientation. We will
+  // translate it so that the old layer's center point aligns with the new
+  // orientation's center point and use that center point as the pivot for the
+  // rotation animation.
+  gfx::Transform translate_transform;
+  translate_transform.Translate(
+      (rotated_screen_bounds.width() - original_screen_bounds.width()) / 2,
+      (rotated_screen_bounds.height() - original_screen_bounds.height()) / 2);
+  layer_cleanup_observer->GetRootLayer()->SetTransform(translate_transform);
+
+  scoped_ptr<ScreenRotationAnimation> screen_rotation(
+      new ScreenRotationAnimation(
+          layer_cleanup_observer->GetRootLayer(),
+          (rotation_degrees + rotation_degree_offset) * rotation_factor,
+          rotation_degree_offset * rotation_factor,
+          layer_cleanup_observer->GetRootLayer()->opacity(),
+          0.0f /* target_opacity */, gfx::Point3F(1.0f, 1.0f, 1.0f),
+          old_layer_target_scale, pivot, duration, tween_type));
+
+  ui::LayerAnimator* animator =
+      layer_cleanup_observer->GetRootLayer()->GetAnimator();
+  animator->set_preemption_strategy(
+      ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
+  scoped_ptr<ui::LayerAnimationSequence> animation_sequence(
+      new ui::LayerAnimationSequence(screen_rotation.release()));
+  // Add an observer so that the cloned layers can be cleaned up with the
+  // animation completes/aborts.
+  animation_sequence->AddObserver(layer_cleanup_observer.release());
+  animator->StartAnimation(animation_sequence.release());
+}
+
+}  // namespace
+
+ScreenRotationAnimator::ScreenRotationAnimator(int64 display_id)
+    : display_(Shell::GetInstance()->display_manager()->GetDisplayForId(
+          display_id)) {
+}
+
+ScreenRotationAnimator::ScreenRotationAnimator(gfx::Display display)
+    : display_(display) {
+}
+
+ScreenRotationAnimator::~ScreenRotationAnimator() {
+}
+
+void ScreenRotationAnimator::Rotate(gfx::Display::Rotation new_rotation) {
+  const gfx::Display::Rotation current_rotation =
+      GetCurrentRotation(display_.id());
+
+  if (current_rotation == new_rotation)
+    return;
+
+  const std::string switch_value =
+      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+          switches::kAshEnableScreenRotationAnimation);
+
+  if (switch_value.empty()) {
+    Shell::GetInstance()->display_manager()->SetDisplayRotation(display_.id(),
+                                                                new_rotation);
+    return;
+  }
+
+  if (kPartialRotation == switch_value ||
+      kPartialRotationSlow == switch_value) {
+    const int durationInMs = (kPartialRotation == switch_value)
+                                 ? kRotationDurationInMs
+                                 : kRotationDurationSlowInMs;
+    const int rotation_degree_offset =
+        Is180DegreeFlip(current_rotation, new_rotation)
+            ? 180 - kPartialRotationDegrees
+            : 90 - kPartialRotationDegrees;
+
+    RotateScreen(display_, new_rotation,
+                 base::TimeDelta::FromMilliseconds(durationInMs),
+                 kPartialRotationDegrees, rotation_degree_offset,
+                 gfx::Tween::FAST_OUT_LINEAR_IN, false /* should_scale */);
+  } else if (kFullRotation == switch_value ||
+             kFullRotationSlow == switch_value) {
+    const int durationInMs = (kFullRotation == switch_value)
+                                 ? kRotationDurationInMs
+                                 : kRotationDurationSlowInMs;
+    const int rotation_degrees =
+        Is180DegreeFlip(current_rotation, new_rotation) ? 180 : 90;
+
+    RotateScreen(display_, new_rotation,
+                 base::TimeDelta::FromMilliseconds(durationInMs),
+                 rotation_degrees, 0 /* rotation_degree_offset */,
+                 gfx::Tween::FAST_OUT_LINEAR_IN, true /* should_scale */);

[oshima, 2015/03/06 20:59:32]

showing stretched image sounds a bit weird.  Didn't "full rotation, no scale"
work well?

[bruthig, 2015/03/09 21:04:27]

I showed that implementation to some developers close by and the general feeling
was it didn't look all that great because of the large black area's while the
old layer faded out.

The two implementations captured in this review are ones specifically asked for
by designers.

[oshima, 2015/03/10 22:20:38]

I tried it on my desktop and showing stretched image didn't look great either.
I think we just need try it on the field though.

+  } else {
+    NOTREACHED();
+  }
+}
+
+}  // namespace ash