Incorporate BlobChannel into Blimp image encode/decode pipeline.

blimp/client/feature/compositor/blimp_compositor_manager.cc

 // Copyright 2016 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/feature/compositor/blimp_compositor_manager.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "blimp/client/feature/compositor/blimp_layer_tree_settings.h"
 #include "blimp/client/feature/compositor/client_image_serialization_processor.h"
 #include "blimp/common/compositor/blimp_task_graph_runner.h"
 #include "cc/proto/compositor_message.pb.h"
 
 namespace blimp {
 namespace client {
 
 namespace {
 base::LazyInstance<blimp::BlimpTaskGraphRunner> g_task_graph_runner =
     LAZY_INSTANCE_INITIALIZER;
 
 const int kDummyTabId = 0;
 }  // namespace
 
 BlimpCompositorManager::BlimpCompositorManager(
     RenderWidgetFeature* render_widget_feature,
     BlimpCompositorManagerClient* client)
     : visible_(false),
       window_(gfx::kNullAcceleratedWidget),
       gpu_memory_buffer_manager_(new BlimpGpuMemoryBufferManager),
-      image_serialization_processor_(new ClientImageSerializationProcessor),
+      image_serialization_processor_(
+          ClientImageSerializationProcessor::GetInstance()),
       active_compositor_(nullptr),
       render_widget_feature_(render_widget_feature),
       client_(client) {
   DCHECK(render_widget_feature_);
   render_widget_feature_->SetDelegate(kDummyTabId, this);
 }
 
 BlimpCompositorManager::~BlimpCompositorManager() {
   render_widget_feature_->RemoveDelegate(kDummyTabId);
   if (compositor_thread_)
@@ skipping 130 matching lines @@
   return g_task_graph_runner.Pointer();
 }
 
 gpu::GpuMemoryBufferManager*
 BlimpCompositorManager::GetGpuMemoryBufferManager() {
   return gpu_memory_buffer_manager_.get();
 }
 
 cc::ImageSerializationProcessor*
 BlimpCompositorManager::GetImageSerializationProcessor() {
-  return image_serialization_processor_.get();
+  return image_serialization_processor_;
 }
 
 void BlimpCompositorManager::SendWebGestureEvent(
     int render_widget_id,
     const blink::WebGestureEvent& gesture_event) {
   render_widget_feature_->SendWebGestureEvent(kDummyTabId,
                                              render_widget_id,
                                              gesture_event);
 }
 
 void BlimpCompositorManager::SendCompositorMessage(
     int render_widget_id,
     const cc::proto::CompositorMessage& message) {
   render_widget_feature_->SendCompositorMessage(kDummyTabId,
                                                render_widget_id,
                                                message);
 }
 
 BlimpCompositor* BlimpCompositorManager::GetCompositor(int render_widget_id) {
   CompositorMap::const_iterator it = compositors_.find(render_widget_id);
   if (it == compositors_.end())
     return nullptr;
   return it->second.get();
 }
 
 }  // namespace client
 }  // namespace blimp