Protocol / client plugin changes to support interactively asking for a PIN

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 116 matching lines @@
     g_logging_instance = LAZY_INSTANCE_INITIALIZER;
 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";
+    "notifyClientDimensions notifyClientResolution pauseVideo pauseAudio "
+    "asyncPin";
 
 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 16 matching lines @@
       input_tracker_(&mouse_input_filter_),
 #if defined(OS_MACOSX)
       // On Mac we need an extra filter to inject missing keyup events.
       // See remoting/client/plugin/mac_key_event_processor.h for more details.
       mac_key_event_processor_(&input_tracker_),
       key_mapper_(&mac_key_event_processor_),
 #else
       key_mapper_(&input_tracker_),
 #endif
       input_handler_(&key_mapper_),
+      use_async_pin_dialog_(false),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE | PP_INPUTEVENT_CLASS_WHEEL);
   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_KEYBOARD);
 
   // Resister this instance to handle debug log messsages.
   RegisterLoggingInstance();
 
   // Send hello message.
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetInteger("apiVersion", kApiVersion);
@@ skipping 79 matching lines @@
     LOG(ERROR) << "Received invalid message:" << message.AsString();
     return;
   }
 
   if (method == "connect") {
     ClientConfig config;
     std::string auth_methods;
     if (!data->GetString("hostJid", &config.host_jid) ||
         !data->GetString("hostPublicKey", &config.host_public_key) ||
         !data->GetString("localJid", &config.local_jid) ||
-        !data->GetString("sharedSecret", &config.shared_secret) ||
         !data->GetString("authenticationMethods", &auth_methods) ||
         !ParseAuthMethods(auth_methods, &config) ||
         !data->GetString("authenticationTag", &config.authentication_tag)) {
       LOG(ERROR) << "Invalid connect() data.";
       return;
     }
-
+    if (use_async_pin_dialog_) {
+      config.fetch_secret_callback =
+          base::Bind(&ChromotingInstance::FetchSecretFromDialog,
+                     this->AsWeakPtr());
+    } else {
+      std::string shared_secret;
+      if (!data->GetString("sharedSecret", &shared_secret)) {
+        LOG(ERROR) << "Invalid connect() data.";
+        return;
+      }
+      config.fetch_secret_callback =
+          base::Bind(&ChromotingInstance::FetchSecretFromString, shared_secret);
+    }
     Connect(config);
   } else if (method == "disconnect") {
     Disconnect();
   } else if (method == "incomingIq") {
     std::string iq;
     if (!data->GetString("iq", &iq)) {
       LOG(ERROR) << "Invalid onIq() data.";
       return;
     }
     OnIncomingIq(iq);
@@ skipping 75 matching lines @@
       return;
     }
     PauseVideo(pause);
   } else if (method == "pauseAudio") {
     bool pause = false;
     if (!data->GetBoolean("pause", &pause)) {
       LOG(ERROR) << "Invalid pauseAudio.";
       return;
     }
     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);
   }
 }
 
 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 31 matching lines @@
   data->SetString("error", ConnectionErrorToString(error));
   PostChromotingMessage("onConnectionStatus", 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).
+  // So, it's impossible to reach this with a callback already registered.
+  DCHECK(secret_fetched_callback_.is_null());
+  secret_fetched_callback_ = secret_fetched_callback;
+  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  PostChromotingMessage("fetchPin", data.Pass());
+}
+
+void ChromotingInstance::FetchSecretFromString(
+    const std::string& shared_secret,
+    const protocol::SecretFetchedCallback& secret_fetched_callback) {
+  secret_fetched_callback.Run(shared_secret);
+}
+
 protocol::ClipboardStub* ChromotingInstance::GetClipboardStub() {
   // TODO(sergeyu): Move clipboard handling to a separate class.
   // crbug.com/138108
   return this;
 }
 
 protocol::CursorShapeStub* ChromotingInstance::GetCursorShapeStub() {
   // TODO(sergeyu): Move cursor shape code to a separate class.
   // crbug.com/138108
   return this;
@@ skipping 206 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) <<

[Sergey Ulanov, 2013/03/20 05:49:05]

nit: operator << should be wrapped when used for IO.

[rmsousa, 2013/03/20 20:17:16]

Done.

+        "Ignored OnPinFetched received 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