Revert of Merge Prevent DisplayPreferences from saving incorrect rotations.

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 <vector>
 
 #include "ash/ash_switches.h"
@@ skipping 49 matching lines @@
 
 // The time it takes for the rotation animations to run.
 const int kRotationDurationInMs = 250;
 
 // Gets the current display rotation for the display with the specified
 // |display_id|.
 gfx::Display::Rotation GetCurrentRotation(int64 display_id) {
   return Shell::GetInstance()
       ->display_manager()
       ->GetDisplayInfo(display_id)
-      .GetActiveRotation();
+      .rotation();
 }
 
 // Returns true if the rotation between |initial_rotation| and |new_rotation| is
 // 180 degrees.
 bool Is180DegreeFlip(gfx::Display::Rotation initial_rotation,
                      gfx::Display::Rotation new_rotation) {
   return (initial_rotation + 2) % 4 == new_rotation;
 }
 
 // A LayerAnimationObserver that will destroy the contained LayerTreeOwner when
@@ skipping 66 matching lines @@
 void LayerCleanupObserver::OnDetachedFromSequence(
     ui::LayerAnimationSequence* sequence) {
   DCHECK_EQ(sequence, sequence_);
   sequence_ = nullptr;
 }
 
 // Set the screen orientation for the given |display| to |new_rotation| and
 // animate the change.
 void RotateScreen(int64 display_id,
                   gfx::Display::Rotation new_rotation,
-                  gfx::Display::RotationSource source,
                   base::TimeDelta duration,
                   int rotation_degrees,
                   int rotation_degree_offset,
                   gfx::Tween::Type tween_type,
                   bool should_scale) {
   aura::Window* root_window =
       Shell::GetInstance()->display_controller()->GetRootWindowForDisplayId(
           display_id);
 
   const gfx::Display::Rotation initial_orientation =
       GetCurrentRotation(display_id);
 
   const gfx::RectF original_screen_bounds = root_window->GetTargetBounds();
   // 180 degree rotations should animate clock-wise.
   const int rotation_factor =
       (initial_orientation + 3) % 4 == new_rotation ? 1 : -1;
 
   scoped_ptr<ui::LayerTreeOwner> old_layer_tree =
       wm::RecreateLayers(root_window);
 
   // 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());
 
   scoped_ptr<LayerCleanupObserver> layer_cleanup_observer(
       new LayerCleanupObserver(old_layer_tree.Pass()));
 
-  Shell::GetInstance()->display_manager()->SetDisplayRotation(
-      display_id, new_rotation, source);
+  Shell::GetInstance()->display_manager()->SetDisplayRotation(display_id,
+                                                              new_rotation);
 
   const gfx::RectF rotated_screen_bounds = root_window->GetTargetBounds();
   const gfx::Point pivot = gfx::Point(rotated_screen_bounds.width() / 2,
                                       rotated_screen_bounds.height() / 2);
 
   gfx::Point3F new_layer_initial_scale = gfx::Point3F(1.0f, 1.0f, 1.0f);
   gfx::Point3F old_layer_target_scale = gfx::Point3F(1.0f, 1.0f, 1.0f);
 
   if (should_scale) {
     new_layer_initial_scale = gfx::Point3F(
@@ skipping 64 matching lines @@
 
 }  // namespace
 
 ScreenRotationAnimator::ScreenRotationAnimator(int64 display_id)
     : display_id_(display_id) {
 }
 
 ScreenRotationAnimator::~ScreenRotationAnimator() {
 }
 
-void ScreenRotationAnimator::Rotate(gfx::Display::Rotation new_rotation,
-                                    gfx::Display::RotationSource source) {
+void ScreenRotationAnimator::Rotate(gfx::Display::Rotation new_rotation) {
   const gfx::Display::Rotation current_rotation =
       GetCurrentRotation(display_id_);
 
   if (current_rotation == new_rotation)
     return;
 
   const std::string switch_value =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kAshEnableScreenRotationAnimation);
 
   if (switch_value == kRotationAnimation_None) {
-    Shell::GetInstance()->display_manager()->SetDisplayRotation(
-        display_id_, new_rotation, source);
+    Shell::GetInstance()->display_manager()->SetDisplayRotation(display_id_,
+                                                                new_rotation);
   } else if (kRotationAnimation_Default == switch_value ||
              kRotationAnimation_Partial == switch_value) {
     const int rotation_degree_offset =
         Is180DegreeFlip(current_rotation, new_rotation)
             ? 180 - kPartialRotationDegrees
             : 90 - kPartialRotationDegrees;
 
-    RotateScreen(display_id_, new_rotation, source,
+    RotateScreen(display_id_, new_rotation,
                  base::TimeDelta::FromMilliseconds(kRotationDurationInMs),
                  kPartialRotationDegrees, rotation_degree_offset,
                  gfx::Tween::FAST_OUT_LINEAR_IN, false /* should_scale */);
   } else if (kRotationAnimation_Full == switch_value) {
     const int rotation_degrees =
         Is180DegreeFlip(current_rotation, new_rotation) ? 180 : 90;
 
-    RotateScreen(display_id_, new_rotation, source,
+    RotateScreen(display_id_, new_rotation,
                  base::TimeDelta::FromMilliseconds(kRotationDurationInMs),
                  rotation_degrees, 0 /* rotation_degree_offset */,
                  gfx::Tween::FAST_OUT_LINEAR_IN, true /* should_scale */);
   } else {
     NOTREACHED();
   }
 }
 
 }  // namespace ash