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 30 matching lines @@
 // potential conflict with chrome headers.
 #include <X11/extensions/Xrandr.h>
 #undef RootWindow
 #endif  // defined(OS_CHROMEOS)
 
 DECLARE_WINDOW_PROPERTY_TYPE(gfx::Display::Rotation);
 
 namespace ash {
 namespace {
 
-DEFINE_WINDOW_PROPERTY_KEY(gfx::Display::Rotation, kRotationKey,
+DEFINE_WINDOW_PROPERTY_KEY(gfx::Display::Rotation, kRotationPropKey,

[James Cook, 2013/03/22 16:53:14]

kRotationPropertyKey please

[oshima, 2013/03/22 18:20:42]

Done.

                            gfx::Display::ROTATE_0);
 
 // Primary display stored in global object as it can be
 // accessed after Shell is deleted. A separate display instance is created
 // during the shutdown instead of always keeping two display instances
 // (one here and another one in display_manager) in sync, which is error prone.
 int64 primary_display_id = gfx::Display::kInvalidDisplayID;
 gfx::Display* primary_display_for_shutdown = NULL;
 // Keeps the number of displays during the shutdown after
 // ash::Shell:: is deleted.
@@ skipping 10 matching lines @@
 // Specifies how long the display change should have been disabled
 // after each display change operations.
 // |kCycleDisplayThrottleTimeoutMs| is set to be longer to avoid
 // 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";
+
 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") {
     *field = DisplayLayout::RIGHT;
@@ skipping 26 matching lines @@
 
 void RotateRootWindow(aura::RootWindow* root_window,
                       const gfx::Display& display,
                       const internal::DisplayInfo& info) {
   // 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.rotation() == root_window->GetProperty(kRotationKey))
+  if (info.rotation() == root_window->GetProperty(kRotationPropKey))
     return;
-  root_window->SetProperty(kRotationKey, info.rotation());
+  root_window->SetProperty(kRotationPropKey, info.rotation());
 #endif
   gfx::Transform rotate;
   // The origin is (0, 0), so the translate width/height must be reduced by 1.
   switch (info.rotation()) {
     case gfx::Display::ROTATE_0:
       break;
     case gfx::Display::ROTATE_90:
       rotate.Translate(display.bounds().height() - 1, 0);
       rotate.Rotate(90);
       break;
     case gfx::Display::ROTATE_270:
       rotate.Translate(0, display.bounds().width() - 1);
       rotate.Rotate(270);
       break;
     case gfx::Display::ROTATE_180:
       rotate.Translate(display.bounds().width() - 1,
                        display.bounds().height() - 1);
       rotate.Rotate(180);
       break;
   }
   root_window->SetTransform(rotate);
 }
 
 void SetDisplayPropertiesOnHostWindow(aura::RootWindow* root,
                                       const gfx::Display& display) {
-  internal::DisplayInfo info = GetDisplayManager()->GetDisplayInfo(display);
+  internal::DisplayInfo info =
+      GetDisplayManager()->GetDisplayInfo(display.id());
 #if defined(OS_CHROMEOS)
   // Native window property (Atom in X11) that specifies the display's
   // rotation, scale factor and if it's internal display.  They are
   // read and used by touchpad/mouse driver directly on X (contact
   // adlr@ for more details on touchpad/mouse driver side). The value
   // of the rotation is one of 0 (normal), 1 (90 degrees clockwise), 2
   // (180 degree) or 3 (270 degrees clockwise).  The value of the
   // scale factor is in percent (100, 140, 200 etc).
   const char kRotationProp[] = "_CHROME_DISPLAY_ROTATION";
   const char kScaleFactorProp[] = "_CHROME_DISPLAY_SCALE_FACTOR";
@@ skipping 82 matching lines @@
 }
 
 // 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("position", position_str);
-  dict_value->SetInteger("offset", layout.offset);
+  dict_value->SetString(kPositionKey, position_str);
+  dict_value->SetInteger(kOffsetKey, layout.offset);
   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>(
-      "position", &DisplayLayout::position, &GetPositionFromString);
-  converter->RegisterIntField("offset", &DisplayLayout::offset);
+      kPositionKey, &DisplayLayout::position, &GetPositionFromString);
+  converter->RegisterIntField(kOffsetKey, &DisplayLayout::offset);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DisplayChangeLimiter
 
 DisplayController::DisplayChangeLimiter::DisplayChangeLimiter()
     : throttle_timeout_(base::Time::Now()) {
 }
 
 void DisplayController::DisplayChangeLimiter::SetThrottleTimeout(
@@ skipping 34 matching lines @@
         default_display_layout_.position = DisplayLayout::LEFT;
       default_display_layout_.offset = offset;
     }
   }
   // Reset primary display to make sure that tests don't use
   // stale display info from previous tests.
   primary_display_id = gfx::Display::kInvalidDisplayID;
   delete primary_display_for_shutdown;
   primary_display_for_shutdown = NULL;
   num_displays_for_shutdown = -1;
-
-  Shell::GetScreen()->AddObserver(this);
 }
 
 DisplayController::~DisplayController() {
   DCHECK(primary_display_for_shutdown);
 }
 
