[merge to m60] cros: Do not cache |root_window| in ScreenRotationAnimator.

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 10 matching lines @@
 #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/display/screen.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;
 
 // 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;
 
 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);
-}
-
 // 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::Get()->window_tree_host_manager()->GetRootWindowForDisplayId(
@@ skipping 53 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;
 }
 
-// Creates a black mask layer and returns the |layer_owner|.
-std::unique_ptr<ui::LayerOwner> CreateBlackMaskLayerOwner(
+bool RootWindowChangedForDisplayId(aura::Window* root_window,
+                                   int64_t display_id) {
+  return root_window != GetRootWindow(display_id);
+}
+
+// Creates a mask layer and returns the |mask_layer_tree_owner|.
+std::unique_ptr<ui::LayerTreeOwner> CreateMaskLayerTreeOwner(
     const gfx::Rect& rect) {
-  std::unique_ptr<ui::Layer> black_mask_layer =
+  std::unique_ptr<ui::Layer> 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));
-  return black_mask_layer_owner;
+  mask_layer->SetBounds(rect);
+  mask_layer->SetColor(SK_ColorBLACK);
+  return base::MakeUnique<ui::LayerTreeOwner>(std::move(mask_layer));
 }
 
 class ScreenRotationAnimationMetricsReporter
     : public ui::AnimationMetricsReporter {
  public:
   ScreenRotationAnimationMetricsReporter() = default;
   ~ScreenRotationAnimationMetricsReporter() override = default;
 
   void Report(int value) override {
     UMA_HISTOGRAM_PERCENTAGE("Ash.Rotation.AnimationSmoothness", value);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ScreenRotationAnimationMetricsReporter);
 };
 
 }  // namespace
 
-ScreenRotationAnimator::ScreenRotationAnimator(int64_t display_id)
-    : display_id_(display_id),
+ScreenRotationAnimator::ScreenRotationAnimator(aura::Window* root_window)
+    : root_window_(root_window),
+      screen_rotation_container_layer_(
+          GetScreenRotationContainer(root_window_)->layer()),
       screen_rotation_state_(IDLE),
       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) {}
 
 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_);
+      GetCurrentScreenRotation(rotation_request->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_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;
   }
 }
 
 void ScreenRotationAnimator::StartSlowAnimation(
     std::unique_ptr<ScreenRotationRequest> rotation_request) {
   CreateOldLayerTreeForSlowAnimation();
-  SetRotation(rotation_request->old_rotation, rotation_request->new_rotation,
-              rotation_request->source);
+  SetRotation(rotation_request->display_id, rotation_request->old_rotation,
+              rotation_request->new_rotation, rotation_request->source);
   AnimateRotation(std::move(rotation_request));
 }
 
 void ScreenRotationAnimator::SetRotation(
+    int64_t display_id,
     display::Display::Rotation old_rotation,
     display::Display::Rotation new_rotation,
     display::Display::RotationSource source) {
   // Allow compositor locks to extend timeout, so that screen rotation only
   // takes output copy after contents are properlly resized, such as wallpaper
   // and ARC apps.
   ui::Compositor* compositor = root_window_->layer()->GetCompositor();
   compositor->set_allow_locks_to_extend_timeout(true);
-  Shell::Get()->display_manager()->SetDisplayRotation(display_id_, new_rotation,
+  Shell::Get()->display_manager()->SetDisplayRotation(display_id, new_rotation,
                                                       source);
   compositor->set_allow_locks_to_extend_timeout(false);
   const display::Display display =
-      Shell::Get()->display_manager()->GetDisplayForId(display_id_);
+      Shell::Get()->display_manager()->GetDisplayForId(display_id);
   old_layer_tree_owner_->root()->SetTransform(
       CreateScreenRotationOldLayerTransformForDisplay(old_rotation,
                                                       new_rotation, display));
 }
 
 void ScreenRotationAnimator::RequestCopyScreenRotationContainerLayer(
     std::unique_ptr<cc::CopyOutputRequest> copy_output_request) {
   copy_output_request->set_area(
       gfx::Rect(screen_rotation_container_layer_->size()));
   screen_rotation_container_layer_->RequestCopyOfOutput(
@@ skipping 16 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;
-  // Abort rotation and animation if the display was removed.
-  if (!IsDisplayIdValid(display_id_)) {
+  // Abort rotation and animation if the display was removed or the
+  // |root_window| was changed for |display_id|.
+  if (RootWindowChangedForDisplayId(root_window_,
+                                    rotation_request->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);
+        rotation_request->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);
+  SetRotation(rotation_request->display_id, 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;
   // 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,
+  // 2) if the |root_window| was changed for |display_id|,
+  // 3) 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()) {
+  if (RootWindowChangedForDisplayId(root_window_,
+                                    rotation_request->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 34 matching lines @@
   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_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(
+    mask_layer_tree_owner_ = CreateMaskLayerTreeOwner(
         gfx::Rect(screen_rotation_container_layer_->size()));
     AddLayerBelowWindowLayer(root_window_, new_root_layer,
-                             black_mask_layer_owner_->layer());
+                             mask_layer_tree_owner_->root());
   }
 
   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 54 matching lines @@
 }
 
 void ScreenRotationAnimator::Rotate(display::Display::Rotation new_rotation,
                                     display::Display::RotationSource source) {
   // |rotation_request_id_| is used to skip stale requests. Before the layer
   // CopyOutputResult callback called, there could have new rotation request.
   // Increases |rotation_request_id_| for each new request and in the callback,
   // we compare the |rotation_request.id| and |rotation_request_id_| to
   // determine the stale status.
   rotation_request_id_++;
+  const int64_t display_id =
+      display::Screen::GetScreen()->GetDisplayNearestWindow(root_window_).id();
   std::unique_ptr<ScreenRotationRequest> rotation_request =
-      base::MakeUnique<ScreenRotationRequest>(rotation_request_id_,
+      base::MakeUnique<ScreenRotationRequest>(rotation_request_id_, display_id,
                                               new_rotation, source);
   switch (screen_rotation_state_) {
     case IDLE:
     case COPY_REQUESTED:
       StartRotationAnimation(std::move(rotation_request));
       break;
     case ROTATING:
       last_pending_request_ = std::move(rotation_request);
       // The pending request will be processed when the
       // |AnimationEndedCallback()| should be called after |StopAnimating()|.
       StopAnimating();
       break;
   }
 }
 
 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() {
   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();
-  if (last_pending_request_ && IsDisplayIdValid(display_id_)) {
+  mask_layer_tree_owner_.reset();
+  if (last_pending_request_ &&
+      !RootWindowChangedForDisplayId(root_window_,
+                                     last_pending_request_->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());
+  mask_layer_tree_owner_.reset();
 }
 
 }  // namespace ash