Capabilities + Extensions + Cast Host Extension Support for Android client

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 <android/log.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 28 matching lines @@
 
 }
 
 ChromotingJniInstance::ChromotingJniInstance(ChromotingJniRuntime* jni_runtime,
                                              const char* username,
                                              const char* auth_token,
                                              const char* host_jid,
                                              const char* host_id,
                                              const char* host_pubkey,
                                              const char* pairing_id,
-                                             const char* pairing_secret)
+                                             const char* pairing_secret,
+                                             const char* capabilities)
     : jni_runtime_(jni_runtime),
       host_id_(host_id),
       host_jid_(host_jid),
       create_pairing_(false),
       stats_logging_enabled_(false),
+      capabilities_(capabilities),
       weak_factory_(this) {
   DCHECK(jni_runtime_->ui_task_runner()->BelongsToCurrentThread());
 
   // Intialize XMPP config.
   xmpp_config_.host = kXmppServer;
   xmpp_config_.port = kXmppPort;
   xmpp_config_.use_tls = kXmppUseTls;
   xmpp_config_.username = username;
   xmpp_config_.auth_token = auth_token;
   xmpp_config_.auth_service = "oauth2";
@@ skipping 178 matching lines @@
         FROM_HERE,
         base::Bind(&ChromotingJniInstance::SendTextEvent, this, text));
     return;
   }
 
   protocol::TextEvent event;
   event.set_text(text);
   client_->input_stub()->InjectTextEvent(event);
 }
 
+void ChromotingJniInstance::SendClientMessage(const std::string& type,
+                                              const std::string& data) {
+  if (!jni_runtime_->network_task_runner()->BelongsToCurrentThread()) {
+    jni_runtime_->network_task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &ChromotingJniInstance::SendClientMessage, this, type, data));
+    return;
+  }
+
+  protocol::ExtensionMessage extension_message;
+  extension_message.set_type(type);
+  extension_message.set_data(data);
+  client_->host_stub()->DeliverClientMessage(extension_message);
+}
+
 void ChromotingJniInstance::RecordPaintTime(int64 paint_time_ms) {
   if (!jni_runtime_->network_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->network_task_runner()->PostTask(
         FROM_HERE, base::Bind(&ChromotingJniInstance::RecordPaintTime, this,
                               paint_time_ms));
     return;
   }
 
   if (stats_logging_enabled_)
     video_renderer_->GetStats()->video_paint_ms()->Record(paint_time_ms);
@@ skipping 29 matching lines @@
 
 void ChromotingJniInstance::OnRouteChanged(
     const std::string& channel_name,
     const protocol::TransportRoute& route) {
   std::string message = "Channel " + channel_name + " using " +
       protocol::TransportRoute::GetTypeString(route.type) + " connection.";
   __android_log_print(ANDROID_LOG_INFO, "route", "%s", message.c_str());
 }
 
 void ChromotingJniInstance::SetCapabilities(const std::string& capabilities) {
-  NOTIMPLEMENTED();
+  jni_runtime_->ui_task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ChromotingJniRuntime::SetCapabilities,
+                 base::Unretained(jni_runtime_),
+                 capabilities));
 }
 
 void ChromotingJniInstance::SetPairingResponse(
     const protocol::PairingResponse& response) {
 
   jni_runtime_->ui_task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&ChromotingJniRuntime::CommitPairingCredentials,
                  base::Unretained(jni_runtime_),
                  host_id_, response.client_id(), response.shared_secret()));
 }
 
 void ChromotingJniInstance::DeliverHostMessage(
     const protocol::ExtensionMessage& message) {
-  NOTIMPLEMENTED();
+  jni_runtime_->ui_task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ChromotingJniRuntime::HandleExtensionMessage,
+                 base::Unretained(jni_runtime_),
+                 message.type(),
+                 message.data()));
 }
 
 protocol::ClipboardStub* ChromotingJniInstance::GetClipboardStub() {
   return this;
 }
 
 protocol::CursorShapeStub* ChromotingJniInstance::GetCursorShapeStub() {
   return this;
 }
 
@@ skipping 67 matching lines @@
       protocol::ChromiumPortAllocator::Create(jni_runtime_->url_requester(),
                                               network_settings));
 
   scoped_ptr<protocol::TransportFactory> transport_factory(
       new protocol::LibjingleTransportFactory(
           signaling_.get(),
           port_allocator.PassAs<cricket::HttpPortAllocatorBase>(),
           network_settings));
 
   client_->Start(signaling_.get(), authenticator_.Pass(),
-                 transport_factory.Pass(), host_jid_, std::string());
+                 transport_factory.Pass(), host_jid_, capabilities_);
 }
 
 void ChromotingJniInstance::DisconnectFromHostOnNetworkThread() {
   DCHECK(jni_runtime_->network_task_runner()->BelongsToCurrentThread());
 
   host_id_.clear();
 
   stats_logging_enabled_ = false;
 
   // |client_| must be torn down before |signaling_|.
@@ skipping 79 matching lines @@
                       stats->round_trip_ms()->Average());
 
   client_status_logger_->LogStatistics(stats);
 
   jni_runtime_->network_task_runner()->PostDelayedTask(
       FROM_HERE, base::Bind(&ChromotingJniInstance::LogPerfStats, this),
       base::TimeDelta::FromMilliseconds(kPerfStatsIntervalMs));
 }
 
 }  // namespace remoting