Use persistent ID/names for displays.

ui/base/x/x11_util.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.
 
 // This file defines utility functions for X11 (Linux only). This code has been
 // ported from XCB since we can't use XCB on Ubuntu while its 32-bit support
 // remains woefully incomplete.
 
 #include "ui/base/x/x11_util.h"
 
 #include <sys/ipc.h>
 #include <sys/shm.h>
 
 #include <list>
 #include <map>
 #include <vector>
 
+#include <X11/extensions/Xrandr.h>
+#include <X11/extensions/randr.h>
+
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
+#include "base/sys_byteorder.h"
 #include "base/threading/thread.h"
 #include "ui/base/keycodes/keyboard_code_conversion_x.h"
 #include "ui/base/x/x11_util_internal.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
 #if defined(OS_FREEBSD)
 #include <sys/sysctl.h>
 #include <sys/types.h>
 #endif
@@ skipping 258 matching lines @@
   }
 
   ~XButtonMap() {}
 
   unsigned char map_[256];
   int count_;
 
   DISALLOW_COPY_AND_ASSIGN(XButtonMap);
 };
 
+bool IsRandRAvailable(Display* display) {
+  int randr_version_major = 0;
+  int randr_version_minor = 0;
+  return XRRQueryVersion(
+      display, &randr_version_major, &randr_version_minor) == Success;
+}
+
 }  // namespace
 
 bool XDisplayExists() {
   return (GetXDisplay() != NULL);
 }
 
 Display* GetXDisplay() {
   return base::MessagePumpForUI::GetDefaultXDisplay();
 }
 
@@ skipping 665 matching lines @@
 }
 
 void FreePicture(Display* display, XID picture) {
   XRenderFreePicture(display, picture);
 }
 
 void FreePixmap(Display* display, XID pixmap) {
   XFreePixmap(display, pixmap);
 }
 
