Add second copy request after screen rotation to flatten the layers in animation.

ash/rotator/screen_rotation_animator.cc

 // 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 <utility>
 #include <vector>
 
+#include "ash/common/ash_switches.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/rotator/screen_rotation_animation.h"
 #include "ash/rotator/screen_rotation_animator_observer.h"
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/time/time.h"
+#include "cc/output/copy_output_request.h"
+#include "cc/output/copy_output_result.h"
 #include "ui/aura/window.h"
+#include "ui/compositor/callback_layer_animation_observer.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_element.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/display/display.h"
 #include "ui/display/manager/display_manager.h"
 #include "ui/display/manager/managed_display_info.h"
@@ skipping 12 matching lines @@
 // The number of degrees that the rotation animations animate through.
 const int kRotationDegrees = 20;
 
 // The time it takes for the rotation animations to run.
 const int kRotationDurationInMs = 250;
 
 // The rotation factors.
 const int kCounterClockWiseRotationFactor = 1;
 const int kClockWiseRotationFactor = -1;
 
-// Aborts the active animations of the layer, and recurses upon its child
-// layers.
-void AbortAnimations(ui::Layer* layer) {
-  for (ui::Layer* child_layer : layer->children())
-    AbortAnimations(child_layer);
-  layer->GetAnimator()->AbortAllAnimations();
-}
+// The delegate root layer name.
+const std::string kDelegateRootLayerName = "DelegateRootLayer";
+// The old root layer name.
+const std::string kOldRootLayerName = "ScreenRotationAnimator:old_layer_tree";
+// The new root layer name.
+const std::string kNewRootLayerName = "ScreenRotationAnimator:new_layer_tree";
 
 display::Display::Rotation GetCurrentScreenRotation(int64_t display_id) {
   return Shell::GetInstance()
       ->display_manager()
       ->GetDisplayInfo(display_id)
       .GetActiveRotation();
 }
 
 bool IsDisplayIdValid(int64_t display_id) {
   return Shell::GetInstance()->display_manager()->IsDisplayIdValid(display_id);
 }
 
 // 180 degree rotations should animate clock-wise.
 int GetRotationFactor(display::Display::Rotation initial_rotation,
                       display::Display::Rotation new_rotation) {
   return (initial_rotation + 3) % 4 == new_rotation
              ? kCounterClockWiseRotationFactor
              : kClockWiseRotationFactor;
 }
 
 aura::Window* GetRootWindow(int64_t display_id) {
   return Shell::GetInstance()
       ->window_tree_host_manager()
       ->GetRootWindowForDisplayId(display_id);
 }
 
+ui::Layer* GetChildLayerByName(ui::Layer* parent, const std::string& name) {
+  for (ui::Layer* child_layer : parent->children()) {
+    if (child_layer->name() == name)
+      return child_layer;
+  }
+  NOTREACHED();
+  return nullptr;
+}
+
 // Returns true if the rotation between |initial_rotation| and |new_rotation| is
 // 180 degrees.
 bool Is180DegreeFlip(display::Display::Rotation initial_rotation,
                      display::Display::Rotation new_rotation) {
   return (initial_rotation + 2) % 4 == new_rotation;
 }
 
 // Returns the initial degrees the old layer animation to begin with.
 int GetInitialDegrees(display::Display::Rotation initial_rotation,
                       display::Display::Rotation new_rotation) {
   return (Is180DegreeFlip(initial_rotation, new_rotation) ? 180 : 90);
 }
 
