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) {
   VLOG(1) << "Connection error: " << net::ErrorToString(result);
   network_observer_->OnDisconnected(result);
 }
 
 BlimpClientSession::BlimpClientSession(const GURL& assigner_endpoint)
     : io_thread_("BlimpIOThread"),
+      blob_delegate_(new HeliumBlobReceiverDelegate),
+      blob_receiver_(
+          BlobChannelReceiver::Create(base::WrapUnique(new InMemoryBlobCache),
+                                      base::WrapUnique(blob_delegate_))),
       tab_control_feature_(new TabControlFeature),
       navigation_feature_(new NavigationFeature),
       ime_feature_(new ImeFeature),
       render_widget_feature_(new RenderWidgetFeature),
       settings_feature_(new SettingsFeature),
       weak_factory_(this) {
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   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(

[nyquist, 2016/06/03 18:30:44]

You seem to do these operations in the constructor args above as well, is that
intentional?

[Kevin M, 2016/06/06 17:43:38]

Uh, whoops.

Done.

+      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())));
+}
+
 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