Add touch events to the protocol, the stub layer, and to the client plugin.

remoting/client/plugin/chromoting_instance.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/client/plugin/chromoting_instance.h"
 
 #include <string>
 #include <vector>
 
 #if defined(OS_NACL)
@@ skipping 169 matching lines @@
 
 const char ChromotingInstance::kRequestedCapabilities[] = "";
 const char ChromotingInstance::kSupportedCapabilities[] = "desktopShape";
 
 ChromotingInstance::ChromotingInstance(PP_Instance pp_instance)
     : pp::Instance(pp_instance),
       initialized_(false),
       plugin_task_runner_(new PluginThreadTaskRunner(&plugin_thread_delegate_)),
       context_(plugin_task_runner_.get()),
       input_tracker_(&mouse_input_filter_),
-      key_mapper_(&input_tracker_),
+      touch_input_scaler_(&input_tracker_),
+      key_mapper_(&touch_input_scaler_),
       cursor_setter_(this),
       empty_cursor_filter_(&cursor_setter_),
       text_input_controller_(this),
       use_async_pin_dialog_(false),
       weak_factory_(this) {
 #if defined(OS_NACL)
   // In NaCl global resources need to be initialized differently because they
   // are not shared with Chrome.
   thread_task_runner_handle_.reset(
       new base::ThreadTaskRunnerHandle(plugin_task_runner_));
@@ skipping 142 matching lines @@
   } else if (method == "requestPairing") {
     HandleRequestPairing(*data);
   } else if (method == "extensionMessage") {
     HandleExtensionMessage(*data);
   } else if (method == "allowMouseLock") {
     HandleAllowMouseLockMessage();
   } else if (method == "sendMouseInputWhenUnfocused") {
     HandleSendMouseInputWhenUnfocused();
   } else if (method == "delegateLargeCursors") {
     HandleDelegateLargeCursors();
+  } else if (method == "enableTouchEvents") {
+    HandleEnableTouchEvents();
   }
 }
 
 void ChromotingInstance::DidChangeFocus(bool has_focus) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   if (!IsConnected())
     return;
 
   input_handler_.DidChangeFocus(has_focus);
   if (mouse_locker_)
     mouse_locker_->DidChangeFocus(has_focus);
 }
 
 void ChromotingInstance::DidChangeView(const pp::View& view) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   plugin_view_ = view;
-  mouse_input_filter_.set_input_size(
+  webrtc::DesktopSize size(
       webrtc::DesktopSize(view.GetRect().width(), view.GetRect().height()));
+  mouse_input_filter_.set_input_size(size);
+  touch_input_scaler_.set_input_size(size);
 
   if (video_renderer_)
     video_renderer_->OnViewChanged(view);
 }
 
 bool ChromotingInstance::HandleInputEvent(const pp::InputEvent& event) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   if (!IsConnected())
     return false;
@@ skipping 11 matching lines @@
   OnConnectionState(protocol::ConnectionToHost::FAILED,
                     protocol::INCOMPATIBLE_PROTOCOL);
 }
 
 void ChromotingInstance::OnVideoFirstFrameReceived() {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   PostLegacyJsonMessage("onFirstFrameReceived", data.Pass());
 }
 
 void ChromotingInstance::OnVideoSize(const webrtc::DesktopSize& size,
-                                        const webrtc::DesktopVector& dpi) {
+                                     const webrtc::DesktopVector& dpi) {
   mouse_input_filter_.set_output_size(size);
+  touch_input_scaler_.set_output_size(size);
 
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetInteger("width", size.width());
   data->SetInteger("height", size.height());
   if (dpi.x())
     data->SetInteger("x_dpi", dpi.x());
   if (dpi.y())
     data->SetInteger("y_dpi", dpi.y());
   PostLegacyJsonMessage("onDesktopSize", data.Pass());
 }
@@ skipping 241 matching lines @@
 
   if (!plugin_view_.is_null())
     video_renderer_->OnViewChanged(plugin_view_);
 
   scoped_ptr<AudioPlayer> audio_player(new PepperAudioPlayer(this));
   client_.reset(new ChromotingClient(&context_, this, video_renderer_.get(),
                                      audio_player.Pass()));
 
   // Connect the input pipeline to the protocol stub & initialize components.
   mouse_input_filter_.set_input_stub(client_->input_stub());
+  touch_input_scaler_.set_input_stub(client_->input_stub());
   if (!plugin_view_.is_null()) {
-    mouse_input_filter_.set_input_size(webrtc::DesktopSize(
-        plugin_view_.GetRect().width(), plugin_view_.GetRect().height()));
+    webrtc::DesktopSize size(plugin_view_.GetRect().width(),
+                             plugin_view_.GetRect().height());
+    mouse_input_filter_.set_input_size(size);
+    touch_input_scaler_.set_input_size(size);
   }
 
   // Setup the signal strategy.
   signal_strategy_.reset(new DelegatingSignalStrategy(
       local_jid, base::Bind(&ChromotingInstance::SendOutgoingIq,
                             weak_factory_.GetWeakPtr())));
 
   // Create TransportFactory.
   scoped_ptr<protocol::TransportFactory> transport_factory(
       new protocol::LibjingleTransportFactory(
@@ skipping 257 matching lines @@
 }
 
 void ChromotingInstance::HandleSendMouseInputWhenUnfocused() {
   input_handler_.set_send_mouse_input_when_unfocused(true);
 }
 
 void ChromotingInstance::HandleDelegateLargeCursors() {
   cursor_setter_.set_delegate_stub(this);
 }
 
+void ChromotingInstance::HandleEnableTouchEvents() {
+  RequestInputEvents(PP_INPUTEVENT_CLASS_TOUCH);
+}
+
 void ChromotingInstance::Disconnect() {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   VLOG(0) << "Disconnecting from host.";
 
   // Disconnect the input pipeline and teardown the connection.
   mouse_input_filter_.set_input_stub(nullptr);
   client_.reset();
   video_renderer_.reset();
 }
@@ skipping 170 matching lines @@
                                       url_components.scheme.len);
   return url_scheme == kChromeExtensionUrlScheme;
 }
 
 bool ChromotingInstance::IsConnected() {
   return client_ &&
          (client_->connection_state() == protocol::ConnectionToHost::CONNECTED);
 }
 
 }  // namespace remoting