-// 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:
-  // Takes WeakPtr of ScreenRotationAnimator. |this| may outlive the |animator_|
-  // instance and the |animator_| isn't detaching itself as an observer when
-  // being destroyed. However, ideally, when |animator_| is destroying,
-  // deleting |old_layer_tree_owner_| will trigger OnLayerAnimationAborted and
-  // delete |this| before |animator_| deleted.
-  explicit LayerCleanupObserver(base::WeakPtr<ScreenRotationAnimator> animator);
-  ~LayerCleanupObserver() override;
-
-  // 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:
-  base::WeakPtr<ScreenRotationAnimator> animator_;
-
-  // The LayerAnimationSequence that |this| has been attached to. Defaults to
-  // nullptr.
-  ui::LayerAnimationSequence* sequence_;
-
-  DISALLOW_COPY_AND_ASSIGN(LayerCleanupObserver);
-};
-
-LayerCleanupObserver::LayerCleanupObserver(
-    base::WeakPtr<ScreenRotationAnimator> animator)
-    : animator_(animator), sequence_(nullptr) {}
-
-LayerCleanupObserver::~LayerCleanupObserver() {
-  // We must eplicitly detach from |sequence_| because we return true from
-  // RequiresNotificationWhenAnimatorDestroyed.
-  if (sequence_)
-    sequence_->RemoveObserver(this);
-}
-
-void LayerCleanupObserver::OnLayerAnimationEnded(
-    ui::LayerAnimationSequence* sequence) {
-  if (animator_)
-    animator_->ProcessAnimationQueue();
-
-  delete this;
-}
-
-void LayerCleanupObserver::OnLayerAnimationAborted(
-    ui::LayerAnimationSequence* sequence) {
-  if (animator_)
-    animator_->ProcessAnimationQueue();
-
-  delete this;
-}
-
-void LayerCleanupObserver::OnAttachedToSequence(
-    ui::LayerAnimationSequence* sequence) {
-  sequence_ = sequence;
-}
-
-void LayerCleanupObserver::OnDetachedFromSequence(
-    ui::LayerAnimationSequence* sequence) {
-  DCHECK_EQ(sequence, sequence_);
-  sequence_ = nullptr;
-}
-
 class ScreenRotationAnimationMetricsReporter
     : public ui::AnimationMetricsReporter {
  public:
   ScreenRotationAnimationMetricsReporter() {}
   ~ScreenRotationAnimationMetricsReporter() override {}
 
   void Report(int value) override {
     UMA_HISTOGRAM_PERCENTAGE("Ash.Rotation.AnimationSmoothness", value);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ScreenRotationAnimationMetricsReporter);
 };
 
+void AddLayerAtTopOfWindowLayers(aura::Window* root_window, ui::Layer* layer) {
+  // Add the cloned layer tree in to the root, so it will be rendered.
+  root_window->layer()->Add(layer);
+  root_window->layer()->StackAtTop(layer);
+}
+
+bool AnimationEndedCallback(
+    base::WeakPtr<ScreenRotationAnimator> animator,
+    const ui::CallbackLayerAnimationObserver& observer) {
+  if (animator)
+    animator->ProcessAnimationQueue();
+  return true;
+}
+
+// Round near zero value to zero.
+void RoundNearZero(gfx::Transform* transform) {
+  const float kEpsilon = 0.001f;
+  SkMatrix44& matrix = transform->matrix();
+  for (int x = 0; x < 4; ++x) {
+    for (int y = 0; y < 4; ++y) {
+      if (std::abs(SkMScalarToFloat(matrix.get(x, y))) < kEpsilon)
+        matrix.set(x, y, SkFloatToMScalar(0.0f));
+    }
+  }
+}
+
+void TransformLayerToOldRotation(
+    ui::Layer* layer,
+    const int64_t display_id,
+    const display::Display::Rotation& new_rotation,
+    const display::Display::Rotation& old_rotation) {
+  const display::Display display =
+      Shell::GetInstance()->display_manager()->GetDisplayForId(display_id);
+
+  const int rotation_changed = ((new_rotation - old_rotation) + 4) % 4;
+  float one_pixel = 1.0f / display.device_scale_factor();
+  gfx::Transform transform;
+  switch (rotation_changed) {
+    case 0:
+      break;
+    case 1:
+      transform.Rotate(270);
+      transform.Translate(-display.bounds().height() + one_pixel, 0);
+      break;
+    case 2:
+      transform.Rotate(180);
+      transform.Translate(-display.bounds().width() + one_pixel,
+                          -display.bounds().height() + one_pixel);
+      break;
+    case 3:
+      transform.Rotate(90);
+      transform.Translate(0, -display.bounds().width() + one_pixel);
+      break;
+  }
+
+  RoundNearZero(&transform);
+  layer->SetTransform(transform);
+}
+
 }  // namespace
 
 struct ScreenRotationAnimator::ScreenRotationRequest {
-  ScreenRotationRequest(display::Display::Rotation to_rotation,
-                        display::Display::RotationSource from_source)
-      : new_rotation(to_rotation), source(from_source) {}
+  ScreenRotationRequest(const display::Display::Rotation& from_rotation,
+                        const display::Display::Rotation& to_rotation,
+                        const display::Display::RotationSource& from_source)
+      : old_rotation(from_rotation),
+        new_rotation(to_rotation),
+        source(from_source) {}
+  display::Display::Rotation old_rotation;
   display::Display::Rotation new_rotation;
   display::Display::RotationSource source;
 };
 
 ScreenRotationAnimator::ScreenRotationAnimator(int64_t display_id)
     : display_id_(display_id),
       is_rotating_(false),
       metrics_reporter_(
           base::MakeUnique<ScreenRotationAnimationMetricsReporter>()),
       disable_animation_timers_for_test_(false),
       weak_factory_(this) {}
 
 ScreenRotationAnimator::~ScreenRotationAnimator() {
   // To prevent a call to |LayerCleanupObserver::OnLayerAnimationAborted()| from
   // calling a method on the |animator_|.
   weak_factory_.InvalidateWeakPtrs();
 
   // Explicitly reset the |old_layer_tree_owner_| and |metrics_reporter_| in
   // order to make sure |metrics_reporter_| outlives the attached animation
   // sequence.
   old_layer_tree_owner_.reset();
   metrics_reporter_.reset();
 }
 
