Add a NOT_DRAWN window in between the root_window and its children.

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 <string>
 #include <utility>
 #include <vector>
 
@@ skipping 31 matching lines @@
 // 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;
 
-// Aborts the active animations of the layer, and recurses upon its child
-// layers.
-void AbortAnimations(ui::Layer* layer) {
-  for (ui::Layer* child_layer : layer->children())
-    AbortAnimations(child_layer);
-  layer->GetAnimator()->AbortAllAnimations();
-}
+// The delegate root layer name.
+const std::string kDelegateRootLayerName = "DelegateRootLayer";
 
 display::Display::Rotation GetCurrentScreenRotation(int64_t display_id) {
   return Shell::GetInstance()
       ->display_manager()
       ->GetDisplayInfo(display_id)
       .GetActiveRotation();
 }
 
 bool IsDisplayIdValid(int64_t display_id) {
   return Shell::GetInstance()->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::GetInstance()
       ->window_tree_host_manager()
       ->GetRootWindowForDisplayId(display_id);
 }
 
+ui::Layer* GetChildLayerByName(ui::Layer* parent, const std::string& name) {
+  for (ui::Layer* child_layer : parent->children()) {
+    if (child_layer->name() == name)
+      return child_layer;
+  }
+  NOTREACHED();
+  return nullptr;
+}
+
 // Returns true if the rotation between |initial_rotation| and |new_rotation| is
 // 180 degrees.
 bool Is180DegreeFlip(display::Display::Rotation initial_rotation,
                      display::Display::Rotation new_rotation) {
   return (initial_rotation + 2) % 4 == new_rotation;
 }
 
 // Returns the initial degrees the old layer animation to begin with.
 int GetInitialDegrees(display::Display::Rotation initial_rotation,
                       display::Display::Rotation new_rotation) {
@@ skipping 147 matching lines @@
   std::unique_ptr<LayerCleanupObserver> old_layer_cleanup_observer(
       new LayerCleanupObserver(weak_factory_.GetWeakPtr()));
 
   Shell::GetInstance()->display_manager()->SetDisplayRotation(
       display_id_, rotation_request->new_rotation, rotation_request->source);
 
   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* delegate_root_layer =
+      GetChildLayerByName(root_window->layer(), kDelegateRootLayerName);

[oshima, 2017/04/05 20:26:51]

can't you just find the window by id and get layer?

[wutao, 2017/04/05 23:37:34]

Done.

+  std::unique_ptr<ScreenRotationAnimation> current_layer_screen_rotation =
+      base::MakeUnique<ScreenRotationAnimation>(
+          delegate_root_layer, kRotationDegrees * rotation_factor,
+          0 /* end_degrees */, 0.0f,
+          delegate_root_layer->opacity() /* target_opacity */, pivot, duration,
+          tween_type);
+
+  ui::LayerAnimator* current_layer_animator =
+      delegate_root_layer->GetAnimator();
+  current_layer_animator->set_preemption_strategy(
+      ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
+  std::unique_ptr<ui::LayerAnimationSequence> current_layer_animation_sequence =
+      base::MakeUnique<ui::LayerAnimationSequence>(
+          std::move(current_layer_screen_rotation));
+  current_layer_animator->StartAnimation(
+      current_layer_animation_sequence.release());
+
   ui::Layer* old_root_layer = old_layer_tree_owner_->root();
-  // We must animate each non-cloned child layer individually because the cloned
-  // layer was added as a child to |root_window|'s layer so that it will be
-  // rendered.
-  // TODO(bruthig): Add a NOT_DRAWN layer in between the root_window's layer and
-  // its current children so that we only need to initiate two
-  // LayerAnimationSequences. One for the new layers and one for the old layer.
-  for (ui::Layer* child_layer : root_window->layer()->children()) {
-    // Skip the cloned layer because it has a different animation.
-    if (child_layer == old_root_layer)
-      continue;
-
-    std::unique_ptr<ScreenRotationAnimation> screen_rotation =
-        base::MakeUnique<ScreenRotationAnimation>(
-            child_layer, kRotationDegrees * rotation_factor,
-            0 /* end_degrees */, child_layer->opacity(),
-            1.0f /* target_opacity */, pivot, duration, tween_type);
-
-    ui::LayerAnimator* animator = child_layer->GetAnimator();
-    animator->set_preemption_strategy(
-        ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
-    std::unique_ptr<ui::LayerAnimationSequence> animation_sequence =
-        base::MakeUnique<ui::LayerAnimationSequence>(
-            std::move(screen_rotation));
-    animator->StartAnimation(animation_sequence.release());
-  }
-
   // The old layer will also be transformed into the new orientation. We will
   // translate it so that the old layer's center point aligns with the new
   // orientation's center point and use that center point as the pivot for the
   // rotation animation.
   gfx::Transform translate_transform;
   translate_transform.Translate(
       (rotated_screen_bounds.width() - original_screen_bounds.width()) / 2,
       (rotated_screen_bounds.height() - original_screen_bounds.height()) / 2);
   old_root_layer->SetTransform(translate_transform);
 
-  std::unique_ptr<ScreenRotationAnimation> screen_rotation =
+  std::unique_ptr<ScreenRotationAnimation> old_layer_screen_rotation =
       base::MakeUnique<ScreenRotationAnimation>(
           old_root_layer, old_layer_initial_rotation_degrees * rotation_factor,
           (old_layer_initial_rotation_degrees - kRotationDegrees) *
               rotation_factor,
           old_root_layer->opacity(), 0.0f /* target_opacity */, pivot, duration,
           tween_type);
 
-  ui::LayerAnimator* animator = old_root_layer->GetAnimator();
-  animator->set_preemption_strategy(
+  ui::LayerAnimator* old_layer_animator = old_root_layer->GetAnimator();
+  old_layer_animator->set_preemption_strategy(
       ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
-  std::unique_ptr<ui::LayerAnimationSequence> animation_sequence =
-      base::MakeUnique<ui::LayerAnimationSequence>(std::move(screen_rotation));
+  std::unique_ptr<ui::LayerAnimationSequence> old_layer_animation_sequence =
+      base::MakeUnique<ui::LayerAnimationSequence>(
+          std::move(old_layer_screen_rotation));
   // Add an observer so that the cloned layers can be cleaned up with the
   // animation completes/aborts.
-  animation_sequence->AddObserver(old_layer_cleanup_observer.release());
+  old_layer_animation_sequence->AddObserver(
+      old_layer_cleanup_observer.release());
   // In unit test, we can use ash::test::ScreenRotationAnimatorTestApi to
   // control the animation.
   if (disable_animation_timers_for_test_)
-    animator->set_disable_timer_for_test(true);
-  animation_sequence->SetAnimationMetricsReporter(metrics_reporter_.get());
-  animator->StartAnimation(animation_sequence.release());
+    old_layer_animator->set_disable_timer_for_test(true);
+  old_layer_animation_sequence->SetAnimationMetricsReporter(
+      metrics_reporter_.get());
+  old_layer_animator->StartAnimation(old_layer_animation_sequence.release());
 
   rotation_request.reset();
 }
 
 void ScreenRotationAnimator::Rotate(display::Display::Rotation new_rotation,
                                     display::Display::RotationSource source) {
   if (GetCurrentScreenRotation(display_id_) == new_rotation)
     return;
 
   std::unique_ptr<ScreenRotationRequest> rotation_request =
@@ skipping 35 matching lines @@
   for (auto& observer : screen_rotation_animator_observers_)
     observer.OnScreenRotationAnimationFinished(this);
 }
 
 void ScreenRotationAnimator::set_disable_animation_timers_for_test(
     bool disable_timers) {
   disable_animation_timers_for_test_ = disable_timers;
 }
 
 void ScreenRotationAnimator::StopAnimating() {
-  aura::Window* root_window = GetRootWindow(display_id_);
-  for (ui::Layer* child_layer : root_window->layer()->children()) {
-    if (child_layer == old_layer_tree_owner_->root())
-      continue;
-
-    child_layer->GetAnimator()->StopAnimating();
-  }
-
+  GetChildLayerByName(GetRootWindow(display_id_)->layer(),
+                      kDelegateRootLayerName)
+      ->GetAnimator()
+      ->StopAnimating();
   old_layer_tree_owner_->root()->GetAnimator()->StopAnimating();
 }
 
 }  // namespace ash