Prevent DisplayPreferences from saving incorrect rotations.

ash/display/display_info.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 <stdio.h>
 #include <string>
 #include <vector>
 
 #include "ash/display/display_info.h"
 #include "base/logging.h"
@@ skipping 189 matching lines @@
       }
     }
     display_modes[native_mode].native = true;
   }
 
   if (id == gfx::Display::kInvalidDisplayID)
     id = synthesized_display_id++;
   DisplayInfo display_info(
       id, base::StringPrintf("Display-%d", static_cast<int>(id)), has_overscan);
   display_info.set_device_scale_factor(device_scale_factor);
-  display_info.set_rotation(rotation);
+  display_info.SetRotation(rotation, gfx::Display::ROTATION_SOURCE_ACTIVE);
   display_info.set_configured_ui_scale(ui_scale);
   display_info.SetBounds(bounds_in_native);
   display_info.SetDisplayModes(display_modes);
 
   // To test the overscan, it creates the default 5% overscan.
   if (has_overscan) {
     int width = bounds_in_native.width() / device_scale_factor / 40;
     int height = bounds_in_native.height() / device_scale_factor / 40;
     display_info.SetOverscanInsets(gfx::Insets(height, width, height, width));
     display_info.UpdateDisplaySize();
   }
 
   DVLOG(1) << "DisplayInfoFromSpec info=" << display_info.ToString()
            << ", spec=" << spec;
   return display_info;
 }
 
 DisplayInfo::DisplayInfo()
     : id_(gfx::Display::kInvalidDisplayID),
       has_overscan_(false),
-      rotation_(gfx::Display::ROTATE_0),
       touch_support_(gfx::Display::TOUCH_SUPPORT_UNKNOWN),
       touch_device_id_(0),
       device_scale_factor_(1.0f),
       overscan_insets_in_dip_(0, 0, 0, 0),
       configured_ui_scale_(1.0f),
       native_(false),
       is_aspect_preserving_scaling_(false),
       clear_overscan_insets_(false),
       color_profile_(ui::COLOR_PROFILE_STANDARD) {
 }
 
 DisplayInfo::DisplayInfo(int64 id,
                          const std::string& name,
                          bool has_overscan)
     : id_(id),
       name_(name),
       has_overscan_(has_overscan),
-      rotation_(gfx::Display::ROTATE_0),
       touch_support_(gfx::Display::TOUCH_SUPPORT_UNKNOWN),
       touch_device_id_(0),
       device_scale_factor_(1.0f),
       overscan_insets_in_dip_(0, 0, 0, 0),
       configured_ui_scale_(1.0f),
       native_(false),
       is_aspect_preserving_scaling_(false),
       clear_overscan_insets_(false),
       color_profile_(ui::COLOR_PROFILE_STANDARD) {
 }
 
 DisplayInfo::~DisplayInfo() {
 }
 
