Revert of Remove supports_touch_events flag from BasicDesktopEnvironment

remoting/host/me2me_desktop_environment.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 "remoting/host/me2me_desktop_environment.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "build/build_config.h"
 #include "remoting/base/logging.h"
 #include "remoting/host/client_session_control.h"
 #include "remoting/host/curtain_mode.h"
 #include "remoting/host/desktop_resizer.h"
 #include "remoting/host/host_window.h"
 #include "remoting/host/host_window.h"
 #include "remoting/host/host_window_proxy.h"
-#include "remoting/host/input_injector.h"
 #include "remoting/host/local_input_monitor.h"
 #include "remoting/host/resizing_host_observer.h"
 #include "remoting/host/screen_controls.h"
 #include "remoting/protocol/capability_names.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capture_options.h"
 #include "third_party/webrtc/modules/desktop_capture/screen_capturer.h"
 
 #if defined(OS_POSIX)
 #include <sys/types.h>
 #include <unistd.h>
@@ skipping 12 matching lines @@
   // We only want to restore the host resolution on disconnect if we are not
   // curtained so we don't mess up the user's window layout unnecessarily if
   // they disconnect and reconnect. Both OS X and Windows will restore the
   // resolution automatically when the user logs back in on the console, and on
   // Linux the curtain-mode uses a separate session.
   return base::WrapUnique(new ResizingHostObserver(DesktopResizer::Create(),
                                                    curtain_ == nullptr));
 }
 
 std::string Me2MeDesktopEnvironment::GetCapabilities() const {
-  std::string capabilities;
-  capabilities += protocol::kRateLimitResizeRequests;
-  if (InputInjector::SupportsTouchEvents()) {
-    capabilities += " ";
-    capabilities += protocol::kTouchEventsCapability;
-  }
+  std::string capabilities = BasicDesktopEnvironment::GetCapabilities();
+  if (!capabilities.empty())
+    capabilities.append(" ");
+  capabilities.append(protocol::kRateLimitResizeRequests);
+
   return capabilities;
 }
 
 Me2MeDesktopEnvironment::Me2MeDesktopEnvironment(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner)
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+    bool supports_touch_events)
     : BasicDesktopEnvironment(caller_task_runner,
                               video_capture_task_runner,
                               input_task_runner,
-                              ui_task_runner) {
+                              ui_task_runner,
+                              supports_touch_events) {
   DCHECK(caller_task_runner->BelongsToCurrentThread());
 
   // X DAMAGE is not enabled by default, since it is broken on many systems -
   // see http://crbug.com/73423. It's safe to enable it here because it works
   // properly under Xvfb.
   desktop_capture_options()->set_use_update_notifications(true);
 }
 
 bool Me2MeDesktopEnvironment::InitializeSecurity(
     base::WeakPtr<ClientSessionControl> client_session_control,
@@ skipping 59 matching lines @@
                                      ui_task_runner) {}
 
 Me2MeDesktopEnvironmentFactory::~Me2MeDesktopEnvironmentFactory() {
 }
 
 std::unique_ptr<DesktopEnvironment> Me2MeDesktopEnvironmentFactory::Create(
     base::WeakPtr<ClientSessionControl> client_session_control) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   std::unique_ptr<Me2MeDesktopEnvironment> desktop_environment(
-      new Me2MeDesktopEnvironment(caller_task_runner(),
-                                  video_capture_task_runner(),
-                                  input_task_runner(), ui_task_runner()));
+      new Me2MeDesktopEnvironment(
+          caller_task_runner(), video_capture_task_runner(),
+          input_task_runner(), ui_task_runner(), supports_touch_events()));
   if (!desktop_environment->InitializeSecurity(client_session_control,
                                                curtain_enabled_)) {
     return nullptr;
   }
 
   return std::move(desktop_environment);
 }
 
 void Me2MeDesktopEnvironmentFactory::SetEnableCurtaining(bool enable) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   curtain_enabled_ = enable;
 }
 
 }  // namespace remoting