Cleanups in ChromotingClient

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 <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 20 matching lines @@
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/dev/url_util_dev.h"
 #include "ppapi/cpp/image_data.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/rect.h"
 #include "ppapi/cpp/var_array_buffer.h"
 #include "ppapi/cpp/var_dictionary.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/delegating_signal_strategy.h"
 #include "remoting/client/plugin/media_source_video_renderer.h"
 #include "remoting/client/plugin/normalizing_input_filter_cros.h"
 #include "remoting/client/plugin/normalizing_input_filter_mac.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_view.h"
 #include "remoting/client/software_video_renderer.h"
@@ skipping 104 matching lines @@
 // Returns true if |pixel| is not completely transparent.
 bool IsVisiblePixel(uint32_t pixel) {
   return (pixel & kPixelAlphaMask) != 0;
 }
 
 // Returns true if there is at least one visible pixel in the given range.
 bool IsVisibleRow(const uint32_t* begin, const uint32_t* end) {
   return std::find_if(begin, end, &IsVisiblePixel) != end;
 }
 
+bool ParseAuthMethods(
+    const std::string& auth_methods_str,
+    std::vector<protocol::AuthenticationMethod>* auth_methods) {
+  std::vector<std::string> parts;
+  base::SplitString(auth_methods_str, ',', &parts);
+  for (std::vector<std::string>::iterator it = parts.begin();
+       it != parts.end(); ++it) {
+    protocol::AuthenticationMethod authentication_method =
+        protocol::AuthenticationMethod::FromString(*it);
+    if (authentication_method.is_valid())
+      auth_methods->push_back(authentication_method);
+  }
+  if (auth_methods->empty()) {
+    LOG(ERROR) << "No valid authentication methods specified.";
+    return false;
+  }
+
+  return true;
+}
+
 // This flag blocks LOGs to the UI if we're already in the middle of logging
 // to the UI. This prevents a potential infinite loop if we encounter an error
 // while sending the log message to the UI.
 bool g_logging_to_plugin = false;
 bool g_has_logging_instance = false;
 base::LazyInstance<scoped_refptr<base::SingleThreadTaskRunner> >::Leaky
     g_logging_task_runner = LAZY_INSTANCE_INITIALIZER;
 base::LazyInstance<base::WeakPtr<ChromotingInstance> >::Leaky
     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 webapp to describe features.
 const char ChromotingInstance::kApiFeatures[] =
     "highQualityScaling injectKeyEvent sendClipboardItem remapKey trapKey "
     "notifyClientResolution pauseVideo pauseAudio asyncPin thirdPartyAuth "
     "pinlessAuth extensionMessage allowMouseLock mediaSourceRendering "
     "videoControl";
 
 const char ChromotingInstance::kRequestedCapabilities[] = "";
 const char ChromotingInstance::kSupportedCapabilities[] = "desktopShape";
 
-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())
-      config->authentication_methods.push_back(authentication_method);
-  }
-  if (config->authentication_methods.empty()) {
-    LOG(ERROR) << "No valid authentication methods specified.";
-    return false;
-  }
-
-  return true;
-}
-
 ChromotingInstance::ChromotingInstance(PP_Instance pp_instance)
     : pp::Instance(pp_instance),
       initialized_(false),
       plugin_task_runner_(new PluginThreadTaskRunner(&plugin_thread_delegate_)),
       context_(plugin_task_runner_.get()),
       input_tracker_(&mouse_input_filter_),
       key_mapper_(&input_tracker_),
       input_handler_(this),
       use_async_pin_dialog_(false),
       use_media_source_rendering_(false),
