touch: Change how touch-screen capability is processed.

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 <X11/Xatom.h>
 #include <X11/cursorfont.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
@@ skipping 12 matching lines @@
 #include "ui/events/devices/x11/device_list_cache_x11.h"
 #include "ui/events/event_switches.h"
 #include "ui/gfx/x/x11_types.h"
 
 namespace ui {
 
 TouchFactory::TouchFactory()
     : pointer_device_lookup_(),
       touch_events_disabled_(false),
       touch_device_list_(),
-      max_touch_points_(-1),
       virtual_core_keyboard_device_(-1),
       id_generator_(0) {
   if (!DeviceDataManagerX11::GetInstance()->IsXInput2Available())
     return;
 
   XDisplay* display = gfx::GetXDisplay();
   UpdateDeviceList(display);
 
   base::CommandLine* cmdline = base::CommandLine::ForCurrentProcess();
   touch_events_disabled_ = cmdline->HasSwitch(switches::kTouchEvents) &&
@@ skipping 32 matching lines @@
     }
     ui::TouchFactory::GetInstance()->SetTouchDeviceList(device_ids);
   }
 }
 
 void TouchFactory::UpdateDeviceList(Display* display) {
   // Detect touch devices.
   touch_device_lookup_.reset();
   touch_device_list_.clear();
   touchscreen_ids_.clear();
-  max_touch_points_ = -1;
 
   // 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 =
       DeviceListCacheX11::GetInstance()->GetXDeviceList(display);
   Atom xi_touchscreen = XInternAtom(display, XI_TOUCHSCREEN, false);
@@ skipping 27 matching lines @@
     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;
             touch_device_list_[devinfo->deviceid] = true;
-            if (tci->num_touches > 0 && tci->num_touches > max_touch_points_)
-              max_touch_points_ = tci->num_touches;
           }
         }
       }
       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) {
@@ skipping 115 matching lines @@
 void TouchFactory::ReleaseSlotForTrackingID(uint32 tracking_id) {
   tracking_id_refcounts_[tracking_id]--;
   if (tracking_id_refcounts_[tracking_id] == 0)
     id_generator_.ReleaseNumber(tracking_id);
 }
 
 bool TouchFactory::IsTouchDevicePresent() {
   return !touch_events_disabled_ && touch_device_lookup_.any();
 }
 
-int TouchFactory::GetMaxTouchPoints() const {
-  return max_touch_points_;
-}
-
 void TouchFactory::ResetForTest() {
   pointer_device_lookup_.reset();
   touch_device_lookup_.reset();
   touch_events_disabled_ = false;
   touch_device_list_.clear();
   touchscreen_ids_.clear();
   tracking_id_refcounts_.clear();
-  max_touch_points_ = -1;
   id_generator_.ResetForTest();
 }
 
 void TouchFactory::SetTouchDeviceForTest(
     const std::vector<unsigned int>& devices) {
   touch_device_lookup_.reset();
   touch_device_list_.clear();
   for (std::vector<unsigned int>::const_iterator iter = devices.begin();
        iter != devices.end(); ++iter) {
     DCHECK(*iter < touch_device_lookup_.size());
@@ skipping 45 matching lines @@
       if (ptr[0] || ptr[1])
         touchscreen_ids_.insert(std::make_pair(ptr[0], ptr[1]));
     }
     XFree(prop_return);
   }
 
   XCloseDevice(display, device);
 }
 
 }  // namespace ui