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/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/compositor/client_image_serialization_processor.h"

[Wez, 2016/05/21 01:08:04]

Non-wrapped line exceeds 80 chars?

ESTYLEGEDDON

[Kevin M, 2016/05/27 22:35:30]

Linter thinks it's cool; I don't think that rule applies to includes?

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

Yup, i think not.

 #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 119 matching lines @@
   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_(
+          new BlobChannelReceiverImpl(base::WrapUnique(new InMemoryBlobCache),
+                                      base::WrapUnique(blob_delegate_))),

[Wez, 2016/05/21 01:08:04]

Would be super duper awesome to avoid this gross pass-but-kinda-hold-on-to
dance.

[Kevin M, 2016/05/27 22:35:30]

Done.

       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) {
   net_components_.reset(new ClientNetworkComponents(
       base::WrapUnique(new CrossThreadNetworkEventObserver(
           weak_factory_.GetWeakPtr(),
           base::SequencedTaskRunnerHandle::Get()))));
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   io_thread_.StartWithOptions(options);
 
   assignment_source_.reset(new AssignmentSource(
       assigner_endpoint, io_thread_.task_runner(), io_thread_.task_runner()));
 
   RegisterFeatures();
 
+  ClientImageSerializationProcessor::GetInstance()->set_blob_receiver(
+      blob_receiver_.get());
+
   // 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 37 matching lines @@
                                             navigation_feature_.get()));
   render_widget_feature_->set_outgoing_input_message_processor(
       thread_pipe_manager_->RegisterFeature(BlimpMessage::INPUT,
                                             render_widget_feature_.get()));
   render_widget_feature_->set_outgoing_compositor_message_processor(
       thread_pipe_manager_->RegisterFeature(BlimpMessage::COMPOSITOR,
                                             render_widget_feature_.get()));
   settings_feature_->set_outgoing_message_processor(
       thread_pipe_manager_->RegisterFeature(BlimpMessage::SETTINGS,
                                             settings_feature_.get()));
+  thread_pipe_manager_->RegisterFeature(BlimpMessage::BLOB_CHANNEL,
+                                        blob_delegate_);
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDownloadWholeDocument))
     settings_feature_->SetRecordWholeDocument(true);
 
   // Client will not send send any RenderWidget messages, so don't save the
   // outgoing BlimpMessageProcessor in the RenderWidgetFeature.
   thread_pipe_manager_->RegisterFeature(BlimpMessage::RENDER_WIDGET,
                                         render_widget_feature_.get());
 
@@ skipping 21 matching lines @@
 RenderWidgetFeature* BlimpClientSession::GetRenderWidgetFeature() const {
   return render_widget_feature_.get();
 }
 
 SettingsFeature* BlimpClientSession::GetSettingsFeature() const {
   return settings_feature_.get();
 }
 
 }  // namespace client
 }  // namespace blimp