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

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"
@@ skipping 17 matching lines @@
 
 #if defined(OS_CHROMEOS)
 #include "base/chromeos/chromeos_version.h"
 #endif
 
 namespace ash {
 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.
 const int kMaxValidOffset = 10000;
 
 // 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,
@@ skipping 100 matching lines @@
 
 // static
 void DisplayLayout::RegisterJSONConverter(
     base::JSONValueConverter<DisplayLayout>* converter) {
   converter->RegisterCustomField<Position>(
       "position", &DisplayLayout::position, &GetPositionFromString);
   converter->RegisterIntField("offset", &DisplayLayout::offset);
 }
 
 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);
 }
 
 DisplayController::~DisplayController() {
   GetDisplayManager()->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 =
         GetRootWindowController(it->second);
     DCHECK(controller);
     delete controller;
   }
 }
 // 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() {
   const gfx::Display* primary_candidate = GetDisplayManager()->GetDisplayAt(0);
 #if defined(OS_CHROMEOS)
   if (base::chromeos::IsRunningOnChromeOS()) {
     internal::MultiDisplayManager* display_manager = GetDisplayManager();
     // On ChromeOS device, root windows are stacked vertically, and
     // default primary is the one on top.
     int count = display_manager->GetNumDisplays();
     int y = primary_candidate->bounds_in_pixel().y();
     for (int i = 1; i < count; ++i) {
       const gfx::Display* display = display_manager->GetDisplayAt(i);
       if (display_manager->IsInternalDisplayId(display->id())) {
         primary_candidate = display;
         break;
       } else if (display->bounds_in_pixel().y() < y) {
         primary_candidate = display;
         y = display->bounds_in_pixel().y();
       }
     }
   }
 #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();
 }
 
 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);
     }
   }
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kAshSecondaryDisplayLayout)) {
     std::string value = command_line->GetSwitchValueASCII(
         switches::kAshSecondaryDisplayLayout);
     char layout;
     int offset;
@@ skipping 15 matching lines @@
 void DisplayController::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void DisplayController::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(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) {
   return root_windows_[id];
 }
 
 void DisplayController::CloseChildWindows() {
   for (std::map<int64, aura::RootWindow*>::const_iterator it =
            root_windows_.begin(); it != root_windows_.end(); ++it) {
     aura::RootWindow* root_window = it->second;
@@ skipping 81 matching lines @@
   DCHECK(new_primary_display.is_valid());
   DCHECK(display_manager->IsActiveDisplay(new_primary_display));
 
   if (!new_primary_display.is_valid() ||
       !display_manager->IsActiveDisplay(new_primary_display)) {
     LOG(ERROR) << "Invalid or non-existent display is requested:"
                << new_primary_display.ToString();
     return;
   }
 
-  if (primary_display->id() == new_primary_display.id() ||
+  if (primary_display_id == new_primary_display.id() ||
       root_windows_.size() < 2) {
     return;
   }
 
   aura::RootWindow* non_primary_root = root_windows_[new_primary_display.id()];
   LOG_IF(ERROR, !non_primary_root)
       << "Unknown display is requested in SetPrimaryDisplay: id="
       << new_primary_display.id();
   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);
 
   root_windows_[new_primary_display.id()] = primary_root;
   primary_root->SetProperty(internal::kDisplayIdKey, new_primary_display.id());
 
   root_windows_[old_primary_display.id()] = non_primary_root;
   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(
       display_manager->GetDisplayNameFor(old_primary_display),
       GetLayoutForDisplay(new_primary_display).Invert());
 
   // 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);
   GetDisplayManager()->set_force_bounds_changed(false);
 }
 
 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());
 }
 
 void DisplayController::OnDisplayAdded(const gfx::Display& display) {
   DCHECK(!root_windows_.empty());
   NotifyDisplayConfigurationChanging();
   aura::RootWindow* root = AddRootWindowForDisplay(display);
   Shell::GetInstance()->InitRootWindowForSecondaryDisplay(root);
   UpdateDisplayBoundsForLayout();
 }
 
 void DisplayController::OnDisplayRemoved(const gfx::Display& display) {
   aura::RootWindow* root_to_delete = root_windows_[display.id()];
   DCHECK(root_to_delete) << display.ToString();
   NotifyDisplayConfigurationChanging();
 
   // Display for root window will be deleted when the Primary RootWindow
   // is deleted by the Shell.
   root_windows_.erase(display.id());
 
   // 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);
   DCHECK(controller);
   controller->MoveWindowsTo(GetPrimaryRootWindow());
   // Delete most of root window related objects, but don't delete
   // root window itself yet because the stak may be using it.
   controller->Shutdown();
   MessageLoop::current()->DeleteSoon(FROM_HERE, controller);
 }
@@ skipping 12 matching lines @@
     root->ConfineCursorToWindow();
 #endif
   return root;
 }
 
 void DisplayController::UpdateDisplayBoundsForLayout() {
   if (gfx::Screen::GetNumDisplays() <= 1)
     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();
   gfx::Point new_secondary_origin = primary_bounds.origin();
 
   const DisplayLayout& layout = GetLayoutForDisplay(*secondary_display);
   DisplayLayout::Position position = layout.position;
 
   // Ignore the offset in case the secondary display doesn't share edges with
   // the primary display.
@@ skipping 27 matching lines @@
   secondary_display->set_bounds(
       gfx::Rect(new_secondary_origin, secondary_bounds.size()));
   secondary_display->UpdateWorkAreaFromInsets(insets);
 }
 
 void DisplayController::NotifyDisplayConfigurationChanging() {
   FOR_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanging());
 }
 
 }  // namespace ash