Refactor BlimpConnection to TCPConnection

blimp/engine/session/blimp_engine_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/engine/session/blimp_engine_session.h"
 
 #include <string>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 54 matching lines @@
 
 namespace blimp {
 namespace engine {
 namespace {
 
 const float kDefaultScaleFactor = 1.f;
 const int kDefaultDisplayWidth = 800;
 const int kDefaultDisplayHeight = 600;
 const uint16_t kDefaultPort = 25467;
 
+const char kTcpTransport[] = "tcp";
+const char kGrpcTransport[] = "grpc";
+
 // Focus rules that support activating an child window.
 class FocusRulesImpl : public wm::BaseFocusRules {
  public:
   FocusRulesImpl() {}
   ~FocusRulesImpl() override {}
 
   bool SupportsChildActivation(aura::Window* window) const override {
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FocusRulesImpl);
 };
 
 // Proxies calls to TaskRunner::PostTask while stripping the return value,
 // which provides a suitable function prototype for binding a base::Closure.
 void PostTask(const scoped_refptr<base::TaskRunner>& task_runner,
               const base::Closure& closure) {
   task_runner->PostTask(FROM_HERE, closure);
 }
 
 // Returns a closure that quits the current (bind-time) MessageLoop.
 base::Closure QuitCurrentMessageLoopClosure() {
   return base::Bind(&PostTask, base::ThreadTaskRunnerHandle::Get(),
                     base::MessageLoop::QuitWhenIdleClosure());
 }
 
+EngineConnectionManager::EngineTransportType GetTransportType() {
+  const std::string transport_parsed =
+      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+          kEngineTransport);
+  if (transport_parsed == kTcpTransport || transport_parsed.empty()) {
+    return EngineConnectionManager::EngineTransportType::TCP;
+  } else if (transport_parsed == kGrpcTransport) {
+    return EngineConnectionManager::EngineTransportType::GRPC;
+  }
+  LOG(FATAL) << "--engine-transport must either be empty or one of "
+             << kGrpcTransport << ", " << kTcpTransport;
+  return EngineConnectionManager::EngineTransportType::TCP;
+}
+
 net::IPAddress GetListeningAddress() {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(kAllowNonLocalhost)) {
     return net::IPAddress::IPv4AllZeros();
   }
   return net::IPAddress::IPv4Localhost();
 }
 
 uint16_t GetListeningPort() {
   unsigned port_parsed = 0;
   if (!base::StringToUint(
@@ skipping 20 matching lines @@
   explicit EngineNetworkComponents(net::NetLog* net_log);
   ~EngineNetworkComponents() override;
 
   // Sets up network components and starts listening for incoming connection.
   // This should be called after all features have been registered so that
   // received messages can be properly handled.
   void Initialize(scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
                   base::WeakPtr<BlobChannelSender> blob_channel_sender,
                   const std::string& client_token);
 
+  // TODO(perumaal): Remove this once gRPC support is ready.
+  //                 See crbug.com/659279.
   uint16_t GetPortForTesting() { return port_; }
 
   BrowserConnectionHandler* connection_handler() {
     return &connection_handler_;
   }
 
   BlobChannelService* blob_channel_service() {
     return blob_channel_service_.get();
   }
 
@@ skipping 30 matching lines @@
     base::WeakPtr<BlobChannelSender> blob_channel_sender,
     const std::string& client_token) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(!connection_manager_);
   // Plumb authenticated connections from the authentication handler
   // to |this| (which will then pass it to |connection_handler_|.
   authentication_handler_ =
       base::MakeUnique<EngineAuthenticationHandler>(this, client_token);
 
   // Plumb unauthenticated connections to |authentication_handler_|.
-  connection_manager_ =
-      base::MakeUnique<EngineConnectionManager>(authentication_handler_.get());
+  connection_manager_ = base::MakeUnique<EngineConnectionManager>(
+      authentication_handler_.get(), net_log_);
 
   blob_channel_service_ =
       base::MakeUnique<BlobChannelService>(blob_channel_sender, ui_task_runner);
 
   // Adds BlimpTransports to connection_manager_.
   net::IPEndPoint address(GetListeningAddress(), GetListeningPort());
-  TCPEngineTransport* transport = new TCPEngineTransport(address, net_log_);
-  connection_manager_->AddTransport(base::WrapUnique(transport));
-
-  transport->GetLocalAddress(&address);
+  connection_manager_->ConnectTransport(&address, GetTransportType());
   port_ = address.port();
-  DVLOG(1) << "Engine port #: " << port_;
 }
 
 void EngineNetworkComponents::HandleConnection(
     std::unique_ptr<BlimpConnection> connection) {
   // Observe |connection| for disconnection events.
   connection->AddConnectionErrorObserver(this);
   connection_handler_.HandleConnection(std::move(connection));
 }
 
 void EngineNetworkComponents::OnConnectionError(int error) {
@@ skipping 350 matching lines @@
     parent->AddChild(content);
   content->Show();
 
   tab_ = base::MakeUnique<Tab>(std::move(new_contents), target_tab_id,
                                &render_widget_feature_,
                                navigation_message_sender_.get());
 }
 
 }  // namespace engine
 }  // namespace blimp