[blimp] Add SkPicture caching support.

cc/test/layer_tree_test.cc

 // Copyright 2011 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 "cc/test/layer_tree_test.h"
 
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/element_animations.h"
 #include "cc/animation/timing_function.h"
 #include "cc/base/switches.h"
+#include "cc/blimp/image_serialization_processor.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/proto/compositor_message_to_impl.pb.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/fake_external_begin_frame_source.h"
+#include "cc/test/fake_image_serialization_processor.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/remote_channel_impl_for_test.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_gpu_memory_buffer_manager.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/test/threaded_channel_for_test.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_impl.h"
@@ skipping 375 matching lines @@
       TestHooks* test_hooks,
       CompositorMode mode,
       LayerTreeHostClientForTesting* client,
       RemoteProtoChannel* remote_proto_channel,
       SharedBitmapManager* shared_bitmap_manager,
       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
       TaskGraphRunner* task_graph_runner,
       const LayerTreeSettings& settings,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
-      std::unique_ptr<BeginFrameSource> external_begin_frame_source) {
+      std::unique_ptr<BeginFrameSource> external_begin_frame_source,
+      ImageSerializationProcessor* image_serialization_processor) {
     LayerTreeHost::InitParams params;
     params.client = client;
     params.shared_bitmap_manager = shared_bitmap_manager;
     params.gpu_memory_buffer_manager = gpu_memory_buffer_manager;
     params.task_graph_runner = task_graph_runner;
     params.settings = &settings;
+    params.image_serialization_processor = image_serialization_processor;
+
     params.animation_host =
         AnimationHost::CreateForTesting(ThreadInstance::MAIN);
     std::unique_ptr<LayerTreeHostForTesting> layer_tree_host(
         new LayerTreeHostForTesting(test_hooks, &params, mode));
     std::unique_ptr<TaskRunnerProvider> task_runner_provider =
         TaskRunnerProvider::Create(main_task_runner, impl_task_runner);
     std::unique_ptr<Proxy> proxy;
     switch (mode) {
       case CompositorMode::SINGLE_THREADED:
         proxy = SingleThreadProxyForTest::Create(test_hooks,
@@ skipping 60 matching lines @@
         test_started_(false) {}
 
   TestHooks* test_hooks_;
   bool test_started_;
 };
 
 LayerTreeTest::LayerTreeTest()
     : output_surface_(nullptr),
       external_begin_frame_source_(nullptr),
       remote_proto_channel_bridge_(this),
+      image_serialization_processor_(
+          base::WrapUnique(new FakeImageSerializationProcessor)),
       beginning_(false),
       end_when_begin_returns_(false),
       timed_out_(false),
       scheduled_(false),
       started_(false),
       ended_(false),
       delegating_renderer_(false),
       timeout_seconds_(0),
       weak_factory_(this) {
   main_thread_weak_ptr_ = weak_factory_.GetWeakPtr();
@@ skipping 185 matching lines @@
   }
 
   DCHECK(!impl_thread_ || impl_thread_->task_runner().get());
 
   if (IsRemoteTest()) {
     DCHECK(impl_thread_);
     layer_tree_host_ = LayerTreeHostForTesting::Create(
         this, mode_, client_.get(), &remote_proto_channel_bridge_.channel_main,
         nullptr, nullptr, task_graph_runner_.get(), settings_,
         base::ThreadTaskRunnerHandle::Get(), nullptr,
-        std::move(external_begin_frame_source));
+        std::move(external_begin_frame_source),
+        image_serialization_processor_.get());
     DCHECK(remote_proto_channel_bridge_.channel_main.HasReceiver());
   } else {
     layer_tree_host_ = LayerTreeHostForTesting::Create(
         this, mode_, client_.get(), nullptr, shared_bitmap_manager_.get(),
         gpu_memory_buffer_manager_.get(), task_graph_runner_.get(), settings_,
         base::ThreadTaskRunnerHandle::Get(),
         impl_thread_ ? impl_thread_->task_runner() : NULL,
-        std::move(external_begin_frame_source));
+        std::move(external_begin_frame_source),
+        image_serialization_processor_.get());
   }
 
   ASSERT_TRUE(layer_tree_host_);
 
   started_ = true;
   beginning_ = true;
   SetupTree();
   WillBeginTest();
   BeginTest();
   beginning_ = false;
@@ skipping 226 matching lines @@
   DCHECK(proto.message_type() ==
          proto::CompositorMessageToImpl::INITIALIZE_IMPL);
 
   proto::InitializeImpl initialize_proto = proto.initialize_impl_message();
   LayerTreeSettings settings;
   settings.FromProtobuf(initialize_proto.layer_tree_settings());
   settings.abort_commit_before_output_surface_creation = false;
   remote_client_layer_tree_host_ = LayerTreeHostForTesting::Create(
       this, mode_, client_.get(), &remote_proto_channel_bridge_.channel_impl,
       nullptr, nullptr, task_graph_runner_.get(), settings,
-      base::ThreadTaskRunnerHandle::Get(), impl_thread_->task_runner(),
-      nullptr);
+      base::ThreadTaskRunnerHandle::Get(), impl_thread_->task_runner(), nullptr,
+      image_serialization_processor_.get());
 
   DCHECK(remote_proto_channel_bridge_.channel_impl.HasReceiver());
   DCHECK(task_runner_provider()->HasImplThread());
 }
 
 TaskGraphRunner* LayerTreeTest::task_graph_runner() const {
   return task_graph_runner_.get();
 }
 
 TaskRunnerProvider* LayerTreeTest::task_runner_provider() const {
@@ skipping 56 matching lines @@
 
 RemoteChannelImplForTest* LayerTreeTest::GetRemoteChannelImplForTest() const {
   DCHECK(IsRemoteTest());
   DCHECK(remote_client_layer_tree_host_);
 
   return static_cast<RemoteChannelImplForTest*>(
       remote_client_layer_tree_host_->proxy());
 }
 
 }  // namespace cc