Use persistent ID/names for displays.

ash/display/multi_display_manager.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/multi_display_manager.h"
 
 #include <string>
 #include <vector>
 
 #include "ash/display/display_controller.h"
 #include "base/command_line.h"
 #include "base/stl_util.h"
 #include "base/string_split.h"
+#include "base/stringprintf.h"
 #include "ui/aura/aura_switches.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/root_window_host.h"
 #include "ui/aura/window_property.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/rect.h"
 
+#if defined(USE_X11)
+#include "ui/base/x/x11_util.h"
+#endif
+
 DECLARE_WINDOW_PROPERTY_TYPE(int);
 
 namespace ash {
 namespace internal {
 namespace {
 
 gfx::Display& GetInvalidDisplay() {
   static gfx::Display* invalid_display = new gfx::Display();
   return *invalid_display;
 }
 
 }  // namespace
 
 using aura::RootWindow;
 using aura::Window;
 using std::string;
 using std::vector;
 
-DEFINE_WINDOW_PROPERTY_KEY(int, kDisplayIdKey, -1);
+DEFINE_WINDOW_PROPERTY_KEY(int64, kDisplayIdKey, -1);
 
 MultiDisplayManager::MultiDisplayManager() {
   Init();
 }
 
 MultiDisplayManager::~MultiDisplayManager() {
 }
 
 // static
 void MultiDisplayManager::AddRemoveDisplay() {
@@ skipping 47 matching lines @@
       NotifyBoundsChanged(current_display);
     }
   }
 
   if (displays_.size() < new_displays.size()) {
     // New displays added
     for (size_t i = min; i < new_displays.size(); ++i) {
       const gfx::Display& new_display = new_displays[i];
       displays_.push_back(gfx::Display(new_display.id()));
       gfx::Display& display = displays_.back();
-      // Force the primary display's ID to be 0.
-      if (i == 0)
-        display.set_id(0);
       display.SetScaleAndBounds(new_display.device_scale_factor(),
                                 new_display.bounds_in_pixel());
       NotifyDisplayAdded(display);
     }
   } else {
     // Displays are removed. We keep the display for the primary
     // display (at index 0) because it needs the display information
     // even if it doesn't exit.
     while (displays_.size() > new_displays.size() && displays_.size() > 1) {
       Displays::reverse_iterator iter = displays_.rbegin();
@@ skipping 62 matching lines @@
     int area = intersect.width() * intersect.height();
     if (area > max) {
       max = area;
       matching = &(*iter);
     }
   }
   // Fallback to the primary display if there is no matching display.
   return matching ? *matching : displays_[0];
 }
 
+std::string MultiDisplayManager::GetDisplayNameAt(size_t index) {
+#if defined(USE_X11)
+  gfx::Display* display = GetDisplayAt(index);
+  std::vector<XID> outputs;
+  if (display && display->id() != -1 &&
+      ui::GetOutputDeviceHandles(&outputs)) {
+    for (size_t i = 0; i < outputs.size(); ++i) {
+      uint16 manufacturer_id = 0;
+      uint32 serial_number = 0;
+      std::string name;
+      if (ui::GetOutputDeviceData(
+              outputs[i], &manufacturer_id, &serial_number, &name) &&
+          display->id() ==
+          gfx::Display::GetID(manufacturer_id, serial_number)) {
+        return name;
+      }
+    }
+  }
+#endif
+
+  return base::StringPrintf("Display %d", static_cast<int>(index + 1));
+}
+
 void MultiDisplayManager::OnRootWindowResized(const aura::RootWindow* root,
                                               const gfx::Size& old_size) {
   if (!use_fullscreen_host_window()) {
     gfx::Display& display = FindDisplayForRootWindow(root);
     display.SetSize(root->GetHostSize());
     NotifyBoundsChanged(display);
   }
 }
 
 void MultiDisplayManager::Init() {
   // TODO(oshima): Move this logic to DisplayChangeObserver.
   const string size_str = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
       switches::kAuraHostWindowSize);
   vector<string> parts;
   base::SplitString(size_str, ',', &parts);
   for (vector<string>::const_iterator iter = parts.begin();
        iter != parts.end(); ++iter) {
     AddDisplayFromSpec(*iter);
   }
   if (displays_.empty())
     AddDisplayFromSpec(std::string() /* default */);
-  // Force the 1st display to be the primary display (id == 0).
-  displays_[0].set_id(0);
 }
 
 void MultiDisplayManager::AddRemoveDisplayImpl() {
   std::vector<gfx::Display> new_displays;
   if (displays_.size() > 1) {
     // Remove if there is more than one display.
     int count = displays_.size() - 1;
     for (Displays::const_iterator iter = displays_.begin(); count-- > 0; ++iter)
       new_displays.push_back(*iter);
   } else {
@@ skipping 53 matching lines @@
     const gfx::Insets insets = display.GetWorkAreaInsets();
     const gfx::Rect& native_bounds = display.bounds_in_pixel();
     display.SetScaleAndBounds(display.device_scale_factor(), native_bounds);
     display.UpdateWorkAreaFromInsets(insets);
   }
   displays_.push_back(display);
 }
 
 }  // namespace internal
 }  // namespace ash