Incorporate BlobChannel into Blimp image encode/decode pipeline.

blimp/client/feature/compositor/blimp_compositor_unittest.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.h"
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "blimp/client/feature/compositor/blimp_gpu_memory_buffer_manager.h"
-#include "blimp/client/feature/compositor/client_image_serialization_processor.h"
+#include "blimp/client/feature/compositor/blob_image_serialization_processor.h"
 #include "blimp/common/compositor/blimp_task_graph_runner.h"
 #include "cc/proto/compositor_message.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 
 namespace blimp {
 namespace client {
 
 class MockBlimpCompositorClient : public BlimpCompositorClient {
  public:
   MockBlimpCompositorClient() : compositor_thread_("Compositor") {
     compositor_thread_.Start();
   }
   ~MockBlimpCompositorClient() override { compositor_thread_.Stop(); }
 
   cc::LayerTreeSettings* GetLayerTreeSettings() override { return &settings_; }
   scoped_refptr<base::SingleThreadTaskRunner> GetCompositorTaskRunner() override
       { return compositor_thread_.task_runner(); }
   cc::TaskGraphRunner* GetTaskGraphRunner() override {
     return &task_graph_runner_; }
   gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() override {
     return &gpu_memory_buffer_manager_;
   }
   cc::ImageSerializationProcessor* GetImageSerializationProcessor() override {
-    return &image_serialization_processor_;
+    return BlobImageSerializationProcessor::current();
   }
   void DidCompleteSwapBuffers() override {}
   void DidCommitAndDrawFrame() override {}
 
   void SendWebGestureEvent(
       int render_widget_id,
       const blink::WebGestureEvent& gesture_event) override {
     MockableSendWebGestureEvent(render_widget_id);
   }
   void SendCompositorMessage(
       int render_widget_id,
       const cc::proto::CompositorMessage& message) override {
     MockableSendCompositorMessage(render_widget_id);
   }
 
   MOCK_METHOD1(MockableSendWebGestureEvent, void(int));
   MOCK_METHOD1(MockableSendCompositorMessage, void(int));
 
   cc::LayerTreeSettings settings_;
   base::Thread compositor_thread_;
   BlimpTaskGraphRunner task_graph_runner_;
   BlimpGpuMemoryBufferManager gpu_memory_buffer_manager_;
-  ClientImageSerializationProcessor image_serialization_processor_;
+  BlobImageSerializationProcessor serialization_processor_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockBlimpCompositorClient);
 };
 
 class BlimpCompositorForTesting : public BlimpCompositor {
  public:
   BlimpCompositorForTesting(int render_widget_id,
                             BlimpCompositorClient* client)
   : BlimpCompositor(render_widget_id, client) {}
 
   void SendProto(const cc::proto::CompositorMessage& proto) {
     SendCompositorProto(proto);
@@ skipping 99 matching lines @@
               MockableSendCompositorMessage(render_widget_id_)).Times(1);
   EXPECT_CALL(compositor_client_,
               MockableSendWebGestureEvent(render_widget_id_)).Times(1);
 
   compositor_->SendProto(cc::proto::CompositorMessage());
   compositor_->SendGestureEvent(blink::WebGestureEvent());
 }
 
 }  // namespace client
 }  // namespace blimp