Move BlimpImageSerializationProcessor and WebPDecoder to //blimp/client

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/thread_task_runner_handle.h"
 #include "blimp/client/feature/compositor/blimp_gpu_memory_buffer_manager.h"
-#include "blimp/common/compositor/blimp_image_serialization_processor.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"
 #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"),
-    image_serialization_processor_(
-       BlimpImageSerializationProcessor::Mode::DESERIALIZATION) {
+      : compositor_thread_("Compositor"), image_serialization_processor_() {

[Kevin M, 2016/05/05 19:34:40]

No need to initialize image_serialization_processor_ here if you're just initing
it to a default value.

[nyquist, 2016/05/05 21:26:08]

Done.

     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 {
@@ skipping 15 matching lines @@
     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_;
-  BlimpImageSerializationProcessor image_serialization_processor_;
+  ClientImageSerializationProcessor image_serialization_processor_;
 };
 
 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