Chromoting Android app mouse/keyboard bugfixes and enhancements

remoting/client/jni/chromoting_jni_instance.cc

 // Copyright 2013 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/jni/chromoting_jni_instance.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "remoting/client/audio_player.h"
 #include "remoting/client/jni/android_keymap.h"
 #include "remoting/client/jni/chromoting_jni_runtime.h"
 #include "remoting/protocol/libjingle_transport_factory.h"
 
 // TODO(solb) Move into location shared with client plugin.
-const char* const CHAT_SERVER = "talk.google.com";
-const int CHAT_PORT = 5222;
-const bool CHAT_USE_TLS = true;
+const char* const kXmppServer = "talk.google.com";
+const int kXmppPort = 5222;
+const bool kXmppUseTls = true;
 
 namespace remoting {
 
 ChromotingJniInstance::ChromotingJniInstance(ChromotingJniRuntime* jni_runtime,
                                              const char* username,
                                              const char* auth_token,
                                              const char* host_jid,
                                              const char* host_id,
                                              const char* host_pubkey)
     : jni_runtime_(jni_runtime),
@@ skipping 48 matching lines @@
     return;
   }
 
   jni_runtime_->RedrawCanvas();
 }
 
 void ChromotingJniInstance::PerformMouseAction(
     int x,
     int y,
     protocol::MouseEvent_MouseButton button,
-    bool buttonDown) {
+    bool button_down) {
   if (!jni_runtime_->network_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->network_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&ChromotingJniInstance::PerformMouseAction,
                    this,
                    x,
                    y,
                    button,
-                   buttonDown));
+                   button_down));
     return;
   }
 
   protocol::MouseEvent action;
   action.set_x(x);
   action.set_y(y);
   action.set_button(button);
   if (button != protocol::MouseEvent::BUTTON_UNDEFINED)
-    action.set_button_down(buttonDown);
+    action.set_button_down(button_down);
 
   connection_->input_stub()->InjectMouseEvent(action);
 }
 
-void ChromotingJniInstance::PerformKeyboardAction(int keyCode, bool keyDown) {
+void ChromotingJniInstance::PerformKeyboardAction(int key_code, bool key_down) {
   if (!jni_runtime_->network_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->network_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&ChromotingJniInstance::PerformKeyboardAction,
                    this,
-                   keyCode,
-                   keyDown));
+                   key_code,
+                   key_down));
     return;
   }
 
-  uint32 usbCode = AndroidKeycodeToUsbKeycode(keyCode);
-  if (usbCode) {
+  uint32 usb_code = AndroidKeycodeToUsbKeycode(key_code);
+  if (usb_code) {
     protocol::KeyEvent action;
-    action.set_usb_keycode(usbCode);
-    action.set_pressed(keyDown);
+    action.set_usb_keycode(usb_code);
+    action.set_pressed(key_down);
     connection_->input_stub()->InjectKeyEvent(action);
   }
-  else
-    LOG(WARNING) << "Ignoring unknown keycode: " << keyCode;
+  else {
+    LOG(WARNING) << "Ignoring unknown keycode: " << key_code;
+  }
 }
 
 void ChromotingJniInstance::OnConnectionState(
     protocol::ConnectionToHost::State state,
     protocol::ErrorCode error) {
   if (!jni_runtime_->ui_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->ui_task_runner()->PostTask(
             FROM_HERE,
             base::Bind(&ChromotingJniInstance::OnConnectionState,
                        this,
@@ skipping 81 matching lines @@
   client_.reset(new ChromotingClient(*client_config_,
                                      client_context_.get(),
                                      connection_.get(),
                                      this,
                                      frame_consumer_,
                                      scoped_ptr<AudioPlayer>()));
 
   view_->set_frame_producer(client_->GetFrameProducer());
 
   signaling_config_.reset(new XmppSignalStrategy::XmppServerConfig());
-  signaling_config_->host = CHAT_SERVER;
-  signaling_config_->port = CHAT_PORT;
-  signaling_config_->use_tls = CHAT_USE_TLS;
+  signaling_config_->host = kXmppServer;
+  signaling_config_->port = kXmppPort;
+  signaling_config_->use_tls = kXmppUseTls;
 
   signaling_.reset(new XmppSignalStrategy(jni_runtime_->url_requester(),
                                           username_,
                                           auth_token_,
                                           "oauth2",
                                           *signaling_config_));
 
   network_settings_.reset(new NetworkSettings(
       NetworkSettings::NAT_TRAVERSAL_ENABLED));
   scoped_ptr<protocol::TransportFactory> fact(
@@ skipping 29 matching lines @@
                    pairable,
                    callback));
     return;
   }
 
   pin_callback_ = callback;
   jni_runtime_->DisplayAuthenticationPrompt();
 }
 
 }  // namespace remoting