Incorporate BlobChannel into Blimp image encode/decode pipeline.

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 <vector>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "blimp/client/app/blimp_client_switches.h"
 #include "blimp/client/feature/ime_feature.h"
 #include "blimp/client/feature/navigation_feature.h"
 #include "blimp/client/feature/render_widget_feature.h"
 #include "blimp/client/feature/settings_feature.h"
 #include "blimp/client/feature/tab_control_feature.h"
+#include "blimp/common/blob_cache/in_memory_blob_cache.h"
 #include "blimp/net/blimp_connection.h"
 #include "blimp/net/blimp_message_processor.h"
 #include "blimp/net/blimp_message_thread_pipe.h"
+#include "blimp/net/blob_channel/blob_channel_receiver.h"
+#include "blimp/net/blob_channel/helium_blob_receiver_delegate.h"
 #include "blimp/net/browser_connection_handler.h"
 #include "blimp/net/client_connection_manager.h"
 #include "blimp/net/common.h"
 #include "blimp/net/connection_handler.h"
 #include "blimp/net/null_blimp_message_processor.h"
 #include "blimp/net/ssl_client_transport.h"
 #include "blimp/net/tcp_client_transport.h"
 #include "blimp/net/thread_pipe_manager.h"
 #include "net/base/address_list.h"
 #include "net/base/ip_address.h"
@@ skipping 45 matching lines @@
 
   // Sets up network components.
   void Initialize();
 
   // Starts the connection to the engine using the given |assignment|.
   // It is required to first call Initialize.
   void ConnectWithAssignment(const Assignment& assignment);
 
   BrowserConnectionHandler* GetBrowserConnectionHandler();
 
+  void DropCurrentConnection();
+
  private:
   // ConnectionHandler implementation.
   void HandleConnection(std::unique_ptr<BlimpConnection> connection) override;
 
   // ConnectionErrorObserver implementation.
   void OnConnectionError(int error) override;
 
   std::unique_ptr<BrowserConnectionHandler> connection_handler_;
   std::unique_ptr<ClientConnectionManager> connection_manager_;
   std::unique_ptr<NetworkEventObserver> network_observer_;
@@ skipping 46 matching lines @@
           << transport_type << ")";
 
   connection_manager_->Connect();
 }
 
 BrowserConnectionHandler*
 ClientNetworkComponents::GetBrowserConnectionHandler() {
   return connection_handler_.get();
 }
 
+void ClientNetworkComponents::DropCurrentConnection() {
+  connection_handler_->DropCurrentConnection();
+}
+
 void ClientNetworkComponents::HandleConnection(
     std::unique_ptr<BlimpConnection> connection) {
   VLOG(1) << "Connection established.";
   connection->AddConnectionErrorObserver(this);
   network_observer_->OnConnected();
   connection_handler_->HandleConnection(std::move(connection));
 }
 
 void ClientNetworkComponents::OnConnectionError(int result) {
   if (result >= 0) {
@@ skipping 17 matching lines @@
   io_thread_.StartWithOptions(options);
   blimp_connection_statistics_ = new BlimpConnectionStatistics();
   net_components_.reset(new ClientNetworkComponents(
       base::WrapUnique(new CrossThreadNetworkEventObserver(
           weak_factory_.GetWeakPtr(), base::SequencedTaskRunnerHandle::Get())),
       base::WrapUnique(blimp_connection_statistics_)));
 
   assignment_source_.reset(new AssignmentSource(
       assigner_endpoint, io_thread_.task_runner(), io_thread_.task_runner()));
 
+  std::unique_ptr<HeliumBlobReceiverDelegate> blob_delegate(
+      new HeliumBlobReceiverDelegate);
+  blob_delegate_ = blob_delegate.get();
+  blob_receiver_ = BlobChannelReceiver::Create(
+      base::WrapUnique(new InMemoryBlobCache), std::move(blob_delegate));
+
   RegisterFeatures();
 
+  ClientImageSerializationProcessor::GetInstance()->set_blob_receiver(
+      blob_receiver_.get());
+  ClientImageSerializationProcessor::GetInstance()->set_error_delegate(this);
+
   // Initialize must only be posted after the RegisterFeature calls have
   // completed.
   io_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&ClientNetworkComponents::Initialize,
                             base::Unretained(net_components_.get())));
 }
 
 BlimpClientSession::~BlimpClientSession() {
   io_thread_.task_runner()->DeleteSoon(FROM_HERE, net_components_.release());
 }
@@ skipping 40 matching lines @@
                                             navigation_feature_.get()));
   render_widget_feature_->set_outgoing_input_message_processor(
       thread_pipe_manager_->RegisterFeature(BlimpMessage::kInput,
                                             render_widget_feature_.get()));
   render_widget_feature_->set_outgoing_compositor_message_processor(
       thread_pipe_manager_->RegisterFeature(BlimpMessage::kCompositor,
                                             render_widget_feature_.get()));
   settings_feature_->set_outgoing_message_processor(
       thread_pipe_manager_->RegisterFeature(BlimpMessage::kSettings,
                                             settings_feature_.get()));
+  thread_pipe_manager_->RegisterFeature(BlimpMessage::kBlobChannel,
+                                        blob_delegate_);
 
   // Client will not send send any RenderWidget messages, so don't save the
   // outgoing BlimpMessageProcessor in the RenderWidgetFeature.
   thread_pipe_manager_->RegisterFeature(BlimpMessage::kRenderWidget,
                                         render_widget_feature_.get());
 
   ime_feature_->set_outgoing_message_processor(
       thread_pipe_manager_->RegisterFeature(BlimpMessage::kIme,
                                             ime_feature_.get()));
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDownloadWholeDocument))
     settings_feature_->SetRecordWholeDocument(true);
 }
 
 void BlimpClientSession::OnConnected() {}
 
 void BlimpClientSession::OnDisconnected(int result) {}
 
+void BlimpClientSession::OnImageDecodeError() {
+  io_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&ClientNetworkComponents::DropCurrentConnection,
+                            base::Unretained(net_components_.get())));

[Wez, 2016/06/07 01:18:31]

DropCurrentConnection() is expected to be called at-most-once, so don't we need
a check here, or in the ClientNetworkComponents, to protected against multiple
calls?

[Kevin M, 2016/06/08 00:21:09]

I made BrowserConnectionHandler::DropCurrentConnection idempotent, how's that?

[Wez, 2016/06/10 22:29:54]

Acknowledged.

+}
+
 TabControlFeature* BlimpClientSession::GetTabControlFeature() const {
   return tab_control_feature_.get();
 }
 
 NavigationFeature* BlimpClientSession::GetNavigationFeature() const {
   return navigation_feature_.get();
 }
 
 ImeFeature* BlimpClientSession::GetImeFeature() const {
   return ime_feature_.get();
 }
 
 RenderWidgetFeature* BlimpClientSession::GetRenderWidgetFeature() const {
   return render_widget_feature_.get();
 }
 
 SettingsFeature* BlimpClientSession::GetSettingsFeature() const {
   return settings_feature_.get();
 }
 
 BlimpConnectionStatistics* BlimpClientSession::GetBlimpConnectionStatistics()
     const {
   return blimp_connection_statistics_;
 }
 
 }  // namespace client
 }  // namespace blimp