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..45f016ff9648a2ee2ee0441782bbbc11d5d1bd9b
--- /dev/null
+++ b/ash/rotator/screen_rotation_animator.cc
@@ -0,0 +1,324 @@
+// 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"
+
+namespace ash {
+
+namespace {
+
+// Clones all child layers of |to_clone| and adds the clones as children to
+// |parent|. Recurses on each child of |to_clone|.
+void CloneChildren(ui::Layer* to_clone, ui::Layer* parent) {
+  typedef std::vector<ui::Layer*> Layers;
+  // Make a copy of the children since RecreateLayer() mutates it.
+  Layers children(to_clone->children());
+  for (Layers::const_iterator i = children.begin(); i != children.end(); ++i) {
+    ui::LayerOwner* owner = (*i)->owner();
+    ui::Layer* clone = owner ? owner->RecreateLayer().release() : NULL;
+    if (clone) {
+      parent->Add(clone);
+      // RecreateLayer() moves the existing children to the new layer. Create a
+      // copy of those.
+      CloneChildren(owner->layer(), clone);
+    }
+  }
+}
+
+// Clones the layer tree owned by |window| and adds the cloned layer tree as a
+// child of |window|'s layer.
+scoped_ptr<ui::LayerTreeOwner> CloneWindowLayers(aura::Window* window) {
+  scoped_ptr<ui::LayerTreeOwner> cloned_layer_tree(
+      new ui::LayerTreeOwner(new ui::Layer()));
+  CloneChildren(window->layer(), cloned_layer_tree->root());
+
+  DCHECK(cloned_layer_tree->root());
+  DCHECK(window->layer());
+
+  // Add the cloned layer tree into the root, so it will be rendered.
+  window->layer()->Add(cloned_layer_tree->root());
+  window->layer()->StackAtTop(cloned_layer_tree->root());
+
+  return cloned_layer_tree.Pass();
+}
+
+// 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_);
+  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) {

[Jun Mukai, 2015/03/03 23:36:42]

Indent seems wrong. Run git cl format.

[bruthig, 2015/03/04 15:31:36]

Done.

+  aura::Window* root_window = Shell::GetInstance()->display_controller()->
+      GetRootWindowForDisplayId(display.id());
+
+  const gfx::Rect original_screen_bounds_f = root_window->GetTargetBounds();

[Jun Mukai, 2015/03/03 23:36:41]

What does the _f prefix mean?  Did you intend to use RectF?

[bruthig, 2015/03/04 15:31:36]

Ya.  I just made both *_screen_bounds variables RectF's and dropped the _f
suffix.

Done.

[Jun Mukai, 2015/03/04 19:46:20]

Ah, actually I'm okay with _f prefix itself, I wondered because this is just a
Rect but has _f prefix. 

+  // 180 degree rotations should animation clock-wise.
+  const int rotation_factor =
+      (GetCurrentRotation(display.id()) + 3) % 4 == new_rotation ? 1 : -1;
+  scoped_ptr<LayerCleanupObserver> layer_cleanup_observer(
+      new LayerCleanupObserver(CloneWindowLayers(root_window).Pass()));
+
+  Shell::GetInstance()->display_manager()->SetDisplayRotation(display.id(),
+      new_rotation);
+
+  const gfx::Rect rotated_screen_bounds = root_window->GetTargetBounds();
+  const gfx::Point pivot =
+      Is180DegreeFlip(GetCurrentRotation(display.id()), new_rotation) ?
+          gfx::Point(rotated_screen_bounds.height() / 2,
+                     rotated_screen_bounds.width() / 2) :
+          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) {
+    const gfx::RectF rotated_screen_bounds_f = rotated_screen_bounds;
+    new_layer_initial_scale = gfx::Point3F(
+      original_screen_bounds_f.width() / rotated_screen_bounds_f.width(),
+      original_screen_bounds_f.height() / rotated_screen_bounds_f.height(),
+      1.0f);
+
+    old_layer_target_scale = gfx::Point3F(
+      rotated_screen_bounds_f.width() / original_screen_bounds_f.width(),
+      rotated_screen_bounds_f.height() / original_screen_bounds_f.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.
+  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;
+
+    scoped_ptr<ScreenRotationAnimation> screen_rotation(
+        new ScreenRotationAnimation(child_layer,
+            rotation_degrees * rotation_factor,
+            0 /* end_degrees */,
+            new_layer_initial_scale,
+            gfx::Point3F(1.0f, 1.0f, 1.0f),
+            pivot,
+            duration));
+
+    screen_rotation->set_tween_type(tween_type);
+    screen_rotation->set_target_opacity(1.0f);

[Jun Mukai, 2015/03/03 23:36:41]

Why these values aren't in constructor params?

[bruthig, 2015/03/04 15:31:36]

I thought the default values for them were reasonable and I thought reducing the
number of parameters in the constructor simplified it for re-use.  Also these
values are not necessary during construction.

[Jun Mukai, 2015/03/04 19:46:20]

I still don't see the reason why these two fields are different. I feel like
tween type and target opacity are just animation parameters, they are same as
end-degree or pivot or duration or something else.
Also anyways these parameters come from the arguments of this RotateScreen
function, they don't complicate the interface.

So if it's better to separate these two makes sense, consider to pass the layer
only as the constructor parameter and set other parameters as optional.

If those animation parameters should be constructor params, consider passing
tween type and target opacity as the constructor params as well. The parameters
are already very complicated, adding two more doesn't have much differences.

[bruthig, 2015/03/06 16:00:33]

Done.

+
+    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());

[Jun Mukai, 2015/03/03 23:36:41]

Could we use ScopedLayerAnimationSettings instead of using LayerAnimator
directly?  If it's just applying a transform, I think that's better.

With ScopedLayerAnimationSettings, ui/compositor/closure_animation_observer.h
can care about the handling events for animation ends and reduce your layer
observer code.

[bruthig, 2015/03/04 15:31:36]

No I don't think it's possible to use the ScopedLayerAnimationSettings directly
because we are applying a compound interpolated transform and we can't achieve
the rotation pivot without it.

[Jun Mukai, 2015/03/04 19:46:20]

got it. Sorry for my poor comment.

+  }
+
+  // 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 =
+      layer_cleanup_observer->GetRootLayer()->GetTargetTransform();
+  translate_transform.Translate(
+      (rotated_screen_bounds.width() - original_screen_bounds_f.width()) / 2,
+      (rotated_screen_bounds.height() - original_screen_bounds_f.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,
+          gfx::Point3F(1.0f, 1.0f, 1.0f),
+          old_layer_target_scale,
+          pivot,
+          duration));
+
+  screen_rotation->set_tween_type(tween_type);
+  screen_rotation->set_target_opacity(0.0f);
+
+  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) {
+    Shell::GetInstance()->display_manager()->SetDisplayRotation(display_.id(),
+      new_rotation);
+    return;
+  }
+
+  if ("partial-rotation" == switch_value ||
+      "partial-rotation-slow" == switch_value) {
+    RotateScreen(display_,
+                 new_rotation,
+                 base::TimeDelta::FromMilliseconds(
+                     "partial-rotation" == switch_value ? 250 : 2500),

[Jun Mukai, 2015/03/03 23:36:41]

You should declare constants for those values, like
const int kRotationDurationInMs = 250;
const int kRotationDurationSlowInMs = 2500;
so that you can share the values below.

[bruthig, 2015/03/04 15:31:35]

Done.

+                 20 /* rotation_degrees */,
+                 Is180DegreeFlip(current_rotation, new_rotation) ? 160 : 70,

[Jun Mukai, 2015/03/03 23:36:41]

What do these 160/70 mean?

[bruthig, 2015/03/04 15:31:36]

I attempted to clarify by adding the kPartialRotationDegrees constant.

Done.

+                 gfx::Tween::FAST_OUT_LINEAR_IN,
+                 false /* should_scale */);
+  } else if ("full-rotation" == switch_value ||
+             "full-rotation-slow" == switch_value) {
+      RotateScreen(display_,
+                   new_rotation,
+                   base::TimeDelta::FromMilliseconds(
+                       "full-rotation" == switch_value ? 250 : 2500),
+                   Is180DegreeFlip(current_rotation, new_rotation) ? 180 : 90,
+                   0 /* rotation_degree_offset */,
+                   gfx::Tween::FAST_OUT_LINEAR_IN,
+                   true /* should_scale */);
+  } else {
+    DCHECK(false);
+  }
+}
+
+}  // namespace ash