Allow storing display preferences per device.

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/multi_display_manager.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
+#include "base/json/json_value_converter.h"
+#include "base/string_piece.h"
+#include "base/values.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 
 namespace ash {
 namespace internal {
 namespace {
 
 // The number of pixels to overlap between the primary and secondary displays,
 // in case that the offset value is too large.
 const int kMinimumOverlapForInvalidOffset = 50;
 
+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;
+    return true;
+  } else if (position == "left") {
+    *field = DisplayLayout::LEFT;
+    return true;
+  }

[oshima, 2012/08/27 23:00:46]

log if the position is not one of value above.

[Jun Mukai, 2012/08/28 08:12:42]

Done.

+
+  return false;
+}
+
+}  // namespace
+
+DisplayLayout::DisplayLayout()
+    : position(RIGHT), offset(0) {}
+
+DisplayLayout::DisplayLayout(DisplayLayout::Position p, int o)
+    : position(p), offset(o) {}

[oshima, 2012/08/27 23:00:46]

you probably want to check the range of both position as they can be read from
file.

[Jun Mukai, 2012/08/28 08:12:42]

Added DCHECK for position.  The offset value validity changes based on the
resolutions of both primary/secondary displays, so it's not possible to check
the validity here.

+
+void DisplayLayout::RegisterJSONConverter(
+    base::JSONValueConverter<DisplayLayout>* converter) {
+  converter->RegisterCustomField<Position>(
+      "position", &DisplayLayout::position, &GetPositionFromString);
+  converter->RegisterIntField("offset", &DisplayLayout::offset);
+}
+
+bool DisplayLayout::GetValue(base::DictionaryValue* value) {
+  std::string position_value;
+  switch (position) {
+    case TOP:
+      position_value = "top";
+      break;
+    case BOTTOM:
+      position_value = "bottom";
+      break;
+    case RIGHT:
+      position_value = "right";
+      break;
+    case LEFT:
+      position_value = "left";
+      break;

[oshima, 2012/08/27 23:00:46]

default:
  return false;

is better.

[Jun Mukai, 2012/08/28 08:12:42]

Done.

+  }
+  if (position_value.empty())

[oshima, 2012/08/27 23:00:46]

if you're worrying about fall through, it should be CHECK/DCHECK.

[Jun Mukai, 2012/08/28 08:12:42]

removed.

+    return false;
+
+  value->SetString("position", position_value);
+  value->SetInteger("offset", offset);
+  return true;
 }
 
 DisplayController::DisplayController()
-    : secondary_display_layout_(RIGHT),
-      secondary_display_offset_(0),
-      dont_warp_mouse_(false) {
+    : dont_warp_mouse_(false) {
   aura::Env::GetInstance()->display_manager()->AddObserver(this);
 }
 
 DisplayController::~DisplayController() {
   aura::Env::GetInstance()->display_manager()->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 =
            root_windows_.rbegin(); it != root_windows_.rend(); ++it) {
     internal::RootWindowController* controller =
@@ skipping 72 matching lines @@
            root_windows_.begin(); it != root_windows_.end(); ++it) {
     internal::RootWindowController* controller =
         GetRootWindowController(it->second);
     if (controller)
       controllers.push_back(controller);
   }
   return controllers;
 }
 
 void DisplayController::SetSecondaryDisplayLayout(
-    SecondaryDisplayLayout layout) {
-  secondary_display_layout_ = layout;
+    DisplayLayout::Position position) {
+  default_display_layout_.position = position;
   UpdateDisplayBoundsForLayout();
 }
 
 void DisplayController::SetSecondaryDisplayOffset(int offset) {
-  secondary_display_offset_ = offset;
+  default_display_layout_.offset = offset;
   UpdateDisplayBoundsForLayout();
 }
 
