Add slave touch device to touch_device_lookup_ and touch_device_list_

ui/events/devices/x11/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/devices/x11/touch_factory_x11.h"
 
 #include <stddef.h>
 #include <X11/Xatom.h>
 #include <X11/cursorfont.h>
 #include <X11/extensions/XInput.h>
@@ skipping 56 matching lines @@
         device_ids.push_back(devid);
       else
         DLOG(WARNING) << "Invalid touch-device id: " << dev.as_string();
     }
     ui::TouchFactory::GetInstance()->SetTouchDeviceList(device_ids);
   }
 }
 
 void TouchFactory::UpdateDeviceList(XDisplay* display) {
   // Detect touch devices.
-  touch_device_lookup_.reset();
   touch_device_list_.clear();
   touchscreen_ids_.clear();
 
   if (!DeviceDataManagerX11::GetInstance()->IsXInput2Available())
     return;
 
   // Instead of asking X for the list of devices all the time, let's maintain a
   // list of pointer devices we care about.
   // It should not be necessary to select for slave devices. XInput2 provides
   // enough information to the event callback to decide which slave device
@@ skipping 10 matching lines @@
       DeviceListCacheX11::GetInstance()->GetXI2DeviceList(display);
   for (int i = 0; i < xi_dev_list.count; i++) {
     const XIDeviceInfo& devinfo = xi_dev_list[i];
     if (devinfo.use == XIFloatingSlave || devinfo.use == XIMasterPointer) {
       for (int k = 0; k < devinfo.num_classes; ++k) {
         XIAnyClassInfo* xiclassinfo = devinfo.classes[k];
         if (xiclassinfo->type == XITouchClass) {
           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;
+          if (tci->mode == XIDirectTouch)
             touch_device_list_[devinfo.deviceid] = true;
-          }
         }
       }
       pointer_device_lookup_[devinfo.deviceid] = true;
     } else if (devinfo.use == XIMasterKeyboard) {
       virtual_core_keyboard_device_ = devinfo.deviceid;
     }
 
     if (devinfo.use == XIFloatingSlave || devinfo.use == XISlavePointer) {
       for (int k = 0; k < devinfo.num_classes; ++k) {
         XIAnyClassInfo* xiclassinfo = devinfo.classes[k];
         if (xiclassinfo->type == XITouchClass) {
           XITouchClassInfo* tci =
               reinterpret_cast<XITouchClassInfo*>(xiclassinfo);
           // Only care direct touch device (such as touch screen) right now
           if (tci->mode == XIDirectTouch) {
             CacheTouchscreenIds(devinfo.deviceid);
             if (devinfo.use == XISlavePointer) {
               device_master_id_list_[devinfo.deviceid] = devinfo.attachment;
               // If the slave device is direct touch device, we also set its
               // master device to be touch device.
-              touch_device_lookup_[devinfo.attachment] = true;
               touch_device_list_[devinfo.attachment] = true;
             }
           }
         }
       }
     }
   }
 }
 
 bool TouchFactory::ShouldProcessXI2Event(XEvent* xev) {
@@ skipping 82 matching lines @@
 
   XIEventMask evmask;
   evmask.deviceid = XIAllDevices;
   evmask.mask_len = sizeof(mask);
   evmask.mask = mask;
   XISelectEvents(display, window, &evmask, 1);
   XFlush(display);
 }
 
 void TouchFactory::SetTouchDeviceList(const std::vector<int>& devices) {
-  touch_device_lookup_.reset();
   touch_device_list_.clear();
   for (int deviceid : devices) {
     DCHECK(IsValidDevice(deviceid));
-    touch_device_lookup_[deviceid] = true;
     touch_device_list_[deviceid] = false;
     if (device_master_id_list_.find(deviceid) != device_master_id_list_.end()) {
       // When we set the device through the "--touch-devices" flag to slave
       // touch device, we also set its master device to be touch device.
-      touch_device_lookup_[device_master_id_list_[deviceid]] = true;
       touch_device_list_[device_master_id_list_[deviceid]] = false;
     }
   }
 }
 
 bool TouchFactory::IsValidDevice(int deviceid) const {
-  return (deviceid >= 0) &&
-         (static_cast<size_t>(deviceid) < touch_device_lookup_.size());
+  return deviceid >= 0;

[sadrul, 2016/12/08 17:53:16]

Should we check size of |touch_device_list_| instead?

 }
 
 bool TouchFactory::IsTouchDevice(int deviceid) const {
-  return IsValidDevice(deviceid) ? touch_device_lookup_[deviceid] : false;
+  return IsValidDevice(deviceid) && (touch_device_list_.count(deviceid) > 0);
 }
 
 bool TouchFactory::IsMultiTouchDevice(int deviceid) const {
-  return (IsValidDevice(deviceid) && touch_device_lookup_[deviceid])
+  return IsTouchDevice(deviceid)
              ? touch_device_list_.find(deviceid)->second
              : false;
 }
 
 bool TouchFactory::QuerySlotForTrackingID(uint32_t tracking_id, int* slot) {
   if (!id_generator_.HasGeneratedIDFor(tracking_id))
     return false;
   *slot = static_cast<int>(id_generator_.GetGeneratedID(tracking_id));
   return true;
 }
 
 int TouchFactory::GetSlotForTrackingID(uint32_t tracking_id) {
   return id_generator_.GetGeneratedID(tracking_id);
 }
 
 void TouchFactory::ReleaseSlotForTrackingID(uint32_t tracking_id) {
   id_generator_.ReleaseNumber(tracking_id);
 }
 
 bool TouchFactory::IsTouchDevicePresent() {
-  return touch_screens_enabled_ &&
-      touch_device_lookup_.any();
+  return touch_screens_enabled_ && !touch_device_list_.empty();
 }
 
 void TouchFactory::ResetForTest() {
   pointer_device_lookup_.reset();
-  touch_device_lookup_.reset();
   touch_device_list_.clear();
   touchscreen_ids_.clear();
   id_generator_.ResetForTest();
   SetTouchscreensEnabled(true);
 }
 
 void TouchFactory::SetTouchDeviceForTest(
     const std::vector<int>& devices) {
-  touch_device_lookup_.reset();
   touch_device_list_.clear();
   for (std::vector<int>::const_iterator iter = devices.begin();
        iter != devices.end(); ++iter) {
     DCHECK(IsValidDevice(*iter));
-    touch_device_lookup_[*iter] = true;
     touch_device_list_[*iter] = true;
   }
   SetTouchscreensEnabled(true);
 }
 
 void TouchFactory::SetPointerDeviceForTest(
     const std::vector<int>& devices) {
   pointer_device_lookup_.reset();
   for (std::vector<int>::const_iterator iter = devices.begin();
        iter != devices.end(); ++iter) {
@@ skipping 15 matching lines @@
       std::find_if(touchscreens.begin(), touchscreens.end(),
                    [device_id](const TouchscreenDevice& touchscreen) {
                      return touchscreen.id == device_id;
                    });
   // Internal displays will have a vid and pid of 0. Ignore them.
   if (it != touchscreens.end() && it->vendor_id && it->product_id)
     touchscreen_ids_.insert(std::make_pair(it->vendor_id, it->product_id));
 }
 
 }  // namespace ui