Client plugin changes to support third party authentication.

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"
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_split.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
+#include "googleurl/src/gurl.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "media/base/media.h"
 #include "net/socket/ssl_server_socket.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/dev/url_util_dev.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/mouse_cursor.h"
 #include "ppapi/cpp/rect.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/util.h"
 #include "remoting/client/chromoting_client.h"
 #include "remoting/client/client_config.h"
 #include "remoting/client/frame_consumer_proxy.h"
 #include "remoting/client/plugin/pepper_audio_player.h"
 #include "remoting/client/plugin/pepper_input_handler.h"
 #include "remoting/client/plugin/pepper_port_allocator.h"
+#include "remoting/client/plugin/pepper_token_fetcher.h"
 #include "remoting/client/plugin/pepper_view.h"
 #include "remoting/client/plugin/pepper_xmpp_proxy.h"
 #include "remoting/client/rectangle_update_decoder.h"
 #include "remoting/protocol/connection_to_host.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/libjingle_transport_factory.h"
 
 // Windows defines 'PostMessage', so we have to undef it.
 #if defined(PostMessage)
 #undef PostMessage
@@ skipping 80 matching lines @@
 base::LazyInstance<base::Lock>::Leaky
     g_logging_lock = LAZY_INSTANCE_INITIALIZER;
 logging::LogMessageHandlerFunction g_logging_old_handler = NULL;
 
 }  // namespace
 
 // String sent in the "hello" message to the plugin to describe features.
 const char ChromotingInstance::kApiFeatures[] =
     "highQualityScaling injectKeyEvent sendClipboardItem remapKey trapKey "
     "notifyClientDimensions notifyClientResolution pauseVideo pauseAudio "
-    "asyncPin";
+    "asyncPin thirdPartyAuth";
 
 bool ChromotingInstance::ParseAuthMethods(const std::string& auth_methods_str,
                                           ClientConfig* config) {
   std::vector<std::string> auth_methods;
   base::SplitString(auth_methods_str, ',', &auth_methods);
   for (std::vector<std::string>::iterator it = auth_methods.begin();
        it != auth_methods.end(); ++it) {
     protocol::AuthenticationMethod authentication_method =
         protocol::AuthenticationMethod::FromString(*it);
     if (authentication_method.is_valid())
@@ skipping 239 matching lines @@
     PauseAudio(pause);
   } else if (method == "useAsyncPinDialog") {
     use_async_pin_dialog_ = true;
   } else if (method == "onPinFetched") {
     std::string pin;
     if (!data->GetString("pin", &pin)) {
       LOG(ERROR) << "Invalid onPinFetched.";
       return;
     }
     OnPinFetched(pin);
+  } else if (method == "onThirdPartyTokenFetched") {
+    std::string token;
+    std::string shared_secret;
+    if (!data->GetString("token", &token) ||
+        !data->GetString("sharedSecret", &shared_secret)) {
+      LOG(ERROR) << "Invalid onThirdPartyTokenFetched data.";
+      return;
+    }
+    OnThirdPartyTokenFetched(token, shared_secret);
   }
 }
 
 void ChromotingInstance::DidChangeView(const pp::View& view) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   plugin_view_ = view;
   if (view_) {
     view_->SetView(view);
     mouse_input_filter_.set_input_size(view_->get_view_size_dips());
@@ skipping 25 matching lines @@
 
 void ChromotingInstance::OnConnectionState(
     protocol::ConnectionToHost::State state,
     protocol::ErrorCode error) {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("state", ConnectionStateToString(state));
   data->SetString("error", ConnectionErrorToString(error));
   PostChromotingMessage("onConnectionStatus", data.Pass());
 }
 
+void ChromotingInstance::FetchThirdPartyToken(
+    const GURL& token_url,
+    const std::string& host_public_key,
+    const std::string& scope,
+    base::WeakPtr<PepperTokenFetcher> pepper_token_fetcher) {
+  // Once the Session object calls this function, it won't continue the
+  // authentication until the callback is called (or connection is canceled).
+  // So, it's impossible to reach this with a callback already registered.
+  DCHECK(!pepper_token_fetcher_);
+  pepper_token_fetcher_ = pepper_token_fetcher;
+  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  data->SetString("tokenUrl", token_url.spec());
+  data->SetString("hostPublicKey", host_public_key);
+  data->SetString("scope", scope);
+  PostChromotingMessage("fetchThirdPartyToken", data.Pass());
+}
+
 void ChromotingInstance::OnConnectionReady(bool ready) {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetBoolean("ready", ready);
   PostChromotingMessage("onConnectionReady", data.Pass());
 }
 
 void ChromotingInstance::FetchSecretFromDialog(
     const protocol::SecretFetchedCallback& secret_fetched_callback) {
   // Once the Session object calls this function, it won't continue the
   // authentication until the callback is called (or connection is canceled).
@@ skipping 15 matching lines @@
   // crbug.com/138108
   return this;
 }
 
 protocol::CursorShapeStub* ChromotingInstance::GetCursorShapeStub() {
   // TODO(sergeyu): Move cursor shape code to a separate class.
   // crbug.com/138108
   return this;
 }
 
+scoped_ptr<protocol::ThirdPartyClientAuthenticator::TokenFetcher>
+ChromotingInstance::GetTokenFetcher(const std::string& host_public_key) {
+  return scoped_ptr<protocol::ThirdPartyClientAuthenticator::TokenFetcher>(
+      new PepperTokenFetcher(this->AsWeakPtr(), host_public_key));
+}
+
 void ChromotingInstance::InjectClipboardEvent(
     const protocol::ClipboardEvent& event) {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("mimeType", event.mime_type());
   data->SetString("item", event.data());
   PostChromotingMessage("injectClipboardItem", data.Pass());
 }
 
 void ChromotingInstance::SetCursorShape(
     const protocol::CursorShapeInfo& cursor_shape) {
@@ skipping 193 matching lines @@
 }
 
 void ChromotingInstance::PauseAudio(bool pause) {
   if (!IsConnected()) {
     return;
   }
   protocol::AudioControl audio_control;
   audio_control.set_enable(!pause);
   host_connection_->host_stub()->ControlAudio(audio_control);
 }
-
 void ChromotingInstance::OnPinFetched(const std::string& pin) {
   if (!secret_fetched_callback_.is_null()) {
     secret_fetched_callback_.Run(pin);
     secret_fetched_callback_.Reset();
   } else {
-    VLOG(1) << "Ignored OnPinFetched received without a pending fetch.";
+    LOG(WARNING) << "Ignored OnPinFetched received without a pending fetch.";
   }
 }
 
+void ChromotingInstance::OnThirdPartyTokenFetched(
+    const std::string& token,
+    const std::string& shared_secret) {
+  if (pepper_token_fetcher_) {
+    pepper_token_fetcher_->OnTokenFetched(token, shared_secret);
+    pepper_token_fetcher_.reset();
+  } else {
+    LOG(WARNING) << "Ignored OnThirdPartyTokenFetched without a pending fetch.";
+  }
+}
+
 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());
@@ skipping 156 matching lines @@
                                       url_components.scheme.len);
   return url_scheme == kChromeExtensionUrlScheme;
 }
 
 bool ChromotingInstance::IsConnected() {
   return host_connection_.get() &&
     (host_connection_->state() == protocol::ConnectionToHost::CONNECTED);
 }
 
 }  // namespace remoting