Uses copy request to flatten the layers to do screen rotation animation.

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>
 
+#include "ash/common/ash_switches.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/rotator/screen_rotation_animation.h"
 #include "ash/rotator/screen_rotation_animator_observer.h"
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/time/time.h"
+#include "cc/output/copy_output_request.h"
+#include "cc/output/copy_output_result.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_element.h"
 #include "ui/compositor/layer_animation_observer.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"
@@ skipping 177 matching lines @@
   // 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) {
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kAshEnableSmoothScreenRotationAnimation)) {
+    RequestCopyRootLayerAndAnimateRotation(std::move(rotation_request));
+  } else {
+    CreateOldLayerTree();
+    AnimateRotation(std::move(rotation_request));
+  }
+}
+
+void ScreenRotationAnimator::RequestCopyRootLayerAndAnimateRotation(
+    std::unique_ptr<ScreenRotationRequest> rotation_request) {
+  std::unique_ptr<cc::CopyOutputRequest> copy_output_request =
+      cc::CopyOutputRequest::CreateRequest(base::Bind(
+          &ScreenRotationAnimator::OnRootLayerCopiedBeforeRotation,
+          weak_factory_.GetWeakPtr(), base::Passed(&rotation_request)));

[oshima, 2017/03/31 00:14:34]

do we still need to use ::Passed? Didn't std::move work?

[wutao, 2017/04/03 16:16:03]

Cannot, it prompts: 'unique_ptr' has been explicitly marked deleted here.

[danakj, 2017/04/03 16:25:04]

Passed() changes behaviour of how the variable is passed when the callback is
run. move() would only change how it's passed/stored inside the callback.
Passed(std::move(t)) or Passed(&t) are equivalent though and both work.

+  ui::Layer* layer = GetRootWindow(display_id_)->layer();
+  layer->RequestCopyOfOutput(std::move(copy_output_request));
+}
+
+void ScreenRotationAnimator::OnRootLayerCopiedBeforeRotation(
+    std::unique_ptr<ScreenRotationRequest> rotation_request,
+    std::unique_ptr<cc::CopyOutputResult> result) {
+  // If copy request does not succeeded, fall back to recreate layers solution.

[oshima, 2017/03/31 00:14:34]

can you mention when and how it can fail?

[wutao, 2017/04/03 16:16:04]

One situation is that the user cancel the request. I will ask Dana to add more
cases it will fail.

[danakj, 2017/04/03 16:23:30]

It would fail if, for example..
- The layer is removed from the compositor and destroyed before committing the
request to the compositor.
- The compositor is shutdown.

Anything that would destroy the copy request prematurely in this way.

+  if (result->IsEmpty() || result->size().IsEmpty() || !result->HasTexture())
+    CreateOldLayerTree();
+  else
+    CopyOldLayerTree(std::move(result));
+  AnimateRotation(std::move(rotation_request));
+}
+
+void ScreenRotationAnimator::CreateOldLayerTree() {
+  old_layer_tree_owner_ = ::wm::RecreateLayers(GetRootWindow(display_id_));
+}
+
+void ScreenRotationAnimator::CopyOldLayerTree(
+    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());
+
+  aura::Window* root_window = GetRootWindow(display_id_);
+  gfx::Rect rect(0, 0, root_window->layer()->size().width(),
+                 root_window->layer()->size().height());

[oshima, 2017/03/31 00:14:34]

gfx::Rect rect(..->size());

[wutao, 2017/04/03 16:16:04]

Done.

+  std::unique_ptr<ui::Layer> copy_layer = base::MakeUnique<ui::Layer>();
+  copy_layer->SetBounds(rect);

[oshima, 2017/03/31 00:14:34]

what happens if
a) the display bounds changed during animation
b) the display gets removed during animation (can happen when switching to
docked mode)

[wutao, 2017/04/03 16:16:04]

