Add APIs to the client plugin to re-map and trap key events.

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>
 
 #include "base/bind.h"
@@ skipping 84 matching lines @@
 static bool g_logging_to_plugin = false;
 static bool g_has_logging_instance = false;
 static ChromotingInstance* g_logging_instance = NULL;
 static logging::LogMessageHandlerFunction g_logging_old_handler = NULL;
 
 static base::LazyInstance<base::Lock>::Leaky
     g_logging_lock = LAZY_INSTANCE_INITIALIZER;
 
 // String sent in the "hello" message to the plugin to describe features.
 const char ChromotingInstance::kApiFeatures[] =
-    "highQualityScaling injectKeyEvent sendClipboardItem";
+    "highQualityScaling injectKeyEvent sendClipboardItem remapKey trapKey";
 
 bool ChromotingInstance::ParseAuthMethods(const std::string& auth_methods_str,
                                           ClientConfig* config) {
   if (auth_methods_str == "v1_token") {
     config->use_v1_authenticator = true;
   } else {
     config->use_v1_authenticator = false;
 
     std::vector<std::string> auth_methods;
     base::SplitString(auth_methods_str, ',', &auth_methods);
@@ skipping 146 matching lines @@
       LOG(ERROR) << "Invalid injectKeyEvent.";
       return;
     }
 
     protocol::KeyEvent event;
     event.set_usb_keycode(usb_keycode);
     event.set_pressed(is_pressed);
     // Even though new hosts will ignore keycode, it's a required field.
     event.set_keycode(0);
     InjectKeyEvent(event);
+  } else if (method == "remapKey") {
+    int from_keycode = 0;
+    int to_keycode = 0;
+    if (!data->GetInteger("fromKeycode", &from_keycode) ||
+        !data->GetInteger("toKeycode", &to_keycode)) {
+      LOG(ERROR) << "Invalid remapKey.";
+      return;
+    }
+
+    RemapKey(from_keycode, to_keycode);
+  } else if (method == "trapKey") {
+    int keycode = 0;
+    bool trap = false;
+    if (!data->GetInteger("keycode", &keycode) ||
+        !data->GetBoolean("trap", &trap)) {
+      LOG(ERROR) << "Invalid trapKey.";
+      return;
+    }
+
+    TrapKey(keycode, trap);
   } else if (method == "sendClipboardItem") {
     std::string mime_type;
     std::string item;
     if (!data->GetString("mimeType", &mime_type) ||
         !data->GetString("item", &item)) {
       LOG(ERROR) << "Invalid sendClipboardItem() data.";
       return;
     }
     SendClipboardItem(mime_type, item);
   }
@@ skipping 81 matching lines @@
   client_.reset(new ChromotingClient(config, &context_, host_connection_.get(),
                                      view_.get(), rectangle_decoder_.get(),
                                      base::Closure()));
 
   // Construct the input pipeline
   mouse_input_filter_.reset(
       new MouseInputFilter(host_connection_->input_stub()));
   mouse_input_filter_->set_input_size(view_->get_view_size());
   input_tracker_.reset(
       new protocol::InputEventTracker(mouse_input_filter_.get()));
+  key_mapper_.set_input_stub(input_tracker_.get());
   input_handler_.reset(
-      new PepperInputHandler(input_tracker_.get()));
+      new PepperInputHandler(&key_mapper_));
 
   LOG(INFO) << "Connecting to " << config.host_jid
             << ". Local jid: " << config.local_jid << ".";
 
   // Setup the XMPP Proxy.
   xmpp_proxy_ = new PepperXmppProxy(
       base::Bind(&ChromotingInstance::SendOutgoingIq, AsWeakPtr()),
       plugin_message_loop_,
       context_.network_message_loop());
 
@@ skipping 33 matching lines @@
 void ChromotingInstance::OnIncomingIq(const std::string& iq) {
   xmpp_proxy_->OnIq(iq);
 }
 
 void ChromotingInstance::ReleaseAllKeys() {
   if (input_tracker_.get())
     input_tracker_->ReleaseAll();
 }
 
 void ChromotingInstance::InjectKeyEvent(const protocol::KeyEvent& event) {
+  // Inject after the KeyEventMapper, so the event won't get mapped or trapped.
   if (input_tracker_.get())
     input_tracker_->InjectKeyEvent(event);
 }
 
+void ChromotingInstance::RemapKey(uint32 in_usb_keycode,
+                                  uint32 out_usb_keycode) {
+  key_mapper_.RemapKey(in_usb_keycode, out_usb_keycode);
+}
+
+void ChromotingInstance::TrapKey(uint32 usb_keycode, bool trap) {
+  key_mapper_.TrapKey(usb_keycode, trap);
+}
+
 void ChromotingInstance::SendClipboardItem(const std::string& mime_type,
                                            const std::string& item) {
   if (!host_connection_.get()) {
     return;
   }
   protocol::ClipboardEvent event;
   event.set_mime_type(mime_type);
   event.set_data(item);
   host_connection_->clipboard_stub()->InjectClipboardEvent(event);
 }
 
 ChromotingStats* ChromotingInstance::GetStats() {
   if (!client_.get())
     return NULL;
   return client_->GetStats();
 }
 
 void ChromotingInstance::PostChromotingMessage(
     const std::string& method,
     scoped_ptr<base::DictionaryValue> data) {
   scoped_ptr<base::DictionaryValue> message(new base::DictionaryValue());
   message->SetString("method", method);
   message->Set("data", data.release());
 
   std::string message_json;
   base::JSONWriter::Write(message.get(), &message_json);
   PostMessage(pp::Var(message_json));
 }
 
+void ChromotingInstance::SendTrappedKey(uint32 usb_keycode, bool pressed) {
+  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  data->SetInteger("usbKeycode", usb_keycode);
+  data->SetBoolean("pressed", pressed);
+  PostChromotingMessage("trappedKeyEvent", data.Pass());
+}
+
 void ChromotingInstance::SendOutgoingIq(const std::string& iq) {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("iq", iq);
   PostChromotingMessage("sendOutgoingIq", data.Pass());
 
   GetScriptableObject()->SendIq(iq);
 }
 
 void ChromotingInstance::SendPerfStats() {
   if (!client_.get()) {
@@ skipping 118 matching lines @@
     scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
     data->SetString("message", message);
     PostChromotingMessage("logDebugMessage", data.Pass());
 
     scriptable_object->LogDebugInfo(message);
   }
   g_logging_to_plugin = false;
 }
 
 }  // namespace remoting