touch: Change how touch-screen capability is processed.

ui/events/platform/x11/x11_hotplug_event_handler.cc

 // Copyright 2014 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/platform/x11/x11_hotplug_event_handler.h"
 
 #include <X11/Xatom.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 
@@ skipping 64 matching lines @@
   Atom label;
   double max;
   double min;
   int mode;
   int number;
 };
 
 // Stores a copy of the XITouchClassInfo values so X11 device processing can
 // happen on a worker thread. This is needed since X11 structs are not copyable.
 struct TouchClassInfo {
-  TouchClassInfo(const XITouchClassInfo& info)
-      : mode(info.mode) {}
+  TouchClassInfo() : mode(0), num_touches(0) {}
+
+  explicit TouchClassInfo(const XITouchClassInfo& info)
+      : mode(info.mode), num_touches(info.num_touches) {}
 
   int mode;
+  int num_touches;
 };
 
 struct DeviceInfo {
   DeviceInfo(const XIDeviceInfo& device, const base::FilePath& path)
       : id(device.deviceid),
         name(device.name),
         use(device.use),
         enabled(device.enabled),
         path(path) {
     for (int i = 0; i < device.num_classes; ++i) {
       switch (device.classes[i]->type) {
         case XIValuatorClass:
           valuator_class_infos.push_back(ValuatorClassInfo(
               *reinterpret_cast<XIValuatorClassInfo*>(device.classes[i])));
           break;
         case XITouchClass:
-          touch_class_infos.push_back(TouchClassInfo(
-              *reinterpret_cast<XITouchClassInfo*>(device.classes[i])));
+          // A device can have at most one XITouchClassInfo. Ref:
+          // http://manpages.ubuntu.com/manpages/saucy/man3/XIQueryDevice.3.html
+          DCHECK(!touch_class_info.mode);
+          touch_class_info = TouchClassInfo(
+              *reinterpret_cast<XITouchClassInfo*>(device.classes[i]));
           break;
         default:
           break;
       }
     }
   }
 
   // Unique device identifier.
   int id;
 
   // Internal device name.
   std::string name;
 
   // Device type (ie: XIMasterPointer)
   int use;
 
   // Specifies if the device is enabled and can send events.
   bool enabled;
 
   // Path to the actual device (ie: /dev/input/eventXX)
   base::FilePath path;
 
   std::vector<ValuatorClassInfo> valuator_class_infos;
 
-  std::vector<TouchClassInfo> touch_class_infos;
+  TouchClassInfo touch_class_info;
 };
 
 // X11 display cache used on worker threads. This is filled on the UI thread and
 // passed in to the worker threads.
 struct DisplayState {
   Atom mt_position_x;
   Atom mt_position_y;
 };
 
 // Returns true if |name| is the name of a known invalid keyboard device. Note,
@@ skipping 121 matching lines @@
         }
       } else if (display_state.mt_position_y == valuator.label) {
         // Ignore Y axis valuator with unexpected properties
         if (valuator.number == 1 && valuator.mode == Absolute &&
             valuator.min == 0.0) {
           max_y = valuator.max;
         }
       }
     }
 
-    for (const TouchClassInfo& info : device_info.touch_class_infos) {
-      is_direct_touch = info.mode == XIDirectTouch;
-    }
+    if (device_info.touch_class_info.mode)
+      is_direct_touch = device_info.touch_class_info.mode == XIDirectTouch;
 
     // Touchscreens should have absolute X and Y axes, and be direct touch
     // devices.
     if (max_x > 0.0 && max_y > 0.0 && is_direct_touch) {
       InputDeviceType type = GetInputDeviceTypeFromPath(device_info.path);
       // |max_x| and |max_y| are inclusive values, so we need to add 1 to get
       // the size.
-      devices.push_back(TouchscreenDevice(
-          device_info.id,
-          type,
-          device_info.name,
-          gfx::Size(max_x + 1, max_y + 1)));
+      devices.push_back(
+          TouchscreenDevice(device_info.id, type, device_info.name,
+                            gfx::Size(max_x + 1, max_y + 1),
+                            device_info.touch_class_info.num_touches));
     }
   }
 
   reply_runner->PostTask(FROM_HERE, base::Bind(callback, devices));
 }
 
 // Called on a worker thread to parse the device information.
 void HandleHotplugEventInWorker(
     const std::vector<DeviceInfo>& devices,
     const DisplayState& display_state,
@@ skipping 52 matching lines @@
   base::WorkerPool::PostTask(FROM_HERE,
                              base::Bind(&HandleHotplugEventInWorker,
                                         device_infos,
                                         display_state,
                                         base::ThreadTaskRunnerHandle::Get(),
                                         callbacks),
                              true /* task_is_slow */);
 }
 
 }  // namespace ui