GRPC Stream implementation of HeliumStream

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 19 matching lines @@
 #include "blimp/net/blimp_connection.h"
 #include "blimp/net/blimp_message_multiplexer.h"
 #include "blimp/net/blimp_message_thread_pipe.h"
 #include "blimp/net/blimp_stats.h"
 #include "blimp/net/blob_channel/blob_channel_sender_impl.h"
 #include "blimp/net/blob_channel/helium_blob_sender_delegate.h"
 #include "blimp/net/browser_connection_handler.h"
 #include "blimp/net/common.h"
 #include "blimp/net/engine_authentication_handler.h"
 #include "blimp/net/engine_connection_manager.h"
+#include "blimp/net/grpc_engine_transport.h"
 #include "blimp/net/null_blimp_message_processor.h"
 #include "blimp/net/tcp_engine_transport.h"
 #include "blimp/net/thread_pipe_manager.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
@@ skipping 15 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;
   }
 
@@ skipping 61 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_; }
+  AssignmentOptions GetAssignmentOptions() { return assignment_options_; }
 
   BrowserConnectionHandler* connection_handler() {
     return &connection_handler_;
   }
 
   BlobChannelService* blob_channel_service() {
     return blob_channel_service_.get();
   }
 
  private:
   // ConnectionHandler implementation.
   void HandleConnection(std::unique_ptr<BlimpConnection> connection) override;
 
   // ConnectionErrorObserver implementation.
   // Signals the engine session that an authenticated connection was
   // terminated.
   void OnConnectionError(int error) override;
 
   net::NetLog* net_log_;
-  uint16_t port_ = 0;
+  AssignmentOptions assignment_options_;
 
   BrowserConnectionHandler connection_handler_;
   std::unique_ptr<EngineAuthenticationHandler> authentication_handler_;
   std::unique_ptr<EngineConnectionManager> connection_manager_;
   std::unique_ptr<BlobChannelService> blob_channel_service_;
   base::Closure quit_closure_;
 
   DISALLOW_COPY_AND_ASSIGN(EngineNetworkComponents);
 };
 
@@ skipping 16 matching lines @@
       base::MakeUnique<EngineAuthenticationHandler>(this, client_token);
 
   // Plumb unauthenticated connections to |authentication_handler_|.
   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());
-  connection_manager_->ConnectTransport(&address, GetTransportType());
-  port_ = address.port();
-
+  assignment_options_.engine_endpoint =
+      net::IPEndPoint(GetListeningAddress(), GetListeningPort());
+  connection_manager_->ConnectTransport(&assignment_options_,
+                                        GetTransportType());
   // Print the engine port for client_engine_integration script, please do not
   // remove this log.
-  DVLOG(1) << "Engine port #: " << port_;
+  DVLOG(1) << "Engine port #: " << assignment_options_.engine_endpoint.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 82 matching lines @@
                  base::Unretained(net_components_.get()),
                  base::ThreadTaskRunnerHandle::Get(),
                  blob_channel_sender_weak_factory_->GetWeakPtr(),
                  engine_config_->client_auth_token()));
 }
 
 BlobChannelService* BlimpEngineSession::GetBlobChannelService() {
   return net_components_->blob_channel_service();
 }
 
-void BlimpEngineSession::GetEnginePortForTesting(
-    const GetPortCallback& callback) {
+void BlimpEngineSession::GetAssignmentOptions(
+    const GetAssignmentOptionsCallback& callback) {
   content::BrowserThread::PostTaskAndReplyWithResult(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&EngineNetworkComponents::GetPortForTesting,
+      base::Bind(&EngineNetworkComponents::GetAssignmentOptions,
                  base::Unretained(net_components_.get())),
       callback);
 }
 
 void BlimpEngineSession::RegisterFeatures() {
   thread_pipe_manager_.reset(
       new ThreadPipeManager(content::BrowserThread::GetTaskRunnerForThread(
                                 content::BrowserThread::IO),
                             net_components_->connection_handler()));
 
@@ skipping 243 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