a) The display bounds changed during animation will not affect here, because the
animation starts after this command. But it may be reliable to pass a rect to
the callback?
b) If we remove the display, we should not continue to rotate. We can clean up
the |animator| and notify the displayConfigurationController.

[oshima, 2017/04/03 16:36:11]

My concerns are:

1) it shouldn't crash or leave chrome in bad state.
2) it shouldn't look corrupted.

I think it's better to simply abort animation and move to the target rotation
for both cases.

[wutao, 2017/04/03 17:53:38]

I archive your comments and add TODO. We can add code in
DisplayConfigurationController to get notifications when a) and b) happens, and
abort the animation to the target rotation when any of the bounds changes or
display removed.

+  copy_layer->SetTextureMailbox(texture_mailbox, std::move(release_callback),
+                                rect.size());
+  old_layer_tree_owner_ =
+      base::MakeUnique<ui::LayerTreeOwner>(std::move(copy_layer));
+}
+
 void ScreenRotationAnimator::AnimateRotation(
     std::unique_ptr<ScreenRotationRequest> rotation_request) {
   aura::Window* root_window = GetRootWindow(display_id_);
+  std::unique_ptr<LayerCleanupObserver> old_layer_cleanup_observer(
+      new LayerCleanupObserver(weak_factory_.GetWeakPtr()));
+  ui::Layer* old_root_layer = old_layer_tree_owner_->root();
+  old_root_layer->set_name("ScreenRotationAnimator:old_layer_tree");
+  // Add the cloned layer tree in to the root, so it will be rendered.
+  root_window->layer()->Add(old_root_layer);
+  root_window->layer()->StackAtTop(old_root_layer);
 
   const gfx::Rect original_screen_bounds = root_window->GetTargetBounds();
 
   const int rotation_factor = GetRotationFactor(
       GetCurrentScreenRotation(display_id_), rotation_request->new_rotation);
 
   const int old_layer_initial_rotation_degrees = GetInitialDegrees(
       GetCurrentScreenRotation(display_id_), rotation_request->new_rotation);
 
   const base::TimeDelta duration =
       base::TimeDelta::FromMilliseconds(kRotationDurationInMs);
 
   const gfx::Tween::Type tween_type = gfx::Tween::FAST_OUT_LINEAR_IN;
 
-  std::unique_ptr<ui::LayerTreeOwner> old_layer_tree =
-      ::wm::RecreateLayers(root_window);
-  old_layer_tree->root()->set_name("ScreenRotationAnimator:old_layer_tree");
-
-  // Add the cloned layer tree in to the root, so it will be rendered.
-  root_window->layer()->Add(old_layer_tree->root());
-  root_window->layer()->StackAtTop(old_layer_tree->root());
-
-  old_layer_tree_owner_ = std::move(old_layer_tree);
-  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* 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;
@@ skipping 58 matching lines @@
       base::MakeUnique<ScreenRotationRequest>(new_rotation, source);
 
   if (is_rotating_) {
     last_pending_request_ = std::move(rotation_request);
     // The pending request will be processed when the
     // OnLayerAnimation(Ended|Aborted) methods should be called after
     // StopAnimating().
     StopAnimating();
   } else {
     is_rotating_ = true;
-    AnimateRotation(std::move(rotation_request));
+    StartRotationAnimation(std::move(rotation_request));
   }
 }
 
 void ScreenRotationAnimator::AddScreenRotationAnimatorObserver(
     ScreenRotationAnimatorObserver* observer) {
   screen_rotation_animator_observers_.AddObserver(observer);
 }
 
 void ScreenRotationAnimator::RemoveScreenRotationAnimatorObserver(
     ScreenRotationAnimatorObserver* observer) {
@@ skipping 26 matching lines @@
     if (child_layer == old_layer_tree_owner_->root())
       continue;
 
     child_layer->GetAnimator()->StopAnimating();
   }
 
   old_layer_tree_owner_->root()->GetAnimator()->StopAnimating();
 }
 
 }  // namespace ash