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;
+  }
+  LOG(ERROR) << "Invalid position value: " << position;
+
+  return false;
+}
+
+}  // namespace
+
+DisplayLayout::DisplayLayout()
+    : position(RIGHT), offset(0) {}
+
+DisplayLayout::DisplayLayout(DisplayLayout::Position position, int offset)
+    : position(position), offset(offset) {
+  DCHECK_LE(DisplayLayout::TOP, position);
+  DCHECK_GE(DisplayLayout::LEFT, position);

[oshima, 2012/08/28 08:55:50]

Since this can be read from file, it's probably better to default to some value
in release build in addition to DCHECK.

I'd still DCHECK offset, say it's within abs(10000) range. (shouldn't be
bigger/samller than that). I believe offset's outlier is correctly handled, so
DCHECK should be enough.

[Jun Mukai, 2012/08/28 09:51:00]

Done.

+}
+
+void DisplayLayout::RegisterJSONConverter(
+    base::JSONValueConverter<DisplayLayout>* converter) {
+  converter->RegisterCustomField<Position>(
+      "position", &DisplayLayout::position, &GetPositionFromString);
+  converter->RegisterIntField("offset", &DisplayLayout::offset);
+}
+
+bool DisplayLayout::ConvertToValue(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;
+    default:
+      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 71 matching lines @@
   for (std::map<int64, aura::RootWindow*>::const_iterator it =
            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;
+void DisplayController::SetDefaultDisplayLayout(const DisplayLayout& layout) {
+  default_display_layout_ = layout;
   UpdateDisplayBoundsForLayout();
 }
 
-void DisplayController::SetSecondaryDisplayOffset(int offset) {
-  secondary_display_offset_ = offset;
+void DisplayController::SetLayoutForDisplayName(const std::string& name,
+                                                const DisplayLayout& layout) {
+  secondary_layouts_[name] = layout;
   UpdateDisplayBoundsForLayout();
 }
 
+const DisplayLayout& DisplayController::GetLayoutForDisplayName(
+    const std::string& name) {
+  std::map<std::string, DisplayLayout>::const_iterator it =
+      secondary_layouts_.find(name);
+
+  if (it != secondary_layouts_.end())
+    return it->second;
+  else
+    return default_display_layout_;
+}
+
 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.

[oshima, 2012/08/28 08:55:50]

we don't need this TODO any more, correct?

[Jun Mukai, 2012/08/28 09:51:00]

Removed.

 
+  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