Fix a regression in checking the status of the touch events.

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>
 #include <X11/extensions/XIproto.h>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/sys_info.h"
 #include "ui/events/base_event_utils.h"
 #include "ui/events/devices/x11/device_data_manager_x11.h"
 #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 {
 
+namespace {
+
+bool IsTouchEventsFlagDisabled() {
+  auto* command_line = base::CommandLine::ForCurrentProcess();
+  bool touch_flag_status = command_line->HasSwitch(switches::kTouchEvents) &&
+      command_line->GetSwitchValueASCII(switches::kTouchEvents) ==
+          switches::kTouchEventsDisabled;
+  return touch_flag_status;
+}
+
+}  // namespace
+
+
 TouchFactory::TouchFactory()
     : pointer_device_lookup_(),
       touch_device_list_(),
       virtual_core_keyboard_device_(-1),
-      id_generator_(0) {
+      id_generator_(0),
+      touch_events_disabled_(IsTouchEventsFlagDisabled()) {
   if (!DeviceDataManagerX11::GetInstance()->IsXInput2Available())
     return;
 
   XDisplay* display = gfx::GetXDisplay();
   UpdateDeviceList(display);
 }
 
 TouchFactory::~TouchFactory() {
 }
 
@@ skipping 91 matching lines @@
       }
     }
   }
 }
 
 bool TouchFactory::ShouldProcessXI2Event(XEvent* xev) {
   DCHECK_EQ(GenericEvent, xev->type);
   XIEvent* event = static_cast<XIEvent*>(xev->xcookie.data);
   XIDeviceEvent* xiev = reinterpret_cast<XIDeviceEvent*>(event);
 
+#if defined(OS_CHROMEOS)
+  const bool is_touch_disabled = touch_events_disabled_ &&
+      !GetTouchEventsCrOsMasterSwitch();
+#else
+  const bool is_touch_disabled = touch_events_disabled_;
+#endif  // defined(OS_CHROMEOS)
+
   if (event->evtype == XI_TouchBegin ||
       event->evtype == XI_TouchUpdate ||
       event->evtype == XI_TouchEnd) {
     // Since SetupXI2ForXWindow() selects events from all devices, for a
     // touchscreen attached to a master pointer device, X11 sends two
     // events for each touch: one from the slave (deviceid == the id of
     // the touchscreen device), and one from the master (deviceid == the
     // id of the master pointer device). Instead of processing both
     // events, discard the event that comes from the slave, and only
     // allow processing the event coming from the master.
     // For a 'floating' touchscreen device, X11 sends only one event for
     // each touch, with both deviceid and sourceid set to the id of the
     // touchscreen device.
     bool is_from_master_or_float = touch_device_list_[xiev->deviceid];
     bool is_from_slave_device = !is_from_master_or_float
         && xiev->sourceid == xiev->deviceid;
-    return ui::AreTouchEventsEnabled() &&
+    return !is_touch_disabled &&
            IsTouchDevice(xiev->deviceid) &&
            !is_from_slave_device;
   }
 
   // Make sure only key-events from the virtual core keyboard are processed.
   if (event->evtype == XI_KeyPress || event->evtype == XI_KeyRelease) {
     return (virtual_core_keyboard_device_ < 0) ||
            (virtual_core_keyboard_device_ == xiev->deviceid);
   }
 
   if (event->evtype != XI_ButtonPress &&
       event->evtype != XI_ButtonRelease &&
       event->evtype != XI_Motion) {
     return true;
   }
 
   if (!pointer_device_lookup_[xiev->deviceid])
     return false;
 
-  return IsTouchDevice(xiev->deviceid) ? ui::AreTouchEventsEnabled() : true;
+  return IsTouchDevice(xiev->deviceid) ? !is_touch_disabled : true;
 }
 
 void TouchFactory::SetupXI2ForXWindow(Window window) {
   // Setup mask for mouse events. It is possible that a device is loaded/plugged
   // in after we have setup XInput2 on a window. In such cases, we need to
   // either resetup XInput2 for the window, so that we get events from the new
   // device, or we need to listen to events from all devices, and then filter
   // the events from uninteresting devices. We do the latter because that's
   // simpler.
 
@@ skipping 66 matching lines @@
 
 int TouchFactory::GetSlotForTrackingID(uint32 tracking_id) {
   return id_generator_.GetGeneratedID(tracking_id);
 }
 
 void TouchFactory::ReleaseSlotForTrackingID(uint32 tracking_id) {
   id_generator_.ReleaseNumber(tracking_id);
 }
 
 bool TouchFactory::IsTouchDevicePresent() {
-  return ui::AreTouchEventsEnabled() && touch_device_lookup_.any();
+#if defined(OS_CHROMEOS)
+  const bool is_touch_disabled = touch_events_disabled_ &&
+      !GetTouchEventsCrOsMasterSwitch();
+#else
+  const bool is_touch_disabled = touch_events_disabled_;
+#endif  // defined(OS_CHROMEOS)
+
+  return !is_touch_disabled && touch_device_lookup_.any();
 }
 
 void TouchFactory::ResetForTest() {
   pointer_device_lookup_.reset();
   touch_device_lookup_.reset();
   touch_device_list_.clear();
   touchscreen_ids_.clear();
   id_generator_.ResetForTest();
+  touch_events_disabled_ = false;
+
+#if defined(OS_CHROMEOS)
+  SetTouchEventsCrOsMasterSwitch(true);
+#endif  // defined(OS_CHROMEOS)
 }
 
 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;
   }
+  touch_events_disabled_ = false;
+
+#if defined(OS_CHROMEOS)
+  SetTouchEventsCrOsMasterSwitch(true);
+#endif  // defined(OS_CHROMEOS)
 }
 
 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) {
     pointer_device_lookup_[*iter] = true;
   }
 }
 
 void TouchFactory::CacheTouchscreenIds(int device_id) {
   if (!DeviceDataManager::HasInstance())
     return;
   std::vector<TouchscreenDevice> touchscreens =
       DeviceDataManager::GetInstance()->touchscreen_devices();
   const auto it =
       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