Add screen rotation animator lock.

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 "ash/ash_switches.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/rotator/screen_rotation_animation.h"
+#include "ash/rotator/screen_rotation_animator_lock.h"
 #include "ash/rotator/screen_rotation_animator_observer.h"
 #include "ash/shell.h"
 #include "ash/utility/transformer_util.h"
+#include "ash/wallpaper/wallpaper_controller.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/threading/thread_task_runner_handle.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_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"
 #include "ui/gfx/animation/tween.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 {
 
 // The number of degrees that the rotation animations animate through.
-const int kRotationDegrees = 20;
+constexpr int kRotationDegrees = 20;
 
 // The time it takes for the rotation animations to run.
-const int kRotationDurationInMs = 250;
+constexpr int kRotationDurationInMs = 250;
+
+// The timeout for waiting |ScreenRotationAnimatorLock|.
+constexpr int kAnimatorLockTimeoutMs = 500;
 
 // The rotation factors.
-const int kCounterClockWiseRotationFactor = 1;
-const int kClockWiseRotationFactor = -1;
+constexpr int kCounterClockWiseRotationFactor = 1;
+constexpr int kClockWiseRotationFactor = -1;
 
 display::Display::Rotation GetCurrentScreenRotation(int64_t display_id) {
   return Shell::Get()
       ->display_manager()
       ->GetDisplayInfo(display_id)
       .GetActiveRotation();
 }
 
 bool IsDisplayIdValid(int64_t display_id) {
   return Shell::Get()->display_manager()->IsDisplayIdValid(display_id);
@@ skipping 107 matching lines @@
       rotation_request_id_(0),
       metrics_reporter_(
           base::MakeUnique<ScreenRotationAnimationMetricsReporter>()),
       disable_animation_timers_for_test_(false),
       has_switch_ash_disable_smooth_screen_rotation_(
           base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kAshDisableSmoothScreenRotation)),
       root_window_(GetRootWindow(display_id_)),
       screen_rotation_container_layer_(
           GetScreenRotationContainer(root_window_)->layer()),
-      weak_factory_(this) {}
+      weak_factory_(this),
+      lock_weak_ptr_factory_(this) {}
 
 ScreenRotationAnimator::~ScreenRotationAnimator() {
+  lock_weak_ptr_factory_.InvalidateWeakPtrs();
   // To prevent a call to |AnimationEndedCallback()| 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) {
   const display::Display::Rotation current_rotation =
       GetCurrentScreenRotation(display_id_);
   if (current_rotation == rotation_request->new_rotation) {
     // We need to call |ProcessAnimationQueue()| to prepare for next rotation
     // request.
     ProcessAnimationQueue();
     return;
   }
 
+  // The |ScreenRotationAnimatorLock| will be reset in |ProcessAnimationQueue|
+  // when animation is finished.
+  // |ScreenRotationAnimatorLock| will only work in the smooth animation. But
+  // for simplicity, set/reset the lock for both slow/smooth animation.
+  // If we need to wait for multiple event, e.g. ARC app resize, we can add more
+  // locks here.
+  Shell::Get()->wallpaper_controller()->SetScreenRotationAnimatorLock(
+      CreateAnimatorLock());
   rotation_request->old_rotation = current_rotation;
   if (has_switch_ash_disable_smooth_screen_rotation_) {
     StartSlowAnimation(std::move(rotation_request));
   } else {
     std::unique_ptr<cc::CopyOutputRequest> copy_output_request =
         cc::CopyOutputRequest::CreateRequest(
             CreateAfterCopyCallbackBeforeRotation(std::move(rotation_request)));
     RequestCopyScreenRotationContainerLayer(std::move(copy_output_request));
     screen_rotation_state_ = COPY_REQUESTED;
   }
@@ skipping 64 matching lines @@
     Shell::Get()->display_manager()->SetDisplayRotation(
         display_id_, rotation_request->new_rotation, rotation_request->source);
     ProcessAnimationQueue();
     return;
   }
 
   old_layer_tree_owner_ = CopyLayerTree(std::move(result));
   AddLayerAtTopOfWindowLayers(root_window_, old_layer_tree_owner_->root());
   SetRotation(rotation_request->old_rotation, rotation_request->new_rotation,
               rotation_request->source);