@@ skipping 310 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 TokenFetcherProxy(
-          base::Bind(&ChromotingInstance::FetchThirdPartyToken,
-                     weak_factory_.GetWeakPtr()),
-          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());
   PostLegacyJsonMessage("injectClipboardItem", data.Pass());
 }
 
 void ChromotingInstance::SetCursorShape(
     const protocol::CursorShapeInfo& cursor_shape) {
@@ skipping 80 matching lines @@
     input_handler_.SetMouseCursor(cursor_image.Pass(), cursor_hotspot);
   }
 }
 
 void ChromotingInstance::OnFirstFrameReceived() {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   PostLegacyJsonMessage("onFirstFrameReceived", data.Pass());
 }
 
 void ChromotingInstance::HandleConnect(const base::DictionaryValue& data) {
-  ClientConfig config;
   std::string local_jid;
-  std::string auth_methods;
-  if (!data.GetString("hostJid", &config.host_jid) ||
-      !data.GetString("hostPublicKey", &config.host_public_key) ||
+  std::string host_jid;
+  std::string host_public_key;
+  std::string auth_methods_str;
+  std::string authentication_tag;
+  std::vector<protocol::AuthenticationMethod> auth_methods;
+  if (!data.GetString("hostJid", &host_jid) ||
+      !data.GetString("hostPublicKey", &host_public_key) ||
       !data.GetString("localJid", &local_jid) ||
-      !data.GetString("authenticationMethods", &auth_methods) ||
-      !ParseAuthMethods(auth_methods, &config) ||
-      !data.GetString("authenticationTag", &config.authentication_tag)) {
+      !data.GetString("authenticationMethods", &auth_methods_str) ||
+      !ParseAuthMethods(auth_methods_str, &auth_methods) ||
+      !data.GetString("authenticationTag", &authentication_tag)) {
     LOG(ERROR) << "Invalid connect() data.";
     return;
   }
-  data.GetString("clientPairingId", &config.client_pairing_id);
-  data.GetString("clientPairedSecret", &config.client_paired_secret);
+
+  std::string client_pairing_id;
+  data.GetString("clientPairingId", &client_pairing_id);
+  std::string client_paired_secret;
+  data.GetString("clientPairedSecret", &client_paired_secret);
+
+  protocol::FetchSecretCallback fetch_secret_callback;
   if (use_async_pin_dialog_) {
-    config.fetch_secret_callback =
-        base::Bind(&ChromotingInstance::FetchSecretFromDialog,
-                   weak_factory_.GetWeakPtr());
+    fetch_secret_callback = base::Bind(
+        &ChromotingInstance::FetchSecretFromDialog, weak_factory_.GetWeakPtr());
   } else {
     std::string shared_secret;
     if (!data.GetString("sharedSecret", &shared_secret)) {
       LOG(ERROR) << "sharedSecret not specified in connect().";
       return;
     }
-    config.fetch_secret_callback =
+    fetch_secret_callback =
         base::Bind(&ChromotingInstance::FetchSecretFromString, shared_secret);
   }
 
   // Read the list of capabilities, if any.
+  std::string capabilities;
   if (data.HasKey("capabilities")) {
-    if (!data.GetString("capabilities", &config.capabilities)) {
+    if (!data.GetString("capabilities", &capabilities)) {
       LOG(ERROR) << "Invalid connect() data.";
       return;
     }
   }
 
+  VLOG(0) << "Connecting to " << host_jid
+          << ". Local jid: " << local_jid << ".";
+
 #if defined(OS_NACL)
   std::string key_filter;
   if (!data.GetString("keyFilter", &key_filter)) {
     NOTREACHED();
     normalizing_input_filter_.reset(new protocol::InputFilter(&key_mapper_));
   } else if (key_filter == "mac") {
     normalizing_input_filter_.reset(
         new NormalizingInputFilterMac(&key_mapper_));
   } else if (key_filter == "cros") {
     normalizing_input_filter_.reset(
         new NormalizingInputFilterCros(&key_mapper_));
   } else {
     DCHECK(key_filter.empty());
     normalizing_input_filter_.reset(new protocol::InputFilter(&key_mapper_));
   }
 #elif defined(OS_MACOSX)
   normalizing_input_filter_.reset(new NormalizingInputFilterMac(&key_mapper_));
 #elif defined(OS_CHROMEOS)
   normalizing_input_filter_.reset(new NormalizingInputFilterCros(&key_mapper_));
 #else
   normalizing_input_filter_.reset(new protocol::InputFilter(&key_mapper_));
 #endif
   input_handler_.set_input_stub(normalizing_input_filter_.get());
 
-  ConnectWithConfig(config, local_jid);
-}
-
-void ChromotingInstance::ConnectWithConfig(const ClientConfig& config,
-                                           const std::string& local_jid) {
-  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
-
   if (use_media_source_rendering_) {
     video_renderer_.reset(new MediaSourceVideoRenderer(this));
   } else {
     view_.reset(new PepperView(this, &context_));
     view_weak_factory_.reset(
         new base::WeakPtrFactory<FrameConsumer>(view_.get()));
 
     // SoftwareVideoRenderer runs on a separate thread so for now we wrap
     // PepperView with a ref-counted proxy object.
     scoped_refptr<FrameConsumerProxy> consumer_proxy =
         new FrameConsumerProxy(plugin_task_runner_,
                                view_weak_factory_->GetWeakPtr());
 
     SoftwareVideoRenderer* renderer =
         new SoftwareVideoRenderer(context_.main_task_runner(),
                                   context_.decode_task_runner(),
                                   consumer_proxy);
     view_->Initialize(renderer);
     if (!plugin_view_.is_null())
       view_->SetView(plugin_view_);
     video_renderer_.reset(renderer);
   }
 
-  host_connection_.reset(new protocol::ConnectionToHost(true));
   scoped_ptr<AudioPlayer> audio_player(new PepperAudioPlayer(this));
-  client_.reset(new ChromotingClient(config, &context_, host_connection_.get(),
-                                     this, video_renderer_.get(),
+  client_.reset(new ChromotingClient(&context_, this, video_renderer_.get(),
                                      audio_player.Pass()));
 
   // Connect the input pipeline to the protocol stub & initialize components.
-  mouse_input_filter_.set_input_stub(host_connection_->input_stub());
+  mouse_input_filter_.set_input_stub(client_->input_stub());
   if (!plugin_view_.is_null()) {
     mouse_input_filter_.set_input_size(webrtc::DesktopSize(
         plugin_view_.GetRect().width(), plugin_view_.GetRect().height()));
   }
 
-  VLOG(0) << "Connecting to " << config.host_jid
-          << ". Local jid: " << local_jid << ".";
-
   // Setup the signal strategy.
   signal_strategy_.reset(new DelegatingSignalStrategy(
       local_jid, base::Bind(&ChromotingInstance::SendOutgoingIq,
                             weak_factory_.GetWeakPtr())));
 
-  scoped_ptr<cricket::HttpPortAllocatorBase> port_allocator(
-      PepperPortAllocator::Create(this));
+  // Create TransportFactory.
   scoped_ptr<protocol::TransportFactory> transport_factory(
       new protocol::LibjingleTransportFactory(
-          signal_strategy_.get(), port_allocator.Pass(),
+          signal_strategy_.get(),
+          PepperPortAllocator::Create(this)
+              .PassAs<cricket::HttpPortAllocatorBase>(),
           NetworkSettings(NetworkSettings::NAT_TRAVERSAL_FULL)));
 
+  // Create Authenticator.
+  scoped_ptr<protocol::ThirdPartyClientAuthenticator::TokenFetcher>
+      token_fetcher(new TokenFetcherProxy(
+          base::Bind(&ChromotingInstance::FetchThirdPartyToken,
+                     weak_factory_.GetWeakPtr()),
+          host_public_key));
+  scoped_ptr<protocol::Authenticator> authenticator(
+      new protocol::NegotiatingClientAuthenticator(
+          client_pairing_id, client_paired_secret, authentication_tag,
+          fetch_secret_callback, token_fetcher.Pass(), auth_methods));
+
   // Kick off the connection.
-  client_->Start(signal_strategy_.get(), transport_factory.Pass());
+  client_->Start(signal_strategy_.get(), authenticator.Pass(),
+                 transport_factory.Pass(), host_jid, capabilities);
 
   // Start timer that periodically sends perf stats.
   plugin_task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&ChromotingInstance::SendPerfStats,
                             weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kPerfStatsIntervalMs));
 }
 
 void ChromotingInstance::HandleDisconnect(const base::DictionaryValue& data) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   // PepperView must be destroyed before the client.
   view_weak_factory_.reset();
   view_.reset();
 
   VLOG(0) << "Disconnecting from host.";
 
-  client_.reset();
-
   // Disconnect the input pipeline and teardown the connection.
   mouse_input_filter_.set_input_stub(NULL);
-  host_connection_.reset();
+  client_.reset();
 }
 
 void ChromotingInstance::HandleOnIncomingIq(const base::DictionaryValue& data) {
   std::string iq;
   if (!data.GetString("iq", &iq)) {
     LOG(ERROR) << "Invalid incomingIq() data.";
     return;
   }
 
   // Just ignore the message if it's received before Connect() is called. It's
@@ skipping 59 matching lines @@
       !data.GetString("item", &item)) {
     LOG(ERROR) << "Invalid sendClipboardItem data.";
     return;
   }
   if (!IsConnected()) {
     return;
   }
   protocol::ClipboardEvent event;
   event.set_mime_type(mime_type);
   event.set_data(item);
-  host_connection_->clipboard_forwarder()->InjectClipboardEvent(event);
+  client_->clipboard_forwarder()->InjectClipboardEvent(event);
 }
 
 void ChromotingInstance::HandleNotifyClientResolution(
     const base::DictionaryValue& data) {
   int width = 0;
   int height = 0;
   int x_dpi = kDefaultDPI;
   int y_dpi = kDefaultDPI;
   if (!data.GetInteger("width", &width) ||
       !data.GetInteger("height", &height) ||
@@ skipping 12 matching lines @@
   protocol::ClientResolution client_resolution;
   client_resolution.set_width(width);
   client_resolution.set_height(height);
   client_resolution.set_x_dpi(x_dpi);
   client_resolution.set_y_dpi(y_dpi);
 
   // Include the legacy width & height in DIPs for use by older hosts.
   client_resolution.set_dips_width((width * kDefaultDPI) / x_dpi);
   client_resolution.set_dips_height((height * kDefaultDPI) / y_dpi);
 
-  host_connection_->host_stub()->NotifyClientResolution(client_resolution);
+  client_->host_stub()->NotifyClientResolution(client_resolution);
 }
 
 void ChromotingInstance::HandlePauseVideo(const base::DictionaryValue& data) {
   if (!data.HasKey("pause")) {
     LOG(ERROR) << "Invalid pauseVideo.";
     return;
   }
   HandleVideoControl(data);
 }
 
 void ChromotingInstance::HandleVideoControl(const base::DictionaryValue& data) {
   protocol::VideoControl video_control;
   bool pause_video = false;
   if (data.GetBoolean("pause", &pause_video)) {
     video_control.set_enable(!pause_video);
   }
   bool lossless_encode = false;
   if (data.GetBoolean("losslessEncode", &lossless_encode)) {
     video_control.set_lossless_encode(lossless_encode);
   }
   bool lossless_color = false;
   if (data.GetBoolean("losslessColor", &lossless_color)) {
     video_control.set_lossless_color(lossless_color);
   }
   if (!IsConnected()) {
     return;
   }
-  host_connection_->host_stub()->ControlVideo(video_control);
+  client_->host_stub()->ControlVideo(video_control);
 }
 
 void ChromotingInstance::HandlePauseAudio(const base::DictionaryValue& data) {
   bool pause = false;
   if (!data.GetBoolean("pause", &pause)) {
     LOG(ERROR) << "Invalid pauseAudio.";
     return;
   }
   if (!IsConnected()) {
     return;
   }
   protocol::AudioControl audio_control;
   audio_control.set_enable(!pause);
-  host_connection_->host_stub()->ControlAudio(audio_control);
+  client_->host_stub()->ControlAudio(audio_control);
 }
 void ChromotingInstance::HandleOnPinFetched(const base::DictionaryValue& data) {
   std::string pin;
   if (!data.GetString("pin", &pin)) {
     LOG(ERROR) << "Invalid onPinFetched.";
     return;
   }
   if (!secret_fetched_callback_.is_null()) {
     secret_fetched_callback_.Run(pin);
     secret_fetched_callback_.Reset();
@@ skipping 24 matching lines @@
   std::string client_name;
   if (!data.GetString("clientName", &client_name)) {
     LOG(ERROR) << "Invalid requestPairing";
     return;
   }
   if (!IsConnected()) {
     return;
   }
   protocol::PairingRequest pairing_request;
   pairing_request.set_client_name(client_name);
-  host_connection_->host_stub()->RequestPairing(pairing_request);
+  client_->host_stub()->RequestPairing(pairing_request);
 }
 
 void ChromotingInstance::HandleExtensionMessage(
     const base::DictionaryValue& data) {
   std::string type;
   std::string message_data;
   if (!data.GetString("type", &type) ||
       !data.GetString("data", &message_data)) {
     LOG(ERROR) << "Invalid extensionMessage.";
     return;
   }
   if (!IsConnected()) {
     return;
   }
   protocol::ExtensionMessage message;
   message.set_type(type);
   message.set_data(message_data);
-  host_connection_->host_stub()->DeliverClientMessage(message);
+  client_->host_stub()->DeliverClientMessage(message);
 }
 
 void ChromotingInstance::HandleAllowMouseLockMessage() {
   input_handler_.AllowMouseLock();
 }
 
 void ChromotingInstance::HandleEnableMediaSourceRendering() {
   use_media_source_rendering_ = true;
 }
 
@@ skipping 178 matching lines @@
   if (!url_var.is_string())
     return false;
 
   std::string url = url_var.AsString();
   std::string url_scheme = url.substr(url_components.scheme.begin,
                                       url_components.scheme.len);
   return url_scheme == kChromeExtensionUrlScheme;
 }
 
 bool ChromotingInstance::IsConnected() {
-  return host_connection_.get() &&
-    (host_connection_->state() == protocol::ConnectionToHost::CONNECTED);
+  return client_ &&
+         (client_->connection_state() == protocol::ConnectionToHost::CONNECTED);
 }
 
 void ChromotingInstance::OnMediaSourceSize(const webrtc::DesktopSize& size,
                                            const webrtc::DesktopVector& dpi) {
   SetDesktopSize(size, dpi);
 }
 
 void ChromotingInstance::OnMediaSourceShape(
     const webrtc::DesktopRegion& shape) {
   SetDesktopShape(shape);
@@ skipping 11 matching lines @@
   void* data_ptr = array_buffer.Map();
   memcpy(data_ptr, buffer, buffer_size);
   array_buffer.Unmap();
   pp::VarDictionary data_dictionary;
   data_dictionary.Set(pp::Var("buffer"), array_buffer);
   data_dictionary.Set(pp::Var("keyframe"), keyframe);
   PostChromotingMessage("mediaSourceData", data_dictionary);
 }
 
 }  // namespace remoting