+void ScreenRotationAnimator::StartRotationAnimation(
+    std::unique_ptr<ScreenRotationRequest> rotation_request) {
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kAshEnableSmoothScreenRotation)) {
+    const cc::CopyOutputRequest::CopyOutputRequestCallback callback =
+        base::Bind(&ScreenRotationAnimator::OnRootLayerCopiedBeforeRotation,
+                   weak_factory_.GetWeakPtr(), base::Passed(&rotation_request));
+    RequestCopyRootLayerByName(kDelegateRootLayerName, callback);
+  } else {
+    StartSlowAnimation(std::move(rotation_request));
+  }
+}
+
+void ScreenRotationAnimator::SetRotation(
+    const display::Display::Rotation& new_rotation,
+    const display::Display::Rotation& old_rotation,
+    const display::Display::RotationSource& source) {
+  Shell::GetInstance()->display_manager()->SetDisplayRotation(
+      display_id_, new_rotation, source);
+  TransformLayerToOldRotation(old_layer_tree_owner_->root(), display_id_,
+                              new_rotation, old_rotation);
+}
+
+void ScreenRotationAnimator::StartSlowAnimation(
+    std::unique_ptr<ScreenRotationRequest> rotation_request) {
+  CreateOldLayerTree();
+  SetRotation(rotation_request->new_rotation, rotation_request->old_rotation,
+              rotation_request->source);
+  AnimateRotation(std::move(rotation_request));
+}
+
+void ScreenRotationAnimator::RequestCopyRootLayerByName(
+    const std::string& layer_name,
+    const cc::CopyOutputRequest::CopyOutputRequestCallback& callback) {
+  std::unique_ptr<cc::CopyOutputRequest> copy_output_request =
+      cc::CopyOutputRequest::CreateRequest(callback);
+  ui::Layer* layer =
+      GetChildLayerByName(GetRootWindow(display_id_)->layer(), layer_name);
+  gfx::Rect rect(layer->size());
+  copy_output_request->set_area(rect);
+  layer->RequestCopyOfOutput(std::move(copy_output_request));
+}
+
+void ScreenRotationAnimator::OnRootLayerCopiedBeforeRotation(
+    std::unique_ptr<ScreenRotationRequest> rotation_request,
+    std::unique_ptr<cc::CopyOutputResult> result) {
+  // If copy request does not succeed or canceled, fall back to recreate layers
+  // solution.
+  if (result->IsEmpty() || result->size().IsEmpty() || !result->HasTexture()) {

[danakj, 2017/03/31 19:32:30]

I don't think you need to check size() or HasTexture.

chromeos only works with GPU compositing, results will always be texture or
empty. The size will always be the size of the surface you're requesting a copy
of.

[wutao, 2017/04/07 06:59:11]

Acknowledged.

+    StartSlowAnimation(std::move(rotation_request));
+  } else {
+    old_layer_tree_owner_ = CopyLayerTree(kOldRootLayerName, std::move(result));
+
+    SetRotation(rotation_request->new_rotation, rotation_request->old_rotation,
+                rotation_request->source);
+
+    const cc::CopyOutputRequest::CopyOutputRequestCallback callback =
+        base::Bind(&ScreenRotationAnimator::OnRootLayerCopiedAfterRotation,
+                   weak_factory_.GetWeakPtr(), base::Passed(&rotation_request));
+    RequestCopyRootLayerByName(kDelegateRootLayerName, callback);

[danakj, 2017/03/31 19:32:30]

Why not do both of these copies at the same time instead of waiting for one to
complete before starting the other?

[wutao, 2017/04/07 06:59:11]

Talked offline, The two requests are on the same layer before/after setting
screen rotation. So need to wait the first request finishes and attach it in
front of old layers to hide the screen rotation. And the second request need to
be taken after the screen rotated and the content are ready.

+  }
+}
+
+void ScreenRotationAnimator::OnRootLayerCopiedAfterRotation(
+    std::unique_ptr<ScreenRotationRequest> rotation_request,
+    std::unique_ptr<cc::CopyOutputResult> result) {
+  if (!result->IsEmpty() && !result->size().IsEmpty() && result->HasTexture())

[danakj, 2017/03/31 19:32:30]

same about size and HasTexture

[wutao, 2017/04/07 06:59:11]

Acknowledged.

+    new_layer_tree_owner_ = CopyLayerTree(kNewRootLayerName, std::move(result));
+  AnimateRotation(std::move(rotation_request));
+}
+
+void ScreenRotationAnimator::CreateOldLayerTree() {
+  aura::Window* root_window = GetRootWindow(display_id_);
+  old_layer_tree_owner_ = ::wm::RecreateLayers(root_window);
+  old_layer_tree_owner_->root()->set_name(kOldRootLayerName);
+  AddLayerAtTopOfWindowLayers(root_window, old_layer_tree_owner_->root());
+}
+
+std::unique_ptr<ui::LayerTreeOwner> ScreenRotationAnimator::CopyLayerTree(
+    const std::string& layer_name,
+    std::unique_ptr<cc::CopyOutputResult> result) {
+  cc::TextureMailbox texture_mailbox;
+  std::unique_ptr<cc::SingleReleaseCallback> release_callback;
+  result->TakeTexture(&texture_mailbox, &release_callback);
+  DCHECK(texture_mailbox.IsTexture());
+
+  aura::Window* root_window = GetRootWindow(display_id_);
+  gfx::Rect rect(root_window->layer()->size());
+  std::unique_ptr<ui::Layer> copy_layer = base::MakeUnique<ui::Layer>();
+  copy_layer->SetBounds(rect);
+  copy_layer->SetTextureMailbox(texture_mailbox, std::move(release_callback),
+                                rect.size());
+
+  copy_layer->set_name(layer_name);
+  AddLayerAtTopOfWindowLayers(root_window, copy_layer.get());
+  return base::MakeUnique<ui::LayerTreeOwner>(std::move(copy_layer));
+}
+
 void ScreenRotationAnimator::AnimateRotation(
     std::unique_ptr<ScreenRotationRequest> rotation_request) {
-  aura::Window* root_window = GetRootWindow(display_id_);
-
-  const gfx::Rect original_screen_bounds = root_window->GetTargetBounds();
-
-  const int rotation_factor = GetRotationFactor(
-      GetCurrentScreenRotation(display_id_), rotation_request->new_rotation);
-
+  const int rotation_factor = GetRotationFactor(rotation_request->old_rotation,
+                                                rotation_request->new_rotation);
   const int old_layer_initial_rotation_degrees = GetInitialDegrees(
-      GetCurrentScreenRotation(display_id_), rotation_request->new_rotation);
-
+      rotation_request->old_rotation, rotation_request->new_rotation);
   const base::TimeDelta duration =
       base::TimeDelta::FromMilliseconds(kRotationDurationInMs);
