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 87 matching lines @@
 }
 
 void AddLayerBelowWindowLayer(aura::Window* root_window,
                               ui::Layer* top_layer,
                               ui::Layer* layer) {
   // Add the cloned/copied layer tree into the root, so it will be rendered.
   root_window->layer()->Add(layer);
   root_window->layer()->StackBelow(layer, top_layer);
 }
 
+void RemoveLayerFromRootWindowForDisplayId(int64_t display_id,
+                                           ui::Layer* layer) {
+  if (IsDisplayIdValid(display_id)) {
+    ui::Layer* root_layer = GetRootWindow(display_id)->layer();
+    if (root_layer->Contains(layer))
+      root_layer->Remove(layer);
+  }
+}
+
 // The Callback will be invoked when all animation sequences have
 // finished. |observer| will be destroyed after invoking the Callback if it
 // returns true.
 bool AnimationEndedCallback(
     base::WeakPtr<ScreenRotationAnimator> animator,
     const ui::CallbackLayerAnimationObserver& observer) {
   if (animator)
     animator->ProcessAnimationQueue();
   return true;
 }
@@ skipping 48 matching lines @@
 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_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.
@@ skipping 32 matching lines @@
   AnimateRotation(std::move(rotation_request));
 }
 
 void ScreenRotationAnimator::SetRotation(
     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();
+  ui::Compositor* compositor =
+      GetRootWindow(display_id_)->layer()->GetCompositor();
   compositor->set_allow_locks_to_extend_timeout(true);
   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_);
   old_layer_tree_owner_->root()->SetTransform(
       CreateScreenRotationOldLayerTransformForDisplay(old_rotation,
                                                       new_rotation, display));
 }
 
 void ScreenRotationAnimator::RequestCopyScreenRotationContainerLayer(
     std::unique_ptr<cc::CopyOutputRequest> copy_output_request) {
+  ui::Layer* screen_rotation_container_layer =
+      GetScreenRotationContainer(GetRootWindow(display_id_))->layer();
   copy_output_request->set_area(
-      gfx::Rect(screen_rotation_container_layer_->size()));
-  screen_rotation_container_layer_->RequestCopyOfOutput(
+      gfx::Rect(screen_rotation_container_layer->size()));
+  screen_rotation_container_layer->RequestCopyOfOutput(
       std::move(copy_output_request));
 }
 
 ScreenRotationAnimator::CopyCallback
 ScreenRotationAnimator::CreateAfterCopyCallbackBeforeRotation(
     std::unique_ptr<ScreenRotationRequest> rotation_request) {
   return base::Bind(&ScreenRotationAnimator::
                         OnScreenRotationContainerLayerCopiedBeforeRotation,
                     weak_factory_.GetWeakPtr(),
                     base::Passed(&rotation_request));
@@ skipping 23 matching lines @@
   // 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());
+  AddLayerAtTopOfWindowLayers(GetRootWindow(display_id_),
+                              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;
   // 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;
   }
 
+  aura::Window* root_window = GetRootWindow(display_id_);
+  // |root_window| changed while waiting for the copy request.
+  if (!root_window->layer()->Contains(old_layer_tree_owner_->root())) {

[oshima, 2017/05/31 22:37:57]

Hmm, I probably made a bad recommendation. I'm very sorry about that.

It's probably better to create a rotator for root window (then you don't have to
worry about these condition, or invalid display in this class).

In GetScreenRotationAnimatorForDisplay, you can find the root window, and then
create the animator for the root window.

+    ProcessAnimationQueue();
+    return;
+  }
+
   new_layer_tree_owner_ = CopyLayerTree(std::move(result));
-  AddLayerBelowWindowLayer(root_window_, old_layer_tree_owner_->root(),
+  AddLayerBelowWindowLayer(root_window, old_layer_tree_owner_->root(),
                            new_layer_tree_owner_->root());
   AnimateRotation(std::move(rotation_request));
 }
 
 void ScreenRotationAnimator::CreateOldLayerTreeForSlowAnimation() {
-  old_layer_tree_owner_ = ::wm::RecreateLayers(root_window_);
-  // |screen_rotation_container_layer_| needs update after |RecreateLayers()|.
-  screen_rotation_container_layer_ =
-      GetScreenRotationContainer(root_window_)->layer();
-  AddLayerAtTopOfWindowLayers(root_window_, old_layer_tree_owner_->root());
+  aura::Window* root_window = GetRootWindow(display_id_);
+  old_layer_tree_owner_ = ::wm::RecreateLayers(root_window);
+  AddLayerAtTopOfWindowLayers(root_window, old_layer_tree_owner_->root());
 }
 
 std::unique_ptr<ui::LayerTreeOwner> ScreenRotationAnimator::CopyLayerTree(
     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());
-
-  const gfx::Rect rect(screen_rotation_container_layer_->size());
+  const gfx::Rect rect(
+      GetScreenRotationContainer(GetRootWindow(display_id_))->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());
   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_);
+  ui::Layer* screen_rotation_container_layer =
+      GetScreenRotationContainer(root_window)->layer();
+
   screen_rotation_state_ = ROTATING;
   const int rotation_factor = GetRotationFactor(rotation_request->old_rotation,
                                                 rotation_request->new_rotation);
   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::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_disable_smooth_screen_rotation_) {
-    new_root_layer = screen_rotation_container_layer_;
+    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_|.
+    // 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,
+        gfx::Rect(screen_rotation_container_layer->size()));
+    AddLayerBelowWindowLayer(root_window, new_root_layer,
                              black_mask_layer_owner_->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);
 
@@ skipping 84 matching lines @@
   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());
+  if (black_mask_layer_owner_) {
+    RemoveLayerFromRootWindowForDisplayId(display_id_,
+                                          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_)) {
     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());
+  if (black_mask_layer_owner_) {
+    RemoveLayerFromRootWindowForDisplayId(display_id_,
+                                          black_mask_layer_owner_->layer());
+  }
 }
 
 }  // namespace ash