+void DisplayController::Start() {
+  Shell::GetScreen()->AddObserver(this);
+}
+
 void DisplayController::Shutdown() {
   DCHECK(!primary_display_for_shutdown);
   primary_display_for_shutdown = new gfx::Display(
       GetDisplayManager()->GetDisplayForId(primary_display_id));
   num_displays_for_shutdown = GetDisplayManager()->GetNumDisplays();
 
   Shell::GetScreen()->RemoveObserver(this);
   // Delete all root window controllers, which deletes root window
   // from the last so that the primary root window gets deleted last.
   for (std::map<int64, aura::RootWindow*>::const_reverse_iterator it =
@@ skipping 308 matching lines @@
   desired_primary_display_id_ = primary_display_id;
 
   display_manager->UpdateWorkAreaOfDisplayNearestWindow(
       primary_root, old_primary_display.GetWorkAreaInsets());
   display_manager->UpdateWorkAreaOfDisplayNearestWindow(
       non_primary_root, new_primary_display.GetWorkAreaInsets());
 
   // Update the dispay manager with new display info.
   std::vector<internal::DisplayInfo> display_info_list;
   display_info_list.push_back(display_manager->GetDisplayInfo(
-      display_manager->GetDisplayForId(primary_display_id)));
+      primary_display_id));
   display_info_list.push_back(display_manager->GetDisplayInfo(
-      *GetSecondaryDisplay()));
+      GetSecondaryDisplay()->id()));
   GetDisplayManager()->set_force_bounds_changed(true);
   GetDisplayManager()->UpdateDisplays(display_info_list);
   GetDisplayManager()->set_force_bounds_changed(false);
 }
 
 gfx::Display* DisplayController::GetSecondaryDisplay() {
   internal::DisplayManager* display_manager = GetDisplayManager();
   CHECK_EQ(2U, display_manager->GetNumDisplays());
   return display_manager->GetDisplayAt(0)->id() == primary_display_id ?
       display_manager->GetDisplayAt(1) : display_manager->GetDisplayAt(0);
 }
 
 void DisplayController::OnDisplayBoundsChanged(const gfx::Display& display) {
   if (limiter_.get())
     limiter_->SetThrottleTimeout(kAfterDisplayChangeThrottleTimeoutMs);
   const internal::DisplayInfo& display_info =
-      GetDisplayManager()->GetDisplayInfo(display);
+      GetDisplayManager()->GetDisplayInfo(display.id());
   DCHECK(!display_info.bounds_in_pixel().IsEmpty());
 
   UpdateDisplayBoundsForLayout();
   aura::RootWindow* root = root_windows_[display.id()];
   root->SetHostBoundsAndInsetsAndRootWindowScale(
       display_info.bounds_in_pixel(),
       display_info.GetOverscanInsetsInPixel(),
       display_info.ui_scale());
   SetDisplayPropertiesOnHostWindow(root, display);
 }
 
 void DisplayController::OnDisplayAdded(const gfx::Display& display) {
   if (limiter_.get())
     limiter_->SetThrottleTimeout(kAfterDisplayChangeThrottleTimeoutMs);
 
   if (primary_root_window_for_replace_) {
     DCHECK(root_windows_.empty());
     primary_display_id = display.id();
     root_windows_[display.id()] = primary_root_window_for_replace_;
     primary_root_window_for_replace_->SetProperty(
         internal::kDisplayIdKey, display.id());
     primary_root_window_for_replace_ = NULL;
     UpdateDisplayBoundsForLayout();
     const internal::DisplayInfo& display_info =
-        GetDisplayManager()->GetDisplayInfo(display);
+        GetDisplayManager()->GetDisplayInfo(display.id());
     root_windows_[display.id()]->SetHostBoundsAndInsetsAndRootWindowScale(
         display_info.bounds_in_pixel(),
         display_info.GetOverscanInsetsInPixel(),
         display_info.ui_scale());
   } else {
     DCHECK(!root_windows_.empty());
     aura::RootWindow* root = AddRootWindowForDisplay(display);
     UpdateDisplayBoundsForLayout();
     if (desired_primary_display_id_ == display.id())
       SetPrimaryDisplay(display);
@@ skipping 44 matching lines @@
   // Delete most of root window related objects, but don't delete
   // root window itself yet because the stack may be using it.
   controller->Shutdown();
   MessageLoop::current()->DeleteSoon(FROM_HERE, controller);
 }
 
 aura::RootWindow* DisplayController::CreateRootWindowForDisplay(
     const gfx::Display& display) {
   static int root_window_count = 0;
   const internal::DisplayInfo& display_info =
-      GetDisplayManager()->GetDisplayInfo(display);
+      GetDisplayManager()->GetDisplayInfo(display.id());
   const gfx::Rect& bounds_in_pixel = display_info.bounds_in_pixel();
   aura::RootWindow::CreateParams params(bounds_in_pixel);
   params.host = Shell::GetInstance()->root_window_host_factory()->
       CreateRootWindowHost(bounds_in_pixel);
   params.initial_insets = display_info.GetOverscanInsetsInPixel();
   params.initial_root_window_scale = display_info.ui_scale();
   aura::RootWindow* root_window = new aura::RootWindow(params);
   root_window->SetName(
       base::StringPrintf("RootWindow-%d", root_window_count++));
 
@@ skipping 88 matching lines @@
 }
 
 void DisplayController::OnFadeOutForSwapDisplayFinished() {
 #if defined(OS_CHROMEOS)
   SetPrimaryDisplay(ScreenAsh::GetSecondaryDisplay());
   Shell::GetInstance()->output_configurator_animation()->StartFadeInAnimation();
 #endif
 }
 
 }  // namespace ash