Flip the flag to enable smooth screen rotation by default.

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"
@@ skipping 116 matching lines @@
   return inverse;
 }
 
 // The |request_id| changed since last copy request, which means a
 // new rotation stated, we need to ignore this copy result.
 bool IgnoreCopyResult(int64_t request_id, int64_t current_request_id) {
   DCHECK(request_id <= current_request_id);
   return request_id < current_request_id;
 }
 
-// In the following cases, abort rotation:
-// 1) if the display was removed,
-// 2) the copy request has been canceled or failed. It would fail if,
-// for examples: a) The layer is removed from the compositor and destroye
-// before committing the request to the compositor. b) The compositor is
-// shutdown.
-bool AbortRotation(int64_t display_id, cc::CopyOutputResult* result) {
-  return !IsDisplayIdValid(display_id) || result->IsEmpty();
-}
-
 // Creates a black mask layer and returns the |layer_owner|.
 std::unique_ptr<ui::LayerOwner> CreateBlackMaskLayerOwner(
     const gfx::Rect& rect) {
   std::unique_ptr<ui::Layer> black_mask_layer =
       base::MakeUnique<ui::Layer>(ui::LAYER_SOLID_COLOR);
   black_mask_layer->SetBounds(rect);
   black_mask_layer->SetColor(SK_ColorBLACK);
   std::unique_ptr<ui::LayerOwner> black_mask_layer_owner =
       base::MakeUnique<ui::LayerOwner>();
   black_mask_layer_owner->SetLayer(std::move(black_mask_layer));
@@ skipping 16 matching lines @@
 
 }  // namespace
 
 ScreenRotationAnimator::ScreenRotationAnimator(int64_t display_id)
     : display_id_(display_id),
       screen_rotation_state_(IDLE),
       rotation_request_id_(0),
       metrics_reporter_(
           base::MakeUnique<ScreenRotationAnimationMetricsReporter>()),
       disable_animation_timers_for_test_(false),
-      has_switch_ash_enable_smooth_screen_rotation_(
+      has_switch_ash_disable_smooth_screen_rotation_(
           base::CommandLine::ForCurrentProcess()->HasSwitch(
-              switches::kAshEnableSmoothScreenRotation)),
+              switches::kAshDisableSmoothScreenRotation)),
       root_window_(GetRootWindow(display_id_)),
       screen_rotation_container_layer_(
           GetScreenRotationContainer(root_window_)->layer()),
       weak_factory_(this) {}
 
 ScreenRotationAnimator::~ScreenRotationAnimator() {
   // 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;
   }
 
   rotation_request->old_rotation = current_rotation;
-  if (has_switch_ash_enable_smooth_screen_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;
-  } else {
-    StartSlowAnimation(std::move(rotation_request));
   }
 }
 
 void ScreenRotationAnimator::StartSlowAnimation(
     std::unique_ptr<ScreenRotationRequest> rotation_request) {
   CreateOldLayerTreeForSlowAnimation();
   SetRotation(rotation_request->old_rotation, rotation_request->new_rotation,
               rotation_request->source);
   AnimateRotation(std::move(rotation_request));
 }
@@ skipping 35 matching lines @@
                         OnScreenRotationContainerLayerCopiedAfterRotation,
                     weak_factory_.GetWeakPtr(),
                     base::Passed(&rotation_request));
 }
 
 void ScreenRotationAnimator::OnScreenRotationContainerLayerCopiedBeforeRotation(
     std::unique_ptr<ScreenRotationRequest> rotation_request,
     std::unique_ptr<cc::CopyOutputResult> result) {
   if (IgnoreCopyResult(rotation_request->id, rotation_request_id_))
     return;
-  if (AbortRotation(display_id_, result.get())) {
+  // Abort rotation and animation if the display was removed.
+  if (!IsDisplayIdValid(display_id_)) {
     ProcessAnimationQueue();
     return;
   }
+  // Abort animation and set the rotation to target rotation when the copy
+  // request has been canceled or failed. It would fail if, for examples: a) The
+  // layer is removed from the compositor and destroye before committing the
+  // request to the compositor. b) The compositor is shutdown.
+  if (result->IsEmpty()) {
+    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));
 }
 
 void ScreenRotationAnimator::OnScreenRotationContainerLayerCopiedAfterRotation(
     std::unique_ptr<ScreenRotationRequest> rotation_request,
     std::unique_ptr<cc::CopyOutputResult> result) {
   if (IgnoreCopyResult(rotation_request->id, rotation_request_id_))
     return;
-  if (AbortRotation(display_id_, result.get())) {
+  // 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,
+  // for examples: a) The layer is removed from the compositor and destroye
+  // before committing the request to the compositor. b) The compositor is
+  // shutdown.
+  if (!IsDisplayIdValid(display_id_) || result->IsEmpty()) {
     ProcessAnimationQueue();
     return;
   }
 
   new_layer_tree_owner_ = CopyLayerTree(std::move(result));
   AddLayerBelowWindowLayer(root_window_, old_layer_tree_owner_->root(),
                            new_layer_tree_owner_->root());
   AnimateRotation(std::move(rotation_request));
 }
 
@@ skipping 28 matching lines @@
   const int old_layer_initial_rotation_degrees = GetInitialDegrees(
       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;
   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* new_root_layer;
-  if (new_layer_tree_owner_ && has_switch_ash_enable_smooth_screen_rotation_) {
+  if (!new_layer_tree_owner_ ||
+      has_switch_ash_disable_smooth_screen_rotation_) {
+    new_root_layer = screen_rotation_container_layer_;
+  } else {
     new_root_layer = new_layer_tree_owner_->root();
     // Add a black mask layer on top of |screen_rotation_container_layer_|.
     black_mask_layer_owner_ = CreateBlackMaskLayerOwner(
         gfx::Rect(screen_rotation_container_layer_->size()));
     AddLayerBelowWindowLayer(root_window_, new_root_layer,
                              black_mask_layer_owner_->layer());
-  } else {
-    new_root_layer = screen_rotation_container_layer_;
   }
 
   std::unique_ptr<ScreenRotationAnimation> new_layer_screen_rotation =
       base::MakeUnique<ScreenRotationAnimation>(
           new_root_layer, kRotationDegrees * rotation_factor,
           0 /* end_degrees */, new_root_layer->opacity(),
           new_root_layer->opacity() /* target_opacity */, pivot, duration,
           tween_type);
 
   ui::LayerAnimator* new_layer_animator = new_root_layer->GetAnimator();
@@ skipping 110 matching lines @@
   // 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());
 }
 
 }  // namespace ash