+bool GetOutputDeviceHandles(std::vector<XID>* outputs) {
+  DCHECK(outputs);
+  outputs->clear();
+
+  Display* display = GetXDisplay();
+  if (!display)
+    return false;
+
+  if (!IsRandRAvailable(display))
+    return false;
+
+  Window root_window = DefaultRootWindow(display);
+  XRRScreenResources* screen_resources =
+      XRRGetScreenResources(display, root_window);
+  for (int i = 0; i < screen_resources->noutput; ++i)
+    outputs->push_back(screen_resources->outputs[i]);
+  XRRFreeScreenResources(screen_resources);
+  return true;
+}
+
+bool GetOutputDeviceData(XID output,
+                         uint16* manufacturer_id,
+                         uint32* serial_number,
+                         std::string* human_readable_name) {
+  DCHECK(manufacturer_id);
+  DCHECK(serial_number);
+  DCHECK(human_readable_name);
+
+  Display* display = GetXDisplay();
+  if (!display)
+    return false;
+
+  if (!IsRandRAvailable(display))
+    return false;
+
+  Atom edid_property = GetAtom(RR_PROPERTY_RANDR_EDID);
+  bool has_edid_property = false;
+  int num_properties = 0;
+  Atom* properties = XRRListOutputProperties(display, output, &num_properties);
+  for (int i = 0; i < num_properties; ++i) {
+    if (properties[i] == edid_property) {
+      has_edid_property = true;
+      break;
+    }
+  }
+  XFree(properties);
+  if (!has_edid_property)
+    return false;
+
+  Atom actual_type;
+  int actual_format;
+  unsigned long nitems;
+  unsigned long bytes_after;
+  unsigned char *prop;
+  XRRGetOutputProperty(display, output, edid_property, 0, 128, false, false,
+                       AnyPropertyType, &actual_type, &actual_format, &nitems,
+                       &bytes_after, &prop);
+  DCHECK(actual_type == XA_INTEGER);
+  DCHECK(actual_format == 8);
+
+  // See http://en.wikipedia.org/wiki/Extended_display_identification_data
+  // for the details of EDID data format.  We use the following data:
+  //   bytes 8-9: manufacturer EISA ID, in big-endian
+  //   bytes 12-15: represents serial number, in little-endian
+  //   bytes 54-125: four descriptors (18-bytes each) which may contain
+  //     the display name.
+  const int kManufacturerOffset = 8;
+  const int kSerialNumberOffset = 12;
+  const int kDescriptorOffset = 54;
+  const int kNumDescriptors = 4;
+  const int kDescriptorLength = 18;
+
+  *manufacturer_id = *reinterpret_cast<uint16*>(prop + kManufacturerOffset);
+#if defined(ARCH_CPU_LITTLE_ENDIAN)
+  *manufacturer_id = base::ByteSwap(*manufacturer_id);
+#endif
+  *serial_number = base::ByteSwapToLE32(
+      *reinterpret_cast<uint32*>(prop + kSerialNumberOffset));
+
+  std::string name_candidate;
+  human_readable_name->clear();
+  for (int i = 0; i < kNumDescriptors; ++i) {
+    unsigned char* desc_buf = prop + kDescriptorOffset + i * kDescriptorLength;
+    // If the descriptor contains the display name, it has the following
+    // structure:
+    //   bytes 0-2, 4: \0
+    //   byte 3: \xfc for "Monitor name", \xfe for "Unspecified text"
+    //   bytes 5-17: text data, ending with \r, padding with spaces
+    // we should check bytes 0-2 and 4, since it may have other values in
+    // case that the descriptor contains other type of data.
+    if (desc_buf[0] == 0 && desc_buf[1] == 0 && desc_buf[2] == 0 &&
+        desc_buf[4] == 0) {
+      if (desc_buf[3] == 0xfc) {

[marcheu, 2012/08/14 21:29:53]

maybe replace 0xfc with kMonitorNameDescriptor or something similar

[Jun Mukai, 2012/08/15 05:14:09]

Done.

+        std::string found_name(
+            reinterpret_cast<char*>(desc_buf + 5), kDescriptorLength - 5);
+        TrimWhitespaceASCII(found_name, TRIM_TRAILING, human_readable_name);
+        break;
+      } else if (desc_buf[3] == 0xfe && name_candidate.empty()) {

[marcheu, 2012/08/14 21:29:53]

Here maybe replace 0xfe with kUnspecifiedTextDescriptor or something similar

[Jun Mukai, 2012/08/15 05:14:09]

Done.

+        // Sometimes the default display of a laptop device doesn't have "FC"
+        // ("Monitor name") descriptor, but has some human readable text with
+        // "FE" ("Unspecified text"). Thus here uses this value as the fallback
+        // of the lack of "FC". Note that multiple descriptors may have "FE",
+        // and the first one is the monitor name.
+        std::string found_name(
+            reinterpret_cast<char*>(desc_buf + 5), kDescriptorLength - 5);
+        TrimWhitespaceASCII(found_name, TRIM_TRAILING, &name_candidate);
+      }
+    }
+  }

[marcheu, 2012/08/14 21:29:53]

At this point I'd probably sanity check the string. At least something like a
simple check for isascii() + return false will filter the worst ones.

[Jun Mukai, 2012/08/15 05:14:09]

Done.  Using isprint() too.

+  if (human_readable_name->empty() && !name_candidate.empty())
+    *human_readable_name = name_candidate;
+
+  XFree(prop);
+  return true;
+}
+
+
 bool GetWindowManagerName(std::string* wm_name) {
   DCHECK(wm_name);
   int wm_window = 0;
   if (!GetIntProperty(GetX11RootWindow(),
                       "_NET_SUPPORTING_WM_CHECK",
                       &wm_window)) {
     return false;
   }
 
   // It's possible that a window manager started earlier in this X session left
@@ skipping 278 matching lines @@
       << "request_code " << static_cast<int>(error_event.request_code) << ", "
       << "minor_code " << static_cast<int>(error_event.minor_code)
       << " (" << request_str << ")";
 }
 
 // ----------------------------------------------------------------------------
 // End of x11_util_internal.h
 
 
 }  // namespace ui