+void DisplayInfo::SetRotation(gfx::Display::Rotation rotation,
+                              gfx::Display::RotationSource source) {
+  rotations_[source] = rotation;
+  rotations_[gfx::Display::ROTATION_SOURCE_ACTIVE] = rotation;
+}
+
+gfx::Display::Rotation DisplayInfo::ActiveRotation() const {
+  return GetRotation(gfx::Display::ROTATION_SOURCE_ACTIVE);
+}
+
+gfx::Display::Rotation DisplayInfo::GetRotation(
+    gfx::Display::RotationSource source) const {
+  if (rotations_.find(source) == rotations_.end())
+    return gfx::Display::ROTATE_0;
+  return rotations_.at(source);
+}
+
 void DisplayInfo::Copy(const DisplayInfo& native_info) {
   DCHECK(id_ == native_info.id_);
   name_ = native_info.name_;
   has_overscan_ = native_info.has_overscan_;
 
   touch_support_ = native_info.touch_support_;
   touch_device_id_ = native_info.touch_device_id_;
   device_scale_factor_ = native_info.device_scale_factor_;
   DCHECK(!native_info.bounds_in_native_.IsEmpty());
   bounds_in_native_ = native_info.bounds_in_native_;
   size_in_pixel_ = native_info.size_in_pixel_;
   is_aspect_preserving_scaling_ = native_info.is_aspect_preserving_scaling_;
   display_modes_ = native_info.display_modes_;
   available_color_profiles_ = native_info.available_color_profiles_;
 
   // Rotation, ui_scale, color_profile and overscan are given by preference,
   // or unit tests. Don't copy if this native_info came from
   // DisplayChangeObserver.
   if (!native_info.native()) {
     // Update the overscan_insets_in_dip_ either if the inset should be
     // cleared, or has non empty insts.
     if (native_info.clear_overscan_insets())
       overscan_insets_in_dip_.Set(0, 0, 0, 0);
     else if (!native_info.overscan_insets_in_dip_.empty())
       overscan_insets_in_dip_ = native_info.overscan_insets_in_dip_;
 
-    rotation_ = native_info.rotation_;
+    rotations_ = native_info.rotations_;
     configured_ui_scale_ = native_info.configured_ui_scale_;
     color_profile_ = native_info.color_profile();
   }
 }
 
 void DisplayInfo::SetBounds(const gfx::Rect& new_bounds_in_native) {
   bounds_in_native_ = new_bounds_in_native;
   size_in_pixel_ = new_bounds_in_native.size();
   UpdateDisplaySize();
 }
@@ skipping 17 matching lines @@
 void DisplayInfo::UpdateDisplaySize() {
   size_in_pixel_ = bounds_in_native_.size();
   if (!overscan_insets_in_dip_.empty()) {
     gfx::Insets insets_in_pixel =
         overscan_insets_in_dip_.Scale(device_scale_factor_);
     size_in_pixel_.Enlarge(-insets_in_pixel.width(), -insets_in_pixel.height());
   } else {
     overscan_insets_in_dip_.Set(0, 0, 0, 0);
   }
 
-  if (rotation_ == gfx::Display::ROTATE_90 ||
-      rotation_ == gfx::Display::ROTATE_270)
+  if (ActiveRotation() == gfx::Display::ROTATE_90 ||
+      ActiveRotation() == gfx::Display::ROTATE_270) {
     size_in_pixel_.SetSize(size_in_pixel_.height(), size_in_pixel_.width());
+  }
   gfx::SizeF size_f(size_in_pixel_);
   size_f.Scale(GetEffectiveUIScale());
   size_in_pixel_ = gfx::ToFlooredSize(size_f);
 }
 
 void DisplayInfo::SetOverscanInsets(const gfx::Insets& insets_in_dip) {
   overscan_insets_in_dip_ = insets_in_dip;
 }
 
 gfx::Insets DisplayInfo::GetOverscanInsetsInPixel() const {
@@ skipping 10 matching lines @@
 gfx::Size DisplayInfo::GetNativeModeSize() const {
   for (size_t i = 0; i < display_modes_.size(); ++i) {
     if (display_modes_[i].native)
       return display_modes_[i].size;
   }
 
   return gfx::Size();
 }
 
 std::string DisplayInfo::ToString() const {
-  int rotation_degree = static_cast<int>(rotation_) * 90;
+  int rotation_degree = static_cast<int>(ActiveRotation()) * 90;
   return base::StringPrintf(
       "DisplayInfo[%lld] native bounds=%s, size=%s, scale=%f, "
       "overscan=%s, rotation=%d, ui-scale=%f, touchscreen=%s, "
       "touch-device-id=%d",
       static_cast<long long int>(id_),
       bounds_in_native_.ToString().c_str(),
       size_in_pixel_.ToString().c_str(),
       device_scale_factor_,
       overscan_insets_in_dip_.ToString().c_str(),
       rotation_degree,
@@ skipping 33 matching lines @@
   return std::find(available_color_profiles_.begin(),
                    available_color_profiles_.end(),
                    profile) != available_color_profiles_.end();
 }
 
 bool DisplayInfo::Use125DSFRorUIScaling() const {
   return use_125_dsf_for_ui_scaling && id_ == gfx::Display::InternalDisplayId();
 }
 
 }  // namespace ash