Plumb maxTouchPoints for AuraX11

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>
@@ skipping 11 matching lines @@
 #include "ui/events/x/device_list_cache_x.h"
 #include "ui/gfx/x/x11_types.h"
 
 namespace ui {
 
 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;
 
   XDisplay* display = gfx::GetXDisplay();
   UpdateDeviceList(display);
 
   CommandLine* cmdline = CommandLine::ForCurrentProcess();
   touch_events_disabled_ = cmdline->HasSwitch(switches::kTouchEvents) &&
       cmdline->GetSwitchValueASCII(switches::kTouchEvents) ==
@@ skipping 31 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();
+  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 =
       DeviceListCacheX::GetInstance()->GetXDeviceList(display);
@@ skipping 32 matching lines @@
       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;
             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;
     }
   }
 }
 
 bool TouchFactory::ShouldProcessXI2Event(XEvent* xev) {
@@ skipping 85 matching lines @@
 }
 
 void TouchFactory::ReleaseSlotForTrackingID(uint32 tracking_id) {
   id_generator_.ReleaseNumber(tracking_id);
 }
 
 bool TouchFactory::IsTouchDevicePresent() {
   return !touch_events_disabled_ && touch_device_available_;
 }
 
+int TouchFactory::GetMaxTouchPoints() const {
+  return max_touch_points_;
+}
+
 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());
     touch_device_lookup_[*iter] = true;
     touch_device_list_[*iter] = true;
   }
   touch_device_available_ = true;
   touch_events_disabled_ = false;
 }
 
 }  // namespace ui