cc: Clean up RecordingSource API

cc/test/fake_recording_source.h

 // 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.
 
 #ifndef CC_TEST_FAKE_RECORDING_SOURCE_H_
 #define CC_TEST_FAKE_RECORDING_SOURCE_H_
 
 #include <stddef.h>
 
 #include "cc/base/region.h"
@@ skipping 11 matching lines @@
 
 // This class provides method for test to add bitmap and draw rect to content
 // layer client. This class also provides function to rerecord to generate a new
 // display list.
 class FakeRecordingSource : public RecordingSource {
  public:
   FakeRecordingSource();
   ~FakeRecordingSource() override {}
 
   static std::unique_ptr<FakeRecordingSource> CreateRecordingSource(
       const gfx::Rect& recorded_viewport,

[Menglin, 2016/07/26 17:49:42]

Do I still need to care about the recorded_viewport here? I feel it doesn't
matter so I kept it. 

[vmpstr, 2016/07/27 18:18:37]

Where do we call SetRecordedViewport aside from tests?

[Menglin, 2016/07/27 19:17:48]

the only place it is called besides in this file is in fake_raster_source
https://cs.chromium.org/chromium/src/cc/test/fake_raster_source.cc?q=SetRecor...
i feel it's just using recorded_viewport between recording source and raster
source

[vmpstr, 2016/07/28 18:19:58]

If that's only called in test, then maybe we can just remove the function? I'm
not sure if any test relies on that to set up some sort of a special recording
source

[Menglin, 2016/07/29 21:32:55]

These two functions are called by FakeRasterSource to set up a special raster
source I think. For example, here
https://cs.chromium.org/chromium/src/cc/test/fake_raster_source.cc?sq=package...
And there are many similar places. So I think I should keep them.

       const gfx::Size& layer_bounds) {
     std::unique_ptr<FakeRecordingSource> recording_source(
         new FakeRecordingSource);
     recording_source->SetRecordedViewport(recorded_viewport);
     recording_source->SetLayerBounds(layer_bounds);
     return recording_source;
   }
 
   static std::unique_ptr<FakeRecordingSource> CreateFilledRecordingSource(
       const gfx::Size& layer_bounds) {
     std::unique_ptr<FakeRecordingSource> recording_source(
         new FakeRecordingSource);
     recording_source->SetRecordedViewport(gfx::Rect(layer_bounds));

[Menglin, 2016/07/26 17:49:42]

same here

     recording_source->SetLayerBounds(layer_bounds);
     return recording_source;
   }
 
   // RecordingSource overrides.
   scoped_refptr<RasterSource> CreateRasterSource(
       bool can_use_lcd) const override;
-  bool IsSuitableForGpuRasterization() const override;
 
   void SetDisplayListUsesCachedPicture(bool use_cached_picture) {
     client_.set_display_list_use_cached_picture(use_cached_picture);
   }
 
   void SetRecordedViewport(const gfx::Rect& recorded_viewport) {
     recorded_viewport_ = recorded_viewport;
   }
 
   void SetLayerBounds(const gfx::Size& layer_bounds) {
     size_ = layer_bounds;
     client_.set_bounds(layer_bounds);
   }
 
   void SetClearCanvasWithDebugColor(bool clear) {
     clear_canvas_with_debug_color_ = clear;
   }
 
   void Rerecord() {
     SetNeedsDisplayRect(recorded_viewport_);
     Region invalidation;
-    UpdateAndExpandInvalidation(&client_, &invalidation, size_, 0,
-                                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();
+    UpdateAndExpandInvalidation(&client_, &invalidation, size_,
+                                new_recorded_viewport, display_list,
+                                painter_reported_memory_usage);
   }
 
   void add_draw_rect(const gfx::Rect& rect) {
     client_.add_draw_rect(rect, default_paint_);
   }
 
   void add_draw_rect_with_paint(const gfx::Rect& rect, const SkPaint& paint) {
     client_.add_draw_rect(rect, paint);
   }
 
@@ skipping 25 matching lines @@
 
   void set_reported_memory_usage(size_t reported_memory_usage) {
     client_.set_reported_memory_usage(reported_memory_usage);
   }
 
   void reset_draws() {
     client_ = FakeContentLayerClient();
     client_.set_bounds(size_);
   }
 
-  void SetForceUnsuitableForGpuRasterization(bool flag) {
-    force_unsuitable_for_gpu_rasterization_ = flag;
-  }
-
   void SetPlaybackAllowedEvent(base::WaitableEvent* event) {
     playback_allowed_event_ = event;
   }
 
-  DisplayItemList* display_list() const { return display_list_.get(); }
-
   // Checks that the basic properties of the |other| match |this|.  For the
   // DisplayItemList, it checks that the painted result matches the painted
   // result of |other|.
   bool EqualsTo(const FakeRecordingSource& other);
 
  private:
   FakeContentLayerClient client_;
   SkPaint default_paint_;
-  bool force_unsuitable_for_gpu_rasterization_;
   base::WaitableEvent* playback_allowed_event_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TEST_FAKE_RECORDING_SOURCE_H_