Third Party Authentication for Android Part II - Java Native Interface plumbing

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 30 matching lines @@
                                              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)
     : jni_runtime_(jni_runtime),
       host_id_(host_id),
       create_pairing_(false),
-      stats_logging_enabled_(false) {
+      stats_logging_enabled_(false),
+      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 41 matching lines @@
   jni_runtime_->network_task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&ChromotingJniInstance::DisconnectFromHostOnNetworkThread,
                  this));
 }
 
 void ChromotingJniInstance::FetchThirdPartyToken(
     const GURL& token_url,
     const std::string& client_id,
     const std::string& scope,
-    base::WeakPtr<TokenFetcherProxy> jni_token_fetcher) {
-  // TODO(kelvinp) Calls into the jni_runtime_ to obtain a token from the
-  // android app (Android Third Party Auth - Part II).
+    base::WeakPtr<TokenFetcherProxy> token_fetcher_proxy) {
+  DCHECK(jni_runtime_->network_task_runner()->BelongsToCurrentThread());
+  DCHECK(!token_fetcher_proxy_.get());
+
+  __android_log_print(ANDROID_LOG_INFO,
+                      "ThirdPartyAuth",
+                      "Fetching Third Party Token from user.");
+
+  token_fetcher_proxy_ = token_fetcher_proxy;
+  jni_runtime_->ui_task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ChromotingJniRuntime::FetchThirdPartyToken,
+                 base::Unretained(jni_runtime_),
+                 token_url,
+                 client_id,
+                 scope));
+}
+
+void ChromotingJniInstance::HandleOnThirdPartyTokenFetched(
+    const std::string& token,
+    const std::string& shared_secret) {
+  DCHECK(jni_runtime_->network_task_runner()->BelongsToCurrentThread());
+
+  __android_log_print(
+      ANDROID_LOG_INFO, "ThirdPartyAuth", "Third Party Token Fetched.");
+
+  if (token_fetcher_proxy_.get()) {
+    token_fetcher_proxy_->OnTokenFetched(token, shared_secret);
+    token_fetcher_proxy_.reset();
+  } else {
+    __android_log_print(
+        ANDROID_LOG_WARN,
+        "ThirdPartyAuth",
+        "Ignored OnThirdPartyTokenFetched() without a pending fetch.");
+  }
 }
 
 void ChromotingJniInstance::ProvideSecret(const std::string& pin,
                                           bool create_pairing,
                                           const std::string& device_name) {
   DCHECK(jni_runtime_->ui_task_runner()->BelongsToCurrentThread());
   DCHECK(!pin_callback_.is_null());
 
   create_pairing_ = create_pairing;
 
@@ skipping 153 matching lines @@
 protocol::ClipboardStub* ChromotingJniInstance::GetClipboardStub() {
   return this;
 }
 
 protocol::CursorShapeStub* ChromotingJniInstance::GetCursorShapeStub() {
   return this;
 }
 
 scoped_ptr<protocol::ThirdPartyClientAuthenticator::TokenFetcher>
     ChromotingJniInstance::GetTokenFetcher(const std::string& host_public_key) {
-  // Return null to indicate that third-party authentication is unsupported.
-  return scoped_ptr<protocol::ThirdPartyClientAuthenticator::TokenFetcher>();
+  return scoped_ptr<protocol::ThirdPartyClientAuthenticator::TokenFetcher>(
+      new TokenFetcherProxy(
+          base::Bind(&ChromotingJniInstance::FetchThirdPartyToken,
+                     weak_factory_.GetWeakPtr()),
+          host_public_key));
 }
 
 void ChromotingJniInstance::InjectClipboardEvent(
     const protocol::ClipboardEvent& event) {
   NOTIMPLEMENTED();
 }
 
 void ChromotingJniInstance::SetCursorShape(
     const protocol::CursorShapeInfo& shape) {
   if (!jni_runtime_->display_task_runner()->BelongsToCurrentThread()) {
@@ skipping 142 matching lines @@
                       stats->round_trip_ms()->Average());
 
   log_to_server_->LogStatistics(stats);
 
   jni_runtime_->network_task_runner()->PostDelayedTask(
       FROM_HERE, base::Bind(&ChromotingJniInstance::LogPerfStats, this),
       base::TimeDelta::FromMilliseconds(kPerfStatsIntervalMs));
 }
 
 }  // namespace remoting