ASH: Use virtual screen coordinates in Display::bounds()

ash/monitor/monitor_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/monitor/monitor_controller.h"
 
 #include "ash/ash_switches.h"
 #include "ash/monitor/multi_monitor_manager.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
@@ skipping 33 matching lines @@
     if (controller)
       delete controller;
     else
       delete it->second;
   }
 }
 
 void MonitorController::InitPrimaryDisplay() {
   aura::MonitorManager* monitor_manager =
       aura::Env::GetInstance()->monitor_manager();
-  const gfx::Display& display = monitor_manager->GetDisplayAt(0);
-  DCHECK_EQ(0, display.id());
-  aura::RootWindow* root = AddRootWindowForDisplay(display);
-  root->SetHostBounds(display.bounds_in_pixel());
+  const gfx::Display* display = monitor_manager->GetDisplayAt(0);
+  DCHECK_EQ(0, display->id());
+  aura::RootWindow* root = AddRootWindowForDisplay(*display);
+  root->SetHostBounds(display->bounds_in_pixel());
 }
 
 void MonitorController::InitSecondaryDisplays() {
   aura::MonitorManager* monitor_manager =
       aura::Env::GetInstance()->monitor_manager();
   for (size_t i = 1; i < monitor_manager->GetNumDisplays(); ++i) {
-    const gfx::Display& display = monitor_manager->GetDisplayAt(i);
-    aura::RootWindow* root = AddRootWindowForDisplay(display);
+    const gfx::Display* display = monitor_manager->GetDisplayAt(i);
+    aura::RootWindow* root = AddRootWindowForDisplay(*display);
     Shell::GetInstance()->InitRootWindowForSecondaryMonitor(root);
   }
 }
 
 aura::RootWindow* MonitorController::GetPrimaryRootWindow() {
   DCHECK(!root_windows_.empty());
   return root_windows_[0];
 }
 
 void MonitorController::CloseChildWindows() {
@@ skipping 33 matching lines @@
         wm::GetRootWindowController(it->second);
     if (controller)
       controllers.push_back(controller);
   }
   return controllers;
 }
 
 void MonitorController::SetSecondaryDisplayLayout(
     SecondaryDisplayLayout layout) {
   secondary_display_layout_ = layout;
+  UpdateDisplayBoundsForLayout();
 }
 
 bool MonitorController::WarpMouseCursorIfNecessary(
     aura::Window* current_root,
     const gfx::Point& location_in_root) {
   if (root_windows_.size() < 2)
     return false;
   // Only 1 external display is supported in extended desktop mode.
   DCHECK_EQ(2U, root_windows_.size());
 
@@ skipping 55 matching lines @@
   if (alternate_root) {
     DCHECK_NE(alternate_root, current_root);
     alternate_root->MoveCursorTo(alternate_point);
     return true;
   }
   return false;
 }
 
 void MonitorController::OnDisplayBoundsChanged(const gfx::Display& display) {
   root_windows_[display.id()]->SetHostBounds(display.bounds_in_pixel());
+  UpdateDisplayBoundsForLayout();
 }
 
 void MonitorController::OnDisplayAdded(const gfx::Display& display) {
   if (root_windows_.empty()) {
     DCHECK_EQ(0, display.id());
     root_windows_[display.id()] = Shell::GetPrimaryRootWindow();
     Shell::GetPrimaryRootWindow()->SetHostBounds(display.bounds_in_pixel());
     return;
   }
   aura::RootWindow* root = AddRootWindowForDisplay(display);
   Shell::GetInstance()->InitRootWindowForSecondaryMonitor(root);
+  UpdateDisplayBoundsForLayout();
 }
 
 void MonitorController::OnDisplayRemoved(const gfx::Display& display) {
   aura::RootWindow* root = root_windows_[display.id()];
   DCHECK(root);
   // Primary monitor should never be removed by MonitorManager.
   DCHECK(root != Shell::GetPrimaryRootWindow());
   // Monitor for root window will be deleted when the Primary RootWindow
   // is deleted by the Shell.
   if (root != Shell::GetPrimaryRootWindow()) {
@@ skipping 14 matching lines @@
           switches::kAshExtendedDesktop);
 }
 
 // static
 void MonitorController::SetExtendedDesktopEnabled(bool enabled) {
   extended_desktop_enabled = enabled;
 }
 
 // static
 bool MonitorController::IsVirtualScreenCoordinatesEnabled() {
-  return virtual_screen_coordinates_enabled ||
-      CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kAshVirtualScreenCoordinates);
+  return IsExtendedDesktopEnabled() &&
+      (virtual_screen_coordinates_enabled ||
+       CommandLine::ForCurrentProcess()->HasSwitch(
+           switches::kAshVirtualScreenCoordinates));
 }
 
 // static
 void MonitorController::SetVirtualScreenCoordinatesEnabled(bool enabled) {
   virtual_screen_coordinates_enabled = enabled;
 }
 
 aura::RootWindow* MonitorController::AddRootWindowForDisplay(
     const gfx::Display& display) {
   aura::RootWindow* root = aura::Env::GetInstance()->monitor_manager()->
       CreateRootWindowForMonitor(display);
   root_windows_[display.id()] = root;
   // Confine the cursor within the window if
   // 1) Extended desktop is enabled or
   // 2) the display is primary monitor and the host window
   // is set to be fullscreen (this is old behavior).
   if (IsExtendedDesktopEnabled() ||
       (aura::MonitorManager::use_fullscreen_host_window() &&
        display.id() == 0)) {
     root->ConfineCursorToWindow();
   }
   return root;
 }
 
+void MonitorController::UpdateDisplayBoundsForLayout() {
+  if (!IsVirtualScreenCoordinatesEnabled() ||
+      gfx::Screen::GetNumDisplays() <= 1) {
+    return;
+  }
+  DCHECK_EQ(2, gfx::Screen::GetNumDisplays());
+  aura::MonitorManager* monitor_manager =
+      aura::Env::GetInstance()->monitor_manager();
+  const gfx::Rect& primary_bounds = monitor_manager->GetDisplayAt(0)->bounds();
+  gfx::Display* secondary_display = monitor_manager->GetDisplayAt(1);
+  const gfx::Rect& secondary_bounds = secondary_display->bounds();
+  gfx::Point new_secondary_origin = primary_bounds.origin();
+
+  // TODO(oshima|mukai): Implement more flexible layout.
+  switch (secondary_display_layout_) {
+    case TOP:
+      new_secondary_origin.Offset(0, -secondary_bounds.height());
+      break;
+    case RIGHT:
+      new_secondary_origin.Offset(primary_bounds.width(), 0);
+      break;
+    case BOTTOM:
+      new_secondary_origin.Offset(0, primary_bounds.height());
+      break;
+    case LEFT:
+      new_secondary_origin.Offset(-secondary_bounds.width(), 0);
+      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