Add second copy request after screen rotation to flatten the layers in animation.

ash/display/root_window_transformers.cc

 // Copyright (c) 2013 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/display/root_window_transformers.h"
 
 #include <cmath>
 
 #include "ash/common/ash_switches.h"
 #include "ash/host/root_window_transformer.h"
 #include "ash/magnifier/magnification_controller.h"
 #include "ash/shell.h"
+#include "ash/utility/transformer_util.h"
 #include "base/command_line.h"
 #include "third_party/skia/include/core/SkMatrix44.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/class_property.h"
 #include "ui/compositor/dip_util.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/geometry/insets.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/transform.h"
-#include "ui/gfx/transform.h"
-
-DECLARE_UI_CLASS_PROPERTY_TYPE(display::Display::Rotation);
 
 namespace ash {
 namespace {
 
-#if defined(OS_WIN)
-DEFINE_UI_CLASS_PROPERTY_KEY(display::Display::Rotation,
-                             kRotationPropertyKey,
-                             display::Display::ROTATE_0);
-#endif
-
-// Round near zero value to zero.
-void RoundNearZero(gfx::Transform* transform) {
-  const float kEpsilon = 0.001f;
-  SkMatrix44& matrix = transform->matrix();
-  for (int x = 0; x < 4; ++x) {
-    for (int y = 0; y < 4; ++y) {
-      if (std::abs(SkMScalarToFloat(matrix.get(x, y))) < kEpsilon)
-        matrix.set(x, y, SkFloatToMScalar(0.0f));
-    }
-  }
-}
-
-// TODO(oshima): Transformers should be able to adjust itself
-// when the device scale factor is changed, instead of
-// precalculating the transform using fixed value.
-
-gfx::Transform CreateRotationTransform(aura::Window* root_window,
-                                       const display::Display& display) {
-  display::ManagedDisplayInfo info =
-      Shell::Get()->display_manager()->GetDisplayInfo(display.id());
-
-// TODO(oshima): Add animation. (crossfade+rotation, or just cross-fade)
-#if defined(OS_WIN)
-  // Windows 8 bots refused to resize the host window, and
-  // updating the transform results in incorrectly resizing
-  // the root window. Don't apply the transform unless
-  // necessary so that unit tests pass on win8 bots.
-  if (info.GetActiveRotation() ==
-      root_window->GetProperty(kRotationPropertyKey)) {
-    return gfx::Transform();
-  }
-  root_window->SetProperty(kRotationPropertyKey, info.GetActiveRotation());
-#endif
-
-  gfx::Transform rotate;
-  // The origin is (0, 0), so the translate width/height must be reduced by
-  // 1 pixel.
-  float one_pixel = 1.0f / display.device_scale_factor();
-  switch (info.GetActiveRotation()) {
-    case display::Display::ROTATE_0:
-      break;
-    case display::Display::ROTATE_90:
-      rotate.Translate(display.bounds().height() - one_pixel, 0);
-      rotate.Rotate(90);
-      break;
-    case display::Display::ROTATE_270:
-      rotate.Translate(0, display.bounds().width() - one_pixel);
-      rotate.Rotate(270);
-      break;
-    case display::Display::ROTATE_180:
-      rotate.Translate(display.bounds().width() - one_pixel,
-                       display.bounds().height() - one_pixel);
-      rotate.Rotate(180);
-      break;
-  }
-
-  RoundNearZero(&rotate);
-  return rotate;
-}
-
-gfx::Transform CreateMagnifierTransform(aura::Window* root_window) {
-  MagnificationController* magnifier = Shell::Get()->magnification_controller();
-  float magnifier_scale = 1.f;
-  gfx::Point magnifier_offset;
-  if (magnifier && magnifier->IsEnabled()) {
-    magnifier_scale = magnifier->GetScale();
-    magnifier_offset = magnifier->GetWindowPosition();
-  }
-  gfx::Transform transform;
-  if (magnifier_scale != 1.f) {
-    transform.Scale(magnifier_scale, magnifier_scale);
-    transform.Translate(-magnifier_offset.x(), -magnifier_offset.y());
-  }
-  return transform;
-}
-
-gfx::Transform CreateInsetsAndScaleTransform(const gfx::Insets& insets,
-                                             float device_scale_factor,
-                                             float ui_scale) {
-  gfx::Transform transform;
-  if (insets.top() != 0 || insets.left() != 0) {
-    float x_offset = insets.left() / device_scale_factor;
-    float y_offset = insets.top() / device_scale_factor;
-    transform.Translate(x_offset, y_offset);
-  }
-  float inverted_scale = 1.0f / ui_scale;
-  transform.Scale(inverted_scale, inverted_scale);
-  return transform;
-}
-
-gfx::Transform CreateMirrorTransform(const display::Display& display) {
-  gfx::Transform transform;
-  transform.matrix().set3x3(-1, 0, 0, 0, 1, 0, 0, 0, 1);
-  transform.Translate(-display.size().width(), 0);
-  return transform;
-}
-
 // RootWindowTransformer for ash environment.
 class AshRootWindowTransformer : public RootWindowTransformer {
  public:
   AshRootWindowTransformer(aura::Window* root, const display::Display& display)
       : root_window_(root) {
     display::DisplayManager* display_manager = Shell::Get()->display_manager();
     display::ManagedDisplayInfo info =
         display_manager->GetDisplayInfo(display.id());
     host_insets_ = info.GetOverscanInsetsInPixel();
     root_window_ui_scale_ = info.GetEffectiveUIScale();
     root_window_bounds_transform_ =
         CreateInsetsAndScaleTransform(host_insets_,
                                       display.device_scale_factor(),
                                       root_window_ui_scale_) *
-        CreateRotationTransform(root, display);
+        CreateRootWindowRotationTransform(root, display);
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kAshEnableMirroredScreen)) {
       // Apply the tranform that flips the screen image horizontally so that
       // the screen looks normal when reflected on a mirror.
       root_window_bounds_transform_ =
           root_window_bounds_transform_ * CreateMirrorTransform(display);
     }
     transform_ = root_window_bounds_transform_ * CreateMagnifierTransform(root);
 
     CHECK(transform_.GetInverse(&invert_transform_));
@@ skipping 164 matching lines @@
                                          mirror_display_info);
 }
 
 RootWindowTransformer* CreateRootWindowTransformerForUnifiedDesktop(
     const gfx::Rect& screen_bounds,
     const display::Display& display) {
   return new PartialBoundsRootWindowTransformer(screen_bounds, display);
 }
 
 }  // namespace ash