Fix software mirror mode on Ozone part 2/2

ui/events/devices/x11/device_data_manager_x11.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/devices/x11/device_data_manager_x11.h"
 
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 
@@ skipping 93 matching lines @@
 // types.
 const int kCMTDataTypeStart = ui::DeviceDataManagerX11::DT_CMT_SCROLL_X;
 const int kCMTDataTypeEnd = ui::DeviceDataManagerX11::DT_CMT_FINGER_COUNT;
 const int kTouchDataTypeStart = ui::DeviceDataManagerX11::DT_TOUCH_MAJOR;
 const int kTouchDataTypeEnd = ui::DeviceDataManagerX11::DT_TOUCH_RAW_TIMESTAMP;
 
 namespace ui {
 
 namespace {
 
-bool KeyboardDeviceHasId(const ui::KeyboardDevice keyboard, unsigned int id) {
-  return keyboard.id == id;
+bool DeviceHasId(const ui::InputDevice input_device, unsigned int id) {
+  return input_device.id == id;
 }
 
 }  // namespace
 
 bool DeviceDataManagerX11::IsCMTDataType(const int type) {
   return (type >= kCMTDataTypeStart) && (type <= kCMTDataTypeEnd);
 }
 
 bool DeviceDataManagerX11::IsTouchDataType(const int type) {
   return (type >= kTouchDataTypeStart) && (type <= kTouchDataTypeEnd);
@@ skipping 534 matching lines @@
     valuator_lookup_[deviceid][j] = valuator_count_[deviceid];
     data_type_lookup_[deviceid][valuator_count_[deviceid]] = j;
     valuator_min_[deviceid][j] = min_value;
     valuator_max_[deviceid][j] = max_value;
     valuator_count_[deviceid]++;
   }
 }
 
 bool DeviceDataManagerX11::TouchEventNeedsCalibrate(
     unsigned int touch_device_id) const {
-#if defined(OS_CHROMEOS) && defined(USE_X11)
-  int64 touch_display_id = GetDisplayForTouchDevice(touch_device_id);
-  if (base::SysInfo::IsRunningOnChromeOS() &&
-      touch_display_id == gfx::Display::InternalDisplayId()) {
-    return true;
-  }
-#endif  // defined(OS_CHROMEOS) && defined(USE_X11)
+#if defined(OS_CHROMEOS)
+  if (!base::SysInfo::IsRunningOnChromeOS())
+    return false;
+
+  const std::vector<TouchscreenDevice>& touch_devices =
+      ui::DeviceDataManager::GetInstance()->touchscreen_devices();
+  std::vector<TouchscreenDevice>::const_iterator it =
+      std::find_if(touch_devices.begin(), touch_devices.end(),
+                   std::bind2nd(std::ptr_fun(&DeviceHasId), touch_device_id));
+  return it != touch_devices.end() && it->type == INPUT_DEVICE_INTERNAL;
+#endif  // defined(OS_CHROMEOS)
   return false;
 }
 
 void DeviceDataManagerX11::SetDisabledKeyboardAllowedKeys(
     scoped_ptr<std::set<KeyboardCode> > excepted_keys) {
   DCHECK(!excepted_keys.get() ||
          !blocked_keyboard_allowed_keys_.get());
   blocked_keyboard_allowed_keys_ = excepted_keys.Pass();
 }
 
 void DeviceDataManagerX11::DisableDevice(unsigned int deviceid) {
   blocked_devices_.set(deviceid, true);
   // TODO(rsadam@): Support blocking touchscreen devices.
   std::vector<KeyboardDevice> keyboards = keyboard_devices();
   std::vector<KeyboardDevice>::iterator it =
       std::find_if(keyboards.begin(),
                    keyboards.end(),
-                   std::bind2nd(std::ptr_fun(&KeyboardDeviceHasId), deviceid));
+                   std::bind2nd(std::ptr_fun(&DeviceHasId), deviceid));
   if (it != std::end(keyboards)) {
     blocked_keyboards_.insert(
         std::pair<unsigned int, KeyboardDevice>(deviceid, *it));
     keyboards.erase(it);
     DeviceDataManager::OnKeyboardDevicesUpdated(keyboards);
   }
 }
 
 void DeviceDataManagerX11::EnableDevice(unsigned int deviceid) {
   blocked_devices_.set(deviceid, false);
@@ skipping 28 matching lines @@
   return blocked_devices_.test(xievent->sourceid);
 }
 
 void DeviceDataManagerX11::OnKeyboardDevicesUpdated(
     const std::vector<KeyboardDevice>& devices) {
   std::vector<KeyboardDevice> keyboards(devices);
   for (std::map<unsigned int, KeyboardDevice>::iterator blocked_iter =
            blocked_keyboards_.begin();
        blocked_iter != blocked_keyboards_.end();) {
     // Check if the blocked device still exists in list of devices.
-    std::vector<KeyboardDevice>::iterator it =
-        std::find_if(keyboards.begin(),
-                     keyboards.end(),
-                     std::bind2nd(std::ptr_fun(&KeyboardDeviceHasId),
-                                  (*blocked_iter).first));
+    std::vector<KeyboardDevice>::iterator it = std::find_if(
+        keyboards.begin(), keyboards.end(),
+        std::bind2nd(std::ptr_fun(&DeviceHasId), (*blocked_iter).first));
     // If the device no longer exists, unblock it, else filter it out from our
     // active list.
     if (it == keyboards.end()) {
       blocked_devices_.set((*blocked_iter).first, false);
       blocked_keyboards_.erase(blocked_iter++);
     } else {
       keyboards.erase(it);
       ++blocked_iter;
     }
   }
   // Notify base class of updated list.
   DeviceDataManager::OnKeyboardDevicesUpdated(keyboards);
 }
 
 }  // namespace ui