Store rotation/ui scale to local state.

ash/display/display_controller.cc

 // Copyright (c) 2012 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/display_controller.h"
 
 #include <algorithm>
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_manager.h"
@@ skipping 64 matching lines @@
 // changing the settings while the system is still configurating
 // displays. It will be overriden by |kAfterDisplayChangeThrottleTimeoutMs|
 // when the display change happens, so the actual timeout is much shorter.
 const int64 kAfterDisplayChangeThrottleTimeoutMs = 500;
 const int64 kCycleDisplayThrottleTimeoutMs = 4000;
 const int64 kSwapDisplayThrottleTimeoutMs = 500;
 
 // Persistent key names
 const char kPositionKey[] = "position";
 const char kOffsetKey[] = "offset";
+const char kMirroredKey[] = "mirrored";
 
 bool GetPositionFromString(const base::StringPiece& position,
                            DisplayLayout::Position* field) {
   if (position == "top") {
     *field = DisplayLayout::TOP;
     return true;
   } else if (position == "bottom") {
     *field = DisplayLayout::BOTTOM;
     return true;
   } else if (position == "right") {
@@ skipping 103 matching lines @@
 #endif
   RotateRootWindow(root, display, info);
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // DisplayLayout
 
 // static
-DisplayLayout DisplayLayout::FromInts(int position, int offsets) {
-  return DisplayLayout(static_cast<Position>(position), offsets);
+DisplayLayout DisplayLayout::FromInts(int position, int offsets, bool mirror) {
+  return DisplayLayout(static_cast<Position>(position), offsets, mirror);
 }
 
 DisplayLayout::DisplayLayout()
     : position(RIGHT),
-      offset(0) {}
+      offset(0),
+      mirrored(false) {}
 
-DisplayLayout::DisplayLayout(DisplayLayout::Position position, int offset)
+DisplayLayout::DisplayLayout(DisplayLayout::Position position,
+                             int offset,
+                             bool mirrored)
     : position(position),
-      offset(offset) {
+      offset(offset),
+      mirrored(mirrored) {
   DCHECK_LE(TOP, position);
   DCHECK_GE(LEFT, position);
 
   // Set the default value to |position| in case position is invalid.  DCHECKs
   // above doesn't stop in Release builds.
   if (TOP > position || LEFT < position)
     this->position = RIGHT;
 
   DCHECK_GE(kMaxValidOffset, abs(offset));
 }
 
 DisplayLayout DisplayLayout::Invert() const {
   Position inverted_position = RIGHT;
   switch (position) {
     case TOP:
       inverted_position = BOTTOM;
       break;
     case BOTTOM:
       inverted_position = TOP;
       break;
     case RIGHT:
       inverted_position = LEFT;
       break;
     case LEFT:
       inverted_position = RIGHT;
       break;
   }
-  return DisplayLayout(inverted_position, -offset);
+  return DisplayLayout(inverted_position, -offset, mirrored);
 }
 
 // static
 bool DisplayLayout::ConvertFromValue(const base::Value& value,
                                      DisplayLayout* layout) {
   base::JSONValueConverter<DisplayLayout> converter;
   return converter.Convert(value, layout);
 }
 
 // static
 bool DisplayLayout::ConvertToValue(const DisplayLayout& layout,
                                    base::Value* value) {
   base::DictionaryValue* dict_value = NULL;
   if (!value->GetAsDictionary(&dict_value) || dict_value == NULL)
     return false;
 
   const std::string position_str = GetStringFromPosition(layout.position);
   dict_value->SetString(kPositionKey, position_str);
   dict_value->SetInteger(kOffsetKey, layout.offset);
+  dict_value->SetBoolean(kMirroredKey, layout.mirrored);
   return true;
 }
 
 std::string DisplayLayout::ToString() const {
   const std::string position_str = GetStringFromPosition(position);
   return base::StringPrintf("%s, %d", position_str.c_str(), offset);
 }
 
 // static
 void DisplayLayout::RegisterJSONConverter(
     base::JSONValueConverter<DisplayLayout>* converter) {
   converter->RegisterCustomField<Position>(
       kPositionKey, &DisplayLayout::position, &GetPositionFromString);
   converter->RegisterIntField(kOffsetKey, &DisplayLayout::offset);
+  converter->RegisterBoolField(kMirroredKey, &DisplayLayout::mirrored);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DisplayChangeLimiter
 
 DisplayController::DisplayChangeLimiter::DisplayChangeLimiter()
     : throttle_timeout_(base::Time::Now()) {
 }
 
 void DisplayController::DisplayChangeLimiter::SetThrottleTimeout(
@@ skipping 573 matching lines @@
   secondary_display->set_bounds(
       gfx::Rect(new_secondary_origin, secondary_bounds.size()));
   secondary_display->UpdateWorkAreaFromInsets(insets);
 }
 
 void DisplayController::NotifyDisplayConfigurationChanging() {
   FOR_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanging());
 }
 
 void DisplayController::NotifyDisplayConfigurationChanged() {
+  internal::DisplayManager* display_manager = GetDisplayManager();
+  if (display_manager->num_connected_displays() > 1) {
+    bool mirrored = display_manager->IsMirrored();
+    DisplayIdPair pair = mirrored ?
+        std::make_pair(GetPrimaryDisplay().id(),
+                       display_manager->mirrored_display_id()) :
+        GetCurrentDisplayIdPair();
+    paired_layouts_[pair].mirrored = mirrored;
+  }
   FOR_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanged());
 }
 
 void DisplayController::RegisterLayoutForDisplayIdPairInternal(
     int64 id1,
     int64 id2,
     const DisplayLayout& layout,
     bool override) {
   DisplayIdPair pair = std::make_pair(id1, id2);
   if (override || paired_layouts_.find(pair) == paired_layouts_.end())
     paired_layouts_[pair] = layout;
 }
 
 void DisplayController::OnFadeOutForSwapDisplayFinished() {
 #if defined(OS_CHROMEOS)
   SetPrimaryDisplay(ScreenAsh::GetSecondaryDisplay());
   Shell::GetInstance()->output_configurator_animation()->StartFadeInAnimation();
 #endif
 }
 
 }  // namespace ash