Return primary display if out of bounds point or NULL ponter is passed to gfx::Screen::GeDisplayNea

I also changed to use just id to remember primary display.
Update window resizer test to use screen coordinates.

BUG=151196
TEST=covered by test.

Review URL: https://chromiumcodereview.appspot.com/10961021

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@157866 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 70 insertions, 56 deletions

diff --git a/ash/display/display_controller.cc b/ash/display/display_controller.cc
index 102f0d7..d87252d 100644
--- a/ash/display/display_controller.cc
+++ b/ash/display/display_controller.cc
@@ -35,7 +35,7 @@ namespace {
 
 // Primary display stored in global object as it can be
 // accessed after Shell is deleted.
-gfx::Display* primary_display = NULL;
+int64 primary_display_id = gfx::Display::kInvalidDisplayID;
 
 // The maximum value for 'offset' in DisplayLayout in case of outliers.  Need
 // to change this value in case to support even larger displays.
@@ -156,10 +156,9 @@ void DisplayLayout::RegisterJSONConverter(
 }
 
 DisplayController::DisplayController() {
-  // Reinstantiate display to make sure that tests don't use
+  // Reset primary display to make sure that tests don't use
   // stale display info from previous tests.
-  delete primary_display;
-  primary_display = new gfx::Display();
+  primary_display_id = gfx::Display::kInvalidDisplayID;
 
   GetDisplayManager()->AddObserver(this);
 }
@@ -177,9 +176,9 @@ DisplayController::~DisplayController() {
   }
 }
 // static
-gfx::Display DisplayController::GetPrimaryDisplay() {
-  DCHECK(primary_display);
-  return *primary_display;
+const gfx::Display& DisplayController::GetPrimaryDisplay() {
+  DCHECK_NE(primary_display_id, gfx::Display::kInvalidDisplayID);
+  return GetDisplayManager()->GetDisplayForId(primary_display_id);
 }
 
 void DisplayController::InitPrimaryDisplay() {
@@ -203,9 +202,9 @@ void DisplayController::InitPrimaryDisplay() {
     }
   }
 #endif
-  *primary_display = *primary_candidate;
-  aura::RootWindow* root = AddRootWindowForDisplay(*primary_display);
-  root->SetHostBounds(primary_display->bounds_in_pixel());
+  primary_display_id = primary_candidate->id();
+  aura::RootWindow* root = AddRootWindowForDisplay(*primary_candidate);
+  root->SetHostBounds(primary_candidate->bounds_in_pixel());
   UpdateDisplayBoundsForLayout();
 }
 
