[blimp] Add SkPicture caching support.

cc/playback/recording_source_unittest.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 <vector>
 
 #include "base/memory/ptr_util.h"
 #include "cc/base/region.h"
 #include "cc/playback/raster_source.h"
 #include "cc/proto/recording_source.pb.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_image_serialization_processor.h"
+#include "cc/test/fake_picture_cache.h"
 #include "cc/test/fake_recording_source.h"
 #include "cc/test/skia_common.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 
 namespace cc {
 namespace {
 
 std::unique_ptr<FakeRecordingSource> CreateRecordingSource(
     const gfx::Rect& viewport) {
   gfx::Rect layer_rect(viewport.right(), viewport.bottom());
   std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateRecordingSource(viewport, layer_rect.size());
   return recording_source;
 }
 
 scoped_refptr<RasterSource> CreateRasterSource(
     FakeRecordingSource* recording_source) {
   bool can_use_lcd_text = true;
   return RasterSource::CreateFromRecordingSource(recording_source,
                                                  can_use_lcd_text);
 }
 
 void ValidateRecordingSourceSerialization(FakeRecordingSource* source) {
   std::unique_ptr<FakeImageSerializationProcessor>
       fake_image_serialization_processor =
           base::WrapUnique(new FakeImageSerializationProcessor);
+  std::unique_ptr<EnginePictureCache> fake_engine_picture_cache =
+      fake_image_serialization_processor->CreateEnginePictureCache();
+  std::unique_ptr<ClientPictureCache> fake_client_picture_cache =
+      fake_image_serialization_processor->CreateClientPictureCache();
 
+  source->SetEnginePictureCache(fake_engine_picture_cache.get());
   proto::RecordingSource proto;
-  source->ToProtobuf(&proto, fake_image_serialization_processor.get());
+  source->ToProtobuf(&proto);
 
   FakeRecordingSource new_source;
-  new_source.FromProtobuf(proto, fake_image_serialization_processor.get());
+  new_source.SetClientPictureCache(fake_client_picture_cache.get());
+  new_source.FromProtobuf(proto);
 
   EXPECT_TRUE(source->EqualsTo(new_source));
+
+  // The EnginePictureCache and ClientPictureCache go out of scope, so clear
+  // the pointers.
+  source->SetEnginePictureCache(nullptr);
+  new_source.SetClientPictureCache(nullptr);
 }
 
 TEST(RecordingSourceTest, TestNullDisplayListSerialization) {
   gfx::Rect recorded_viewport(0, 0, 256, 256);
 
   std::unique_ptr<FakeRecordingSource> recording_source =
       CreateRecordingSource(recorded_viewport);
   recording_source->SetDisplayListUsesCachedPicture(false);
   recording_source->SetGenerateDiscardableImagesMetadata(true);
   recording_source->Rerecord();
@@ skipping 368 matching lines @@
                                               &images);
     EXPECT_EQ(3u, images.size());
     EXPECT_TRUE(images[0].image() == discardable_image[0][0]);
     EXPECT_TRUE(images[1].image() == discardable_image[0][1]);
     EXPECT_TRUE(images[2].image() == discardable_image[1][1]);
   }
 }
 
 }  // namespace
 }  // namespace cc