Include external touchscreen vid/pid in UMA hardware profile

ui/events/x/touch_factory_x11.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 "ui/events/x/touch_factory_x11.h"
 
 #include <X11/cursorfont.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/XIproto.h>
+#include <X11/Xatom.h>

[sadrul, 2013/12/12 19:28:59]

sort

[tdresser, 2013/12/12 21:24:22]

Done.

 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "ui/events/event_switches.h"
 #include "ui/events/x/device_data_manager.h"
 #include "ui/events/x/device_list_cache_x.h"
 #include "ui/gfx/x/x11_types.h"
 
 namespace ui {
 
+const char* TouchFactory::kDeviceProductIdString = "Device Product ID";
+
 TouchFactory::TouchFactory()
     : pointer_device_lookup_(),
       touch_device_available_(false),
       touch_events_disabled_(false),
       touch_device_list_(),
       max_touch_points_(-1),
       id_generator_(0) {
   if (!DeviceDataManager::GetInstance()->IsXInput2Available())
     return;
 
@@ skipping 37 matching lines @@
     }
     ui::TouchFactory::GetInstance()->SetTouchDeviceList(device_ids);
   }
 }
 
 void TouchFactory::UpdateDeviceList(Display* display) {
   // Detect touch devices.
   touch_device_available_ = false;
   touch_device_lookup_.reset();
   touch_device_list_.clear();
+  touchscreen_ids_.clear();
   max_touch_points_ = -1;
 
 #if !defined(USE_XI2_MT)
   // NOTE: The new API for retrieving the list of devices (XIQueryDevice) does
   // not provide enough information to detect a touch device. As a result, the
   // old version of query function (XListInputDevices) is used instead.
   // If XInput2 is not supported, this will return null (with count of -1) so
   // we assume there cannot be any touch devices.
   // With XI2.1 or older, we allow only single touch devices.
   XDeviceList dev_list =
@@ skipping 26 matching lines @@
   pointer_device_lookup_.reset();
   XIDeviceList xi_dev_list =
       DeviceListCacheX::GetInstance()->GetXI2DeviceList(display);
   for (int i = 0; i < xi_dev_list.count; i++) {
     XIDeviceInfo* devinfo = xi_dev_list.devices + i;
     if (devinfo->use == XIFloatingSlave || devinfo->use == XIMasterPointer) {
 #if defined(USE_XI2_MT)
       for (int k = 0; k < devinfo->num_classes; ++k) {
         XIAnyClassInfo* xiclassinfo = devinfo->classes[k];
         if (xiclassinfo->type == XITouchClass) {
+          CacheTouchscreenIds(display, devinfo->deviceid);
           XITouchClassInfo* tci =
               reinterpret_cast<XITouchClassInfo *>(xiclassinfo);
           // Only care direct touch device (such as touch screen) right now
           if (tci->mode == XIDirectTouch) {
             touch_device_lookup_[devinfo->deviceid] = true;

[sadrul, 2013/12/12 19:28:59]

It should be in here, I think?

[tdresser, 2013/12/12 21:24:22]

Done.

             touch_device_list_[devinfo->deviceid] = true;
             touch_device_available_ = true;
             if (tci->num_touches > 0 && tci->num_touches > max_touch_points_)
               max_touch_points_ = tci->num_touches;
           }
         }
       }
 #endif
       pointer_device_lookup_[devinfo->deviceid] = true;
     }
@@ skipping 116 matching lines @@
 
 void TouchFactory::SetPointerDeviceForTest(
     const std::vector<unsigned int>& devices) {
   pointer_device_lookup_.reset();
   for (std::vector<unsigned int>::const_iterator iter = devices.begin();
        iter != devices.end(); ++iter) {
     pointer_device_lookup_[*iter] = true;
   }
 }
 
+void TouchFactory::CacheTouchscreenIds(Display* display, int id) {

[sadrul, 2013/12/12 19:28:59]

Call this XID device_id

[tdresser, 2013/12/12 21:24:22]

Done.

+  XDevice* device = XOpenDevice(display, id);
+  Atom actual_type_return;
+  int actual_format_return;
+  unsigned long nitems_return;
+  unsigned long bytes_after_return;
+  unsigned char *prop_return;
+

[sadrul, 2013/12/12 19:28:59]

define kDeviceProductIdString in here.

(For X11 atoms, the atom name is the proper identifer, not the int-id (e.g. it's
257 on my workstation, 250 on my laptop etc.))

[tdresser, 2013/12/12 21:24:22]

Done.

+  Atom device_product_id_atom =
+      XInternAtom(display, kDeviceProductIdString, false);
+
+  if (XGetDeviceProperty(display, device, device_product_id_atom, 0, 2,
+                         False, XA_INTEGER, &actual_type_return,
+                         &actual_format_return, &nitems_return,
+                         &bytes_after_return, &prop_return) == Success) {
+    // XA_INTEGER, which results in an actual_format_return of 32, implies that
+    // the returned data is an array of longs. See the description of
+    // |prop_return| in `man XGetDeviceProperty` for details.
+    long* ptr = reinterpret_cast<long*>(prop_return);
+
+    // Internal displays will have a vid and pid of 0. Ignore them.
+    // ptr[0] is the pid, and ptr[1] is the vid.
+    if (ptr[0] || ptr[1])
+      touchscreen_ids_.insert(std::make_pair(ptr[0], ptr[1]));
+    XFree(prop_return);
+  }
+
+  XCloseDevice(display, device);
+}
+
 }  // namespace ui