-  std::unique_ptr<cc::CopyOutputRequest> copy_output_request =
-      cc::CopyOutputRequest::CreateRequest(
-          CreateAfterCopyCallbackAfterRotation(std::move(rotation_request)));
-  RequestCopyScreenRotationContainerLayer(std::move(copy_output_request));
+
+  // If the rotation angle is 180 degree, there is no resize.
+  if (Is180DegreeFlip(rotation_request->old_rotation,
+                      rotation_request->new_rotation)) {
+    std::unique_ptr<cc::CopyOutputRequest> copy_output_request =
+        cc::CopyOutputRequest::CreateRequest(
+            CreateAfterCopyCallbackAfterRotation(std::move(rotation_request)));
+    RequestCopyScreenRotationContainerLayer(std::move(copy_output_request));
+  } else {
+    rotation_request_after_unlock_ = std::move(rotation_request);
+  }
 }
 
 void ScreenRotationAnimator::OnScreenRotationContainerLayerCopiedAfterRotation(
     std::unique_ptr<ScreenRotationRequest> rotation_request,
     std::unique_ptr<cc::CopyOutputResult> result) {
   if (IgnoreCopyResult(rotation_request->id, rotation_request_id_))
     return;
   // In the following cases, abort animation:
   // 1) if the display was removed,
   // 2) the copy request has been canceled or failed. It would fail if,
@@ skipping 160 matching lines @@
   screen_rotation_animator_observers_.RemoveObserver(observer);
 }
 
 void ScreenRotationAnimator::ProcessAnimationQueue() {
   screen_rotation_state_ = IDLE;
   if (IsDisplayIdValid(display_id_) && black_mask_layer_owner_)
     root_window_->layer()->Remove(black_mask_layer_owner_->layer());
   old_layer_tree_owner_.reset();
   new_layer_tree_owner_.reset();
   black_mask_layer_owner_.reset();
+  ResetCreatedAnimatorLocks();
   if (last_pending_request_ && IsDisplayIdValid(display_id_)) {
     StartRotationAnimation(std::move(last_pending_request_));
     return;
   }
 
   // This is only used in test to notify animator observer.
   for (auto& observer : screen_rotation_animator_observers_)
     observer.OnScreenRotationAnimationFinished(this);
 }
 
 void ScreenRotationAnimator::StopAnimating() {
   // |old_layer_tree_owner_| new_layer_tree_owner_| could be nullptr if another
   // the rotation request comes before the copy request finished.
   if (old_layer_tree_owner_)
     old_layer_tree_owner_->root()->GetAnimator()->StopAnimating();
   if (new_layer_tree_owner_)
     new_layer_tree_owner_->root()->GetAnimator()->StopAnimating();
   if (IsDisplayIdValid(display_id_) && black_mask_layer_owner_)
     root_window_->layer()->Remove(black_mask_layer_owner_->layer());
 }
 
+ScreenRotationAnimatorLock* ScreenRotationAnimator::CreateAnimatorLock() {
+  auto lock_unique_ptr = base::MakeUnique<ScreenRotationAnimatorLock>(
+      lock_weak_ptr_factory_.GetWeakPtr());
+  auto* lock = lock_unique_ptr.get();
+  created_locks_.push_back(std::move(lock_unique_ptr));
+  return lock;
+}
+
+void ScreenRotationAnimator::AddAnimatorLock(ScreenRotationAnimatorLock* lock) {
+  bool was_empty = active_locks_.empty();
+  active_locks_.push_back(lock);
+  if (was_empty) {
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&ScreenRotationAnimator::TimeoutAnimatorLocks,
+                   lock_weak_ptr_factory_.GetWeakPtr()),
+        base::TimeDelta::FromMilliseconds(kAnimatorLockTimeoutMs));
+  }
+}
+
+void ScreenRotationAnimator::RemoveAnimatorLock(
+    ScreenRotationAnimatorLock* lock) {
+  base::Erase(active_locks_, lock);
+  if (active_locks_.empty()) {
+    lock_weak_ptr_factory_.InvalidateWeakPtrs();
+    // If we are waiting for the lock, we should send the second copy request
+    // after screen rotation.
+    if (rotation_request_after_unlock_) {
+      std::unique_ptr<cc::CopyOutputRequest> copy_output_request =
+          cc::CopyOutputRequest::CreateRequest(
+              CreateAfterCopyCallbackAfterRotation(
+                  std::move(rotation_request_after_unlock_)));
+      RequestCopyScreenRotationContainerLayer(std::move(copy_output_request));
+    }
+  }
+}
+
+void ScreenRotationAnimator::TimeoutAnimatorLocks() {
+  // Make a copy, we're going to cause |active_locks_| to become
+  // empty
+  std::vector<ScreenRotationAnimatorLock*> locks = active_locks_;
+  for (auto* lock : locks)
+    lock->TimeoutLock();
+  DCHECK(active_locks_.empty());
+}
+
+void ScreenRotationAnimator::ResetCreatedAnimatorLocks() {
+  created_locks_.clear();
+  active_locks_.clear();
+}
+
 }  // namespace ash