Handles users rotating screen too early

ash/display/display_configuration_controller.cc

 // Copyright 2016 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/display/display_configuration_controller.h"
 
 #include "ash/display/display_animator.h"
 #include "ash/display/display_animator_chromeos.h"
 #include "ash/display/display_util.h"
 #include "ash/rotator/screen_rotation_animator.h"
@@ skipping 82 matching lines @@
                    weak_ptr_factory_.GetWeakPtr(), mirror));
   } else {
     SetMirrorModeImpl(mirror);
   }
 }
 
 void DisplayConfigurationController::SetDisplayRotation(
     int64_t display_id,
     display::Display::Rotation rotation,
     display::Display::RotationSource source) {
-  ash::ScreenRotationAnimator screen_rotation_animator(display_id);
-  if (screen_rotation_animator.CanAnimate())
-    screen_rotation_animator.Rotate(rotation, source);
-  else
+  if (GetCurrentScreenRotation(display_id) == rotation)
+    return;
+
+  if (display_manager_->IsDisplayIdValid(display_id)) {
+    ScreenRotationAnimator* screen_rotation_animator =
+        GetScreenRotationAnimatorForDisplay(display_id);
+    screen_rotation_animator->Rotate(rotation, source);
+  } else {
+    DCHECK(!rotation_animator_map_.count(display_id));
     display_manager_->SetDisplayRotation(display_id, rotation, source);
+  }
 }
 
 void DisplayConfigurationController::SetPrimaryDisplayId(int64_t display_id) {
   if (display_manager_->GetNumDisplays() <= 1 || IsLimited())
     return;
 
   SetThrottleTimeout(kSetPrimaryDisplayThrottleTimeoutMs);
   if (display_animator_) {
     display_animator_->StartFadeOutAnimation(
         base::Bind(&DisplayConfigurationController::SetPrimaryDisplayIdImpl,
                    weak_ptr_factory_.GetWeakPtr(), display_id));
   } else {
     SetPrimaryDisplayIdImpl(display_id);
   }
 }
 
 void DisplayConfigurationController::OnDisplayConfigurationChanged() {
   // TODO(oshima): Stop all animations.
   SetThrottleTimeout(kAfterDisplayChangeThrottleTimeoutMs);
 }
 
+void DisplayConfigurationController::OnScreenRotationAnimationFinished(
+    ScreenRotationAnimator* screen_rotation_animator) {
+  const int64_t display_id = screen_rotation_animator->display_id();
+
+  DCHECK(rotation_animator_map_.count(display_id));
+
+  screen_rotation_animator->RemoveScreenRotationAnimatorObserver(this);
+  rotation_animator_map_.erase(screen_rotation_animator->display_id());
+}
+
 // Protected
 
 void DisplayConfigurationController::ResetAnimatorForTest() {
   if (!display_animator_)
     return;
   display_animator_.reset();
 }
 
 // Private
 
@@ skipping 19 matching lines @@
     display_animator_->StartFadeInAnimation();
 }
 
 void DisplayConfigurationController::SetPrimaryDisplayIdImpl(
     int64_t display_id) {
   window_tree_host_manager_->SetPrimaryDisplayId(display_id);
   if (display_animator_)
     display_animator_->StartFadeInAnimation();
 }
 
+ScreenRotationAnimator*
+DisplayConfigurationController::GetScreenRotationAnimatorForDisplay(
+    int64_t display_id) {
+  auto iter = rotation_animator_map_.find(display_id);
+  if (iter != rotation_animator_map_.end())
+    return iter->second.get();
+
+  auto animator = base::MakeUnique<ScreenRotationAnimator>(display_id);
+  animator->AddScreenRotationAnimatorObserver(this);
+  ScreenRotationAnimator* result = animator.get();
+  rotation_animator_map_.insert(
+      std::make_pair(display_id, std::move(animator)));
+  return result;
+}
+
 }  // namespace ash