+void DisplayController::SetDisplayLayoutForName(const std::string& name,
+                                                const base::Value& value) {
+  base::JSONValueConverter<DisplayLayout> converter;
+  DisplayLayout layout;
+  if (!converter.Convert(value, &layout))
+    return;
+
+  secondary_layouts_[name] = layout;
+  UpdateDisplayBoundsForLayout();
+}
+
+void DisplayController::GetLayoutForDisplay(const gfx::Display& display,
+                                            int* layout, int* offset) {
+  // TODO
+}
+
 bool DisplayController::WarpMouseCursorIfNecessary(
     aura::RootWindow* current_root,
     const gfx::Point& point_in_root) {
   if (root_windows_.size() < 2 || dont_warp_mouse_)
     return false;
   const float scale = ui::GetDeviceScaleFactor(current_root->layer());
 
   // The pointer might be outside the |current_root|. Get the root window where
   // the pointer is currently on.
   std::pair<aura::RootWindow*, gfx::Point> actual_location =
@@ skipping 96 matching lines @@
 
 void DisplayController::UpdateDisplayBoundsForLayout() {
   if (!IsExtendedDesktopEnabled() || gfx::Screen::GetNumDisplays() <= 1) {
     return;
   }
   DCHECK_EQ(2, gfx::Screen::GetNumDisplays());
   aura::DisplayManager* display_manager =
       aura::Env::GetInstance()->display_manager();
   const gfx::Rect& primary_bounds = display_manager->GetDisplayAt(0)->bounds();
   gfx::Display* secondary_display = display_manager->GetDisplayAt(1);
+  const std::string& secondary_name = display_manager->GetDisplayNameAt(1);
   const gfx::Rect& secondary_bounds = secondary_display->bounds();
   gfx::Point new_secondary_origin = primary_bounds.origin();
 
   // TODO(oshima|mukai): Implement more flexible layout.
 
+  const DisplayLayout* layout = &default_display_layout_;
+  std::map<std::string, DisplayLayout>::const_iterator iter =
+      secondary_layouts_.find(secondary_name);
+  if (iter != secondary_layouts_.end())
+    layout = &iter->second;
+
+  DisplayLayout::Position position = layout->position;
+
   // Ignore the offset in case the secondary display doesn't share edges with
   // the primary display.
-  int offset = secondary_display_offset_;
-  if (secondary_display_layout_ == TOP || secondary_display_layout_ == BOTTOM) {
+  int offset = layout->offset;
+  if (position == DisplayLayout::TOP || position == DisplayLayout::BOTTOM) {
     offset = std::min(
         offset, primary_bounds.width() - kMinimumOverlapForInvalidOffset);
     offset = std::max(
         offset, -secondary_bounds.width() + kMinimumOverlapForInvalidOffset);
   } else {
     offset = std::min(
         offset, primary_bounds.height() - kMinimumOverlapForInvalidOffset);
     offset = std::max(
         offset, -secondary_bounds.height() + kMinimumOverlapForInvalidOffset);
   }
-  switch (secondary_display_layout_) {
-    case TOP:
+  switch (position) {
+    case DisplayLayout::TOP:
       new_secondary_origin.Offset(offset, -secondary_bounds.height());
       break;
-    case RIGHT:
+    case DisplayLayout::RIGHT:
       new_secondary_origin.Offset(primary_bounds.width(), offset);
       break;
-    case BOTTOM:
+    case DisplayLayout::BOTTOM:
       new_secondary_origin.Offset(offset, primary_bounds.height());
       break;
-    case LEFT:
+    case DisplayLayout::LEFT:
       new_secondary_origin.Offset(-secondary_bounds.width(), offset);
       break;
   }
   gfx::Insets insets = secondary_display->GetWorkAreaInsets();
   secondary_display->set_bounds(
       gfx::Rect(new_secondary_origin, secondary_bounds.size()));
   secondary_display->UpdateWorkAreaFromInsets(insets);
 }
 
 }  // namespace internal
 }  // namespace ash