@@ -213,7 +212,7 @@ void DisplayController::InitSecondaryDisplays() {
   internal::MultiDisplayManager* display_manager = GetDisplayManager();
   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
     const gfx::Display* display = display_manager->GetDisplayAt(i);
-    if (primary_display->id() != display->id()) {
+    if (primary_display_id != display->id()) {
       aura::RootWindow* root = AddRootWindowForDisplay(*display);
       Shell::GetInstance()->InitRootWindowForSecondaryDisplay(root);
     }
@@ -249,7 +248,7 @@ void DisplayController::RemoveObserver(Observer* observer) {
 
 aura::RootWindow* DisplayController::GetPrimaryRootWindow() {
   DCHECK(!root_windows_.empty());
-  return root_windows_[primary_display->id()];
+  return root_windows_[primary_display_id];
 }
 
 aura::RootWindow* DisplayController::GetRootWindowForDisplayId(int64 id) {
@@ -351,7 +350,7 @@ void DisplayController::SetPrimaryDisplay(
     return;
   }
 
-  if (primary_display->id() == new_primary_display.id() ||
+  if (primary_display_id == new_primary_display.id() ||
       root_windows_.size() < 2) {
     return;
   }
@@ -363,10 +362,10 @@ void DisplayController::SetPrimaryDisplay(
   if (!non_primary_root)
     return;
 
-  gfx::Display old_primary_display = *primary_display;
+  gfx::Display old_primary_display = GetPrimaryDisplay();
 
   // Swap root windows between current and new primary display.
-  aura::RootWindow* primary_root = root_windows_[primary_display->id()];
+  aura::RootWindow* primary_root = root_windows_[primary_display_id];
   DCHECK(primary_root);
   DCHECK_NE(primary_root, non_primary_root);
 
@@ -377,7 +376,7 @@ void DisplayController::SetPrimaryDisplay(
   non_primary_root->SetProperty(internal::kDisplayIdKey,
                                 old_primary_display.id());
 
-  *primary_display = new_primary_display;
+  primary_display_id = new_primary_display.id();
 
   // Update the layout.
   SetLayoutForDisplayName(
@@ -386,7 +385,7 @@ void DisplayController::SetPrimaryDisplay(
 
   // Update the dispay manager with new display info.
   std::vector<gfx::Display> displays;
-  displays.push_back(*primary_display);
+  displays.push_back(GetDisplayManager()->GetDisplayForId(primary_display_id));
   displays.push_back(*GetSecondaryDisplay());
   GetDisplayManager()->set_force_bounds_changed(true);
   GetDisplayManager()->OnNativeDisplaysChanged(displays);
@@ -396,13 +395,11 @@ void DisplayController::SetPrimaryDisplay(
 gfx::Display* DisplayController::GetSecondaryDisplay() {
   internal::MultiDisplayManager* display_manager = GetDisplayManager();
   CHECK_EQ(2U, display_manager->GetNumDisplays());
-  return display_manager->GetDisplayAt(0)->id() == primary_display->id() ?
+  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 (display.id() == primary_display->id())
-    *primary_display = display;
   NotifyDisplayConfigurationChanging();
   UpdateDisplayBoundsForLayout();
   root_windows_[display.id()]->SetHostBounds(display.bounds_in_pixel());
@@ -427,20 +424,21 @@ void DisplayController::OnDisplayRemoved(const gfx::Display& display) {
 
   // When the primary root window's display is removed, move the primary
   // root to the other display.
-  if (primary_display->id() == display.id()) {
+  if (primary_display_id == display.id()) {
     DCHECK_EQ(1U, root_windows_.size());
-    *primary_display = *GetSecondaryDisplay();
+    primary_display_id = GetSecondaryDisplay()->id();
     aura::RootWindow* primary_root = root_to_delete;
 
     // Delete the other root instead.
-    root_to_delete = root_windows_[primary_display->id()];
+    root_to_delete = root_windows_[primary_display_id];
     root_to_delete->SetProperty(internal::kDisplayIdKey, display.id());
 
     // Setup primary root.
-    root_windows_[primary_display->id()] = primary_root;
-    primary_root->SetProperty(internal::kDisplayIdKey, primary_display->id());
+    root_windows_[primary_display_id] = primary_root;
+    primary_root->SetProperty(internal::kDisplayIdKey, primary_display_id);
 
-    OnDisplayBoundsChanged(*primary_display);
+    OnDisplayBoundsChanged(
+        GetDisplayManager()->GetDisplayForId(primary_display_id));
   }
   internal::RootWindowController* controller =
       GetRootWindowController(root_to_delete);
@@ -473,7 +471,7 @@ void DisplayController::UpdateDisplayBoundsForLayout() {
     return;
 
   DCHECK_EQ(2, gfx::Screen::GetNumDisplays());
-  const gfx::Rect& primary_bounds = primary_display->bounds();
+  const gfx::Rect& primary_bounds = GetPrimaryDisplay().bounds();
 
   gfx::Display* secondary_display = GetSecondaryDisplay();
   const gfx::Rect& secondary_bounds = secondary_display->bounds();
diff --git a/ash/display/display_controller.h b/ash/display/display_controller.h
index 8a822ce..0c00cfb 100644
--- a/ash/display/display_controller.h
+++ b/ash/display/display_controller.h
@@ -85,7 +85,7 @@ class ASH_EXPORT DisplayController : public aura::DisplayObserver {
 
   // Gets primary display. This information is stored in global
   // object as this can be accessed after Shell is closed.
-  static gfx::Display GetPrimaryDisplay();
+  static const gfx::Display& GetPrimaryDisplay();
 
   // Initializes primary display.
   void InitPrimaryDisplay();
diff --git a/ash/display/display_controller_unittest.cc b/ash/display/display_controller_unittest.cc
index 6934cdd..97d7707 100644
--- a/ash/display/display_controller_unittest.cc
+++ b/ash/display/display_controller_unittest.cc
@@ -208,11 +208,19 @@ TEST_F(DisplayControllerTest, SwapPrimary) {
       Shell::GetInstance()->launcher()->widget()->GetNativeView();
   EXPECT_TRUE(primary_root->Contains(launcher_window));
   EXPECT_FALSE(secondary_root->Contains(launcher_window));
+  EXPECT_EQ(primary_display.id(),
+            gfx::Screen::GetDisplayNearestPoint(gfx::Point(-100, -100)).id());
+  EXPECT_EQ(primary_display.id(),
+            gfx::Screen::GetDisplayNearestWindow(NULL).id());
 
   // Switch primary and secondary
   display_controller->SetPrimaryDisplay(secondary_display);
   EXPECT_EQ(secondary_display.id(), gfx::Screen::GetPrimaryDisplay().id());
   EXPECT_EQ(primary_display.id(), ScreenAsh::GetSecondaryDisplay().id());
+  EXPECT_EQ(secondary_display.id(),
+            gfx::Screen::GetDisplayNearestPoint(gfx::Point(-100, -100)).id());
+  EXPECT_EQ(secondary_display.id(),
+            gfx::Screen::GetDisplayNearestWindow(NULL).id());
 
   EXPECT_EQ(
       primary_root,
@@ -237,6 +245,10 @@ TEST_F(DisplayControllerTest, SwapPrimary) {
   RunAllPendingInMessageLoop();  // RootWindow is deleted in a posted task.
   EXPECT_EQ(1, gfx::Screen::GetNumDisplays());
   EXPECT_EQ(primary_display.id(), gfx::Screen::GetPrimaryDisplay().id());
+  EXPECT_EQ(primary_display.id(),
+            gfx::Screen::GetDisplayNearestPoint(gfx::Point(-100, -100)).id());
+  EXPECT_EQ(primary_display.id(),
+            gfx::Screen::GetDisplayNearestWindow(NULL).id());
   EXPECT_TRUE(tracker.Contains(primary_root));
   EXPECT_FALSE(tracker.Contains(secondary_root));
   EXPECT_TRUE(primary_root->Contains(launcher_window));
diff --git a/ash/display/multi_display_manager.cc b/ash/display/multi_display_manager.cc
index 21663f0..e428c7c 100644
--- a/ash/display/multi_display_manager.cc
+++ b/ash/display/multi_display_manager.cc
@@ -119,6 +119,16 @@ bool MultiDisplayManager::UpdateWorkAreaOfDisplayNearestWindow(
   return old_work_area != display.work_area();
 }
 
+const gfx::Display& MultiDisplayManager::GetDisplayForId(int64 id) const {
+  for (DisplayList::const_iterator iter = displays_.begin();
+       iter != displays_.end(); ++iter) {
+    if ((*iter).id() == id)
+      return *iter;
+  }
+  VLOG(1) << "display not found for id:" << id;
+  return GetInvalidDisplay();
+}
+
 const gfx::Display& MultiDisplayManager::FindDisplayContainingPoint(
     const gfx::Point& point_in_screen) const {
   for (DisplayList::const_iterator iter = displays_.begin();
@@ -264,7 +274,7 @@ size_t MultiDisplayManager::GetNumDisplays() const {
 const gfx::Display& MultiDisplayManager::GetDisplayNearestWindow(
     const Window* window) const {
   if (!window)
-    return displays_[0];
+    return DisplayController::GetPrimaryDisplay();
   const RootWindow* root = window->GetRootWindow();
   MultiDisplayManager* manager = const_cast<MultiDisplayManager*>(this);
   return root ? manager->FindDisplayForRootWindow(root) : GetInvalidDisplay();
@@ -275,7 +285,7 @@ const gfx::Display& MultiDisplayManager::GetDisplayNearestPoint(
   // Fallback to the primary display if there is no root display containing
   // the |point|.
   const gfx::Display& display = FindDisplayContainingPoint(point);
-  return display.is_valid() ? display : displays_[0];
+  return display.is_valid() ? display : DisplayController::GetPrimaryDisplay();
 }
 
 const gfx::Display& MultiDisplayManager::GetDisplayMatching(
@@ -296,7 +306,7 @@ const gfx::Display& MultiDisplayManager::GetDisplayMatching(
     }
   }
   // Fallback to the primary display if there is no matching display.
-  return matching ? *matching : displays_[0];
+  return matching ? *matching : DisplayController::GetPrimaryDisplay();
 }
 
 std::string MultiDisplayManager::GetDisplayNameFor(
@@ -362,37 +372,28 @@ void MultiDisplayManager::Init() {
 }
 
 void MultiDisplayManager::CycleDisplayImpl() {
+  DCHECK(!displays_.empty());
   std::vector<gfx::Display> new_displays;
-  if (displays_.size() > 1) {
-    // Remove if there is more than one display.
-    int count = displays_.size() - 1;
-    for (DisplayList::const_iterator iter = displays_.begin();
-         count-- > 0; ++iter) {
-      new_displays.push_back(*iter);
-    }
-  } else {
-    // Add if there is only one display.
-    new_displays.push_back(displays_[0]);
+  new_displays.push_back(DisplayController::GetPrimaryDisplay());
+  // Add if there is only one display.
+  if (displays_.size() == 1)
     new_displays.push_back(CreateDisplayFromSpec("100+200-500x400"));
-  }
-  if (new_displays.size())
-    OnNativeDisplaysChanged(new_displays);
+  OnNativeDisplaysChanged(new_displays);
 }
 
 void MultiDisplayManager::ScaleDisplayImpl() {
-  if (displays_.size() > 0) {
-    std::vector<gfx::Display> new_displays;
-    for (DisplayList::const_iterator iter = displays_.begin();
-         iter != displays_.end(); ++iter) {
-      gfx::Display display = *iter;
-      float factor = display.device_scale_factor() == 1.0f ? 2.0f : 1.0f;
-      display.SetScaleAndBounds(
-          factor, gfx::Rect(display.bounds_in_pixel().origin(),
-                            display.size().Scale(factor)));
-      new_displays.push_back(display);
-    }
-    OnNativeDisplaysChanged(new_displays);
+  DCHECK(!displays_.empty());
+  std::vector<gfx::Display> new_displays;
+  for (DisplayList::const_iterator iter = displays_.begin();
+       iter != displays_.end(); ++iter) {
+    gfx::Display display = *iter;
+    float factor = display.device_scale_factor() == 1.0f ? 2.0f : 1.0f;
+    display.SetScaleAndBounds(
+        factor, gfx::Rect(display.bounds_in_pixel().origin(),
+                          display.size().Scale(factor)));
+    new_displays.push_back(display);
   }
+  OnNativeDisplaysChanged(new_displays);
 }
 
 gfx::Display& MultiDisplayManager::FindDisplayForRootWindow(
diff --git a/ash/display/multi_display_manager.h b/ash/display/multi_display_manager.h
index de3fd80..18d952b 100644
--- a/ash/display/multi_display_manager.h
+++ b/ash/display/multi_display_manager.h
@@ -64,6 +64,9 @@ class ASH_EXPORT MultiDisplayManager : public aura::DisplayManager,
   bool UpdateWorkAreaOfDisplayNearestWindow(const aura::Window* window,
                                             const gfx::Insets& insets);
 
+  // Returns display for given |id|;
+  const gfx::Display& GetDisplayForId(int64 id) const;
+
   // Finds the display that contains |point| in screeen coordinates.
   // Returns invalid display if there is no display that can satisfy
   // the condition.