-
   const gfx::Tween::Type tween_type = gfx::Tween::FAST_OUT_LINEAR_IN;
-
-  std::unique_ptr<ui::LayerTreeOwner> old_layer_tree =
-      ::wm::RecreateLayers(root_window);
-  old_layer_tree->root()->set_name("ScreenRotationAnimator:old_layer_tree");
-
-  // 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());
-
-  old_layer_tree_owner_ = std::move(old_layer_tree);
-  std::unique_ptr<LayerCleanupObserver> old_layer_cleanup_observer(
-      new LayerCleanupObserver(weak_factory_.GetWeakPtr()));
-
-  Shell::GetInstance()->display_manager()->SetDisplayRotation(
-      display_id_, rotation_request->new_rotation, rotation_request->source);
-
+  aura::Window* root_window = GetRootWindow(display_id_);
   const gfx::Rect rotated_screen_bounds = root_window->GetTargetBounds();
   const gfx::Point pivot = gfx::Point(rotated_screen_bounds.width() / 2,
                                       rotated_screen_bounds.height() / 2);
 
-  ui::Layer* old_root_layer = old_layer_tree_owner_->root();
-  // 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.
-  // TODO(bruthig): Add a NOT_DRAWN layer in between the root_window's layer and
-  // its current children so that we only need to initiate two
-  // LayerAnimationSequences. One for the new layers and one for the old layer.
-  for (ui::Layer* child_layer : root_window->layer()->children()) {
-    // Skip the cloned layer because it has a different animation.
-    if (child_layer == old_root_layer)
-      continue;
-
-    std::unique_ptr<ScreenRotationAnimation> screen_rotation =
-        base::MakeUnique<ScreenRotationAnimation>(
-            child_layer, kRotationDegrees * rotation_factor,
-            0 /* end_degrees */, child_layer->opacity(),
-            1.0f /* target_opacity */, pivot, duration, tween_type);
-
-    ui::LayerAnimator* animator = child_layer->GetAnimator();
-    animator->set_preemption_strategy(
-        ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
-    std::unique_ptr<ui::LayerAnimationSequence> animation_sequence =
-        base::MakeUnique<ui::LayerAnimationSequence>(
-            std::move(screen_rotation));
-    animator->StartAnimation(animation_sequence.release());
+  // Make the current layers invisible.
+  if (new_layer_tree_owner_) {
+    GetChildLayerByName(root_window->layer(), kDelegateRootLayerName)
+        ->SetOpacity(0.0f);
   }
 
+  // Add an observer so that the copied layers can be cleaned up with the
+  // animation completes/aborts.
+  ui::CallbackLayerAnimationObserver* observer =
+      new ui::CallbackLayerAnimationObserver(
+          base::Bind(&AnimationEndedCallback, weak_factory_.GetWeakPtr()));
+
+  ui::Layer* new_root_layer;
+  if (new_layer_tree_owner_ &&
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kAshEnableSmoothScreenRotation)) {
+    new_root_layer = new_layer_tree_owner_->root();
+  } else {
+    new_root_layer =
+        GetChildLayerByName(root_window->layer(), kDelegateRootLayerName);
+  }
+
+  std::unique_ptr<ScreenRotationAnimation> current_layer_screen_rotation =
+      base::MakeUnique<ScreenRotationAnimation>(
+          new_root_layer, kRotationDegrees * rotation_factor,
+          0 /* end_degrees */, 0.0f,
+          new_root_layer->opacity() /* target_opacity */, pivot, duration,
+          tween_type);
+
+  ui::LayerAnimator* current_layer_animator = new_root_layer->GetAnimator();
+  current_layer_animator->set_preemption_strategy(
+      ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
+  std::unique_ptr<ui::LayerAnimationSequence> current_layer_animation_sequence =
+      base::MakeUnique<ui::LayerAnimationSequence>(
+          std::move(current_layer_screen_rotation));
+
+  ui::Layer* old_root_layer = old_layer_tree_owner_->root();
+  const gfx::Rect original_screen_bounds = old_root_layer->GetTargetBounds();
   // 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);
   old_root_layer->SetTransform(translate_transform);
 
-  std::unique_ptr<ScreenRotationAnimation> screen_rotation =
+  std::unique_ptr<ScreenRotationAnimation> old_layer_screen_rotation =
       base::MakeUnique<ScreenRotationAnimation>(
           old_root_layer, old_layer_initial_rotation_degrees * rotation_factor,
           (old_layer_initial_rotation_degrees - kRotationDegrees) *
               rotation_factor,
           old_root_layer->opacity(), 0.0f /* target_opacity */, pivot, duration,
           tween_type);
 
-  ui::LayerAnimator* animator = old_root_layer->GetAnimator();
-  animator->set_preemption_strategy(
+  ui::LayerAnimator* old_layer_animator = old_root_layer->GetAnimator();
+  old_layer_animator->set_preemption_strategy(
       ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
-  std::unique_ptr<ui::LayerAnimationSequence> animation_sequence =
-      base::MakeUnique<ui::LayerAnimationSequence>(std::move(screen_rotation));
-  // Add an observer so that the cloned layers can be cleaned up with the
-  // animation completes/aborts.
-  animation_sequence->AddObserver(old_layer_cleanup_observer.release());
-  // In unit test, we can use ash::test::ScreenRotationAnimatorTestApi to
-  // control the animation.
+  std::unique_ptr<ui::LayerAnimationSequence> old_layer_animation_sequence =
+      base::MakeUnique<ui::LayerAnimationSequence>(
+          std::move(old_layer_screen_rotation));
+
   if (disable_animation_timers_for_test_)
-    animator->set_disable_timer_for_test(true);
-  animation_sequence->SetAnimationMetricsReporter(metrics_reporter_.get());
-  animator->StartAnimation(animation_sequence.release());
+    old_layer_animator->set_disable_timer_for_test(true);
+  old_layer_animation_sequence->SetAnimationMetricsReporter(
+      metrics_reporter_.get());
 
+  current_layer_animator->AddObserver(observer);
+  old_layer_animator->AddObserver(observer);
+  current_layer_animator->StartAnimation(
+      current_layer_animation_sequence.release());
+  old_layer_animator->StartAnimation(old_layer_animation_sequence.release());
+  observer->SetActive();
   rotation_request.reset();
 }
 
 void ScreenRotationAnimator::Rotate(display::Display::Rotation new_rotation,
                                     display::Display::RotationSource source) {
-  if (GetCurrentScreenRotation(display_id_) == new_rotation)
+  const display::Display::Rotation current_rotation =
+      GetCurrentScreenRotation(display_id_);
+  if (current_rotation == new_rotation)
     return;
 
   std::unique_ptr<ScreenRotationRequest> rotation_request =
-      base::MakeUnique<ScreenRotationRequest>(new_rotation, source);
+      base::MakeUnique<ScreenRotationRequest>(current_rotation, new_rotation,
+                                              source);
 
   if (is_rotating_) {
     last_pending_request_ = std::move(rotation_request);
     // The pending request will be processed when the
     // OnLayerAnimation(Ended|Aborted) methods should be called after
     // StopAnimating().
     StopAnimating();
   } else {
     is_rotating_ = true;
-    AnimateRotation(std::move(rotation_request));
+    StartRotationAnimation(std::move(rotation_request));
   }
 }
 
 void ScreenRotationAnimator::AddScreenRotationAnimatorObserver(
     ScreenRotationAnimatorObserver* observer) {
   screen_rotation_animator_observers_.AddObserver(observer);
 }
 
 void ScreenRotationAnimator::RemoveScreenRotationAnimatorObserver(
     ScreenRotationAnimatorObserver* observer) {
   screen_rotation_animator_observers_.RemoveObserver(observer);
 }
 
 void ScreenRotationAnimator::ProcessAnimationQueue() {
   is_rotating_ = false;
+  StopAnimating();
   old_layer_tree_owner_.reset();
+  new_layer_tree_owner_.reset();
   if (last_pending_request_ && IsDisplayIdValid(display_id_)) {
     std::unique_ptr<ScreenRotationRequest> rotation_request =
         std::move(last_pending_request_);
     Rotate(rotation_request->new_rotation, rotation_request->source);
     rotation_request.reset();
     return;
   }
 
   for (auto& observer : screen_rotation_animator_observers_)
     observer.OnScreenRotationAnimationFinished(this);
 }
 
 void ScreenRotationAnimator::set_disable_animation_timers_for_test(
     bool disable_timers) {
   disable_animation_timers_for_test_ = disable_timers;
 }
 
 void ScreenRotationAnimator::StopAnimating() {
-  aura::Window* root_window = GetRootWindow(display_id_);
-  for (ui::Layer* child_layer : root_window->layer()->children()) {
-    if (child_layer == old_layer_tree_owner_->root())
-      continue;
-
-    child_layer->GetAnimator()->StopAnimating();
-  }
-
+  GetChildLayerByName(GetRootWindow(display_id_)->layer(),
+                      kDelegateRootLayerName)
+      ->SetOpacity(1.0f);
   old_layer_tree_owner_->root()->GetAnimator()->StopAnimating();
+  // |new_layer_tree_owner_| could be nullptr if the second copy request failed
+  // or canceled.
+  if (new_layer_tree_owner_)
+    new_layer_tree_owner_->root()->GetAnimator()->StopAnimating();
 }
 
 }  // namespace ash