cc: Clean up RecordingSource API

cc/layers/picture_layer_unittest.cc

 // Copyright 2013 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/layers/picture_layer.h"
 
 #include <stddef.h>
 
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 78 matching lines @@
     EXPECT_THAT(engine_picture_ids,
                 testing::UnorderedElementsAreArray(
                     client_picture_cache->GetAllUsedPictureIds()));
 
     // Validate that the PictureLayer specific fields are properly set.
     EXPECT_TRUE(recording_source()->EqualsTo(*layer->recording_source()));
     EXPECT_EQ(update_source_frame_number_, layer->update_source_frame_number_);
     EXPECT_EQ(is_mask_, layer->is_mask_);
     EXPECT_EQ(picture_layer_inputs_.nearest_neighbor,
               layer->picture_layer_inputs_.nearest_neighbor);
+    EXPECT_EQ(picture_layer_inputs_.recorded_viewport,
+              layer->picture_layer_inputs_.recorded_viewport);
+
+    // The DisplayItemLists are equal if they are both null or they are both not
+    // null and render to the same thing.
+    bool display_lists_equal = !picture_layer_inputs_.display_list &&
+                               !layer->picture_layer_inputs_.display_list;
+    if (picture_layer_inputs_.display_list &&
+        layer->picture_layer_inputs_.display_list) {
+      display_lists_equal = AreDisplayListDrawingResultsSame(
+          picture_layer_inputs_.recorded_viewport,
+          picture_layer_inputs_.display_list.get(),
+          layer->picture_layer_inputs_.display_list.get());
+    }
+    EXPECT_TRUE(display_lists_equal);
   }
 
   std::vector<uint32_t> GetPictureIds() {
     std::vector<uint32_t> ids;
     const DisplayItemList* display_list =
-        recording_source()->GetDisplayItemList();
+        picture_layer_inputs_.display_list.get();
     if (!display_list)
       return ids;
 
     for (auto it = display_list->begin(); it != display_list->end(); ++it) {
       sk_sp<const SkPicture> picture = it->GetPicture();
       if (!picture)
         continue;
 
       ids.push_back(picture->uniqueID());
     }
@@ skipping 323 matching lines @@
   FakeLayerTreeHostClient host_client;
   TestTaskGraphRunner task_graph_runner;
   std::unique_ptr<FakeLayerTreeHost> host =
       FakeLayerTreeHost::Create(&host_client, &task_graph_runner);
   host->SetRootLayer(layer);
 
   // Update layers to initialize the recording source.
   gfx::Size layer_bounds(200, 200);
   gfx::Rect layer_rect(layer_bounds);
   Region invalidation(layer_rect);
-  recording_source->UpdateAndExpandInvalidation(
-      client, &invalidation, layer_bounds, 1, RecordingSource::RECORD_NORMALLY);
+
+  gfx::Rect new_recorded_viewport = client->PaintableRegion();
+  scoped_refptr<DisplayItemList> display_list =
+      client->PaintContentsToDisplayList(
+          ContentLayerClient::PAINTING_BEHAVIOR_NORMAL);
+  size_t painter_reported_memory_usage =
+      client->GetApproximateUnsharedMemoryUsage();
+  recording_source->UpdateAndExpandInvalidation(&invalidation, layer_bounds,
+                                                new_recorded_viewport);
+  recording_source->UpdateDisplayItemList(display_list,
+                                          painter_reported_memory_usage);
 
   // Layer is suitable for gpu rasterization by default.
-  EXPECT_TRUE(recording_source->IsSuitableForGpuRasterization());
   EXPECT_TRUE(layer->IsSuitableForGpuRasterization());
 
   // Veto gpu rasterization.
-  recording_source->SetForceUnsuitableForGpuRasterization(true);
-  EXPECT_FALSE(recording_source->IsSuitableForGpuRasterization());
+  layer->set_force_unsuitable_for_gpu_rasterization(true);
   EXPECT_FALSE(layer->IsSuitableForGpuRasterization());
 }
 
 // PicturePile uses the source frame number as a unit for measuring invalidation
 // frequency. When a pile moves between compositors, the frame number increases
 // non-monotonically. This executes that code path under this scenario allowing
 // for the code to verify correctness with DCHECKs.
 TEST(PictureLayerTest, NonMonotonicSourceFrameNumber) {
   LayerTreeSettings settings = LayerTreeSettingsForTesting();
   settings.single_thread_proxy_scheduler = false;
@@ skipping 57 matching lines @@
   // Do a main frame, record the picture layers. The frame number has changed
   // non-monotonically.
   layer->SetNeedsDisplay();
   host2->Composite(base::TimeTicks::Now());
   EXPECT_EQ(3, layer->update_count());
   EXPECT_EQ(1, host2->source_frame_number());
 }
 
 }  // namespace
 }  // namespace cc