Blimp: add support for SSL connections.

blimp/client/session/blimp_client_session.cc

 // Copyright 2015 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 "blimp/client/session/blimp_client_session.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "blimp/client/app/blimp_client_switches.h"
 #include "blimp/client/feature/navigation_feature.h"
 #include "blimp/client/feature/render_widget_feature.h"
 #include "blimp/client/feature/tab_control_feature.h"
 #include "blimp/net/blimp_message_processor.h"
 #include "blimp/net/blimp_message_thread_pipe.h"
 #include "blimp/net/browser_connection_handler.h"
 #include "blimp/net/client_connection_manager.h"
 #include "blimp/net/common.h"
 #include "blimp/net/null_blimp_message_processor.h"
+#include "blimp/net/ssl_client_transport.h"
 #include "blimp/net/tcp_client_transport.h"
 #include "net/base/address_list.h"
 #include "net/base/ip_address.h"
 #include "net/base/ip_endpoint.h"
 
 namespace blimp {
 namespace client {
 
 // This class's functions and destruction are all invoked on the IO thread by
 // the BlimpClientSession.
@@ skipping 24 matching lines @@
   scoped_ptr<ClientConnectionManager> connection_manager_;
 
   // Container for the feature-specific MessageProcessors.
   std::vector<scoped_ptr<BlimpMessageProcessor>> incoming_proxies_;
 
   // Containers for the MessageProcessors used to write feature-specific
   // messages to the network, and the thread-pipe endpoints through which
   // they are used from the UI thread.
   std::vector<scoped_ptr<BlimpMessageThreadPipe>> outgoing_pipes_;
   std::vector<scoped_ptr<BlimpMessageProcessor>> outgoing_message_processors_;
-
   DISALLOW_COPY_AND_ASSIGN(ClientNetworkComponents);
 };
 
 void ClientNetworkComponents::Initialize() {
   DCHECK(!connection_manager_);
   connection_manager_ = make_scoped_ptr(
       new ClientConnectionManager(browser_connection_handler_.get()));
 }
 
 void ClientNetworkComponents::ConnectWithAssignment(
     const Assignment& assignment) {
   DCHECK(connection_manager_);
   connection_manager_->set_client_token(assignment.client_token);
 
-  connection_manager_->AddTransport(make_scoped_ptr(new TCPClientTransport(
-      net::AddressList(assignment.ip_endpoint), nullptr)));
+  switch (assignment.transport_protocol) {
+    case Assignment::SSL:
+      DCHECK(assignment.cert);
+      connection_manager_->AddTransport(make_scoped_ptr(new SSLClientTransport(
+          assignment.engine_endpoint, std::move(assignment.cert), nullptr)));
+      break;
+    case Assignment::TCP:
+      connection_manager_->AddTransport(make_scoped_ptr(
+          new TCPClientTransport(assignment.engine_endpoint, nullptr)));
+      break;
+    case Assignment::UNKNOWN:
+      DLOG(FATAL) << "Uknown transport type.";
+      break;
+  }
 
   connection_manager_->Connect();
 }
 
 void ClientNetworkComponents::RegisterFeature(
     BlimpMessage::Type type,
     scoped_ptr<BlimpMessageThreadPipe> outgoing_pipe,
     scoped_ptr<BlimpMessageProcessor> incoming_proxy) {
   if (!browser_connection_handler_) {
     browser_connection_handler_ = make_scoped_ptr(new BrowserConnectionHandler);
@@ skipping 15 matching lines @@
     : io_thread_("BlimpIOThread"),
       tab_control_feature_(new TabControlFeature),
       navigation_feature_(new NavigationFeature),
       render_widget_feature_(new RenderWidgetFeature),
       net_components_(new ClientNetworkComponents),
       weak_factory_(this) {
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   io_thread_.StartWithOptions(options);
 
-  assignment_source_.reset(new AssignmentSource(
-      base::ThreadTaskRunnerHandle::Get(), io_thread_.task_runner()));
+  assignment_source_.reset(
+      new AssignmentSource(io_thread_.task_runner(), io_thread_.task_runner()));
 
   // Register features' message senders and receivers.
   tab_control_feature_->set_outgoing_message_processor(
       RegisterFeature(BlimpMessage::TAB_CONTROL, tab_control_feature_.get()));
   navigation_feature_->set_outgoing_message_processor(
       RegisterFeature(BlimpMessage::NAVIGATION, navigation_feature_.get()));
   render_widget_feature_->set_outgoing_input_message_processor(
       RegisterFeature(BlimpMessage::INPUT, render_widget_feature_.get()));
   render_widget_feature_->set_outgoing_compositor_message_processor(
       RegisterFeature(BlimpMessage::COMPOSITOR, render_widget_feature_.get()));
@@ skipping 73 matching lines @@
 NavigationFeature* BlimpClientSession::GetNavigationFeature() const {
   return navigation_feature_.get();
 }
 
 RenderWidgetFeature* BlimpClientSession::GetRenderWidgetFeature() const {
   return render_widget_feature_.get();
 }
 
 }  // namespace client
 }  // namespace blimp