cc: Clean up RecordingSource API

cc/layers/picture_layer.h

 // Copyright 2012 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_LAYERS_PICTURE_LAYER_H_
 #define CC_LAYERS_PICTURE_LAYER_H_
 
 #include "base/macros.h"
 #include "cc/base/invalidation_region.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/micro_benchmark_controller.h"
 #include "cc/layers/layer.h"
 
+namespace {

[vmpstr, 2016/07/20 22:18:10]

I don't think anonymous namespace in a header file is useful. This variable
would still be visible by any file that includes this header. Can we move this
to the .cc file, even if it means that the ctor will actually have to initialize
this variable?

[Menglin, 2016/07/20 22:39:31]

OK.

+
+#ifdef NDEBUG
+const bool kDefaultClearCanvasSetting = false;
+#else
+const bool kDefaultClearCanvasSetting = true;
+#endif
+
+}  // namespace
+
 namespace cc {
 
 class ContentLayerClient;
-class RecordingSource;
+class DisplayItemList;
+class RasterSource;
 class ResourceUpdateQueue;
 
+struct PictureLayerData {

[vmpstr, 2016/07/20 22:18:10]

These should probably move to separate files. 

[Menglin, 2016/07/20 22:39:31]

Some header file just for these two structs?

[vmpstr, 2016/07/20 23:55:55]

Or even a header per... The rule is usually one class per file.. See here for
example
https://cs.chromium.org/chromium/src/cc/playback/draw_image.h?q=draw_image&sq...

draw_image is also very small, but it has it's own .h/.cc

+  PictureLayerData();
+  ~PictureLayerData();
+
+  gfx::Size size;

[vmpstr, 2016/07/20 22:18:10]

Can you rename this to something more meaningful?

PictureLayerData::size makes me think this is layer size? Is it? Or is this the
recorded region size?

Or maybe we can rename PictureLayerData to something... hmm Maybe
PictureLayerRasterData? I'm not too sure... danakj@, do you have an opinion
here?

[Menglin, 2016/07/20 22:39:31]

Looking at code here, I think it's the recorded region size
https://cs.chromium.org/chromium/src/cc/playback/recording_source.cc?dr=CSs&s...

Maybe I can leave the member name as it is, but only change the struct name, if
we can get a proper struct name

[vmpstr, 2016/07/20 23:55:54]

Yeah I think that's a good idea. 

+  int slow_down_raster_scale_factor_for_debug = 0;
+  bool generate_discardable_images_metadata = false;
+  bool requires_clear = false;
+  bool is_solid_color = false;
+  bool clear_canvas_with_debug_color = kDefaultClearCanvasSetting;
+  SkColor solid_color = SK_ColorTRANSPARENT;
+  SkColor background_color = SK_ColorTRANSPARENT;
+};
+
+// Encapsulates all data received from the ContentLayerClient.
+struct ContentLayerClientData {
+  ContentLayerClientData();
+  ContentLayerClientData(const ContentLayerClientData&);
+  ~ContentLayerClientData();
+
+  gfx::Rect recorded_viewport;
+  scoped_refptr<DisplayItemList> display_list;
+  size_t painter_reported_memory_usage = 0;
+};
+
 class CC_EXPORT PictureLayer : public Layer {
  public:
+  // TODO(schenney) Remove RECORD_WITH_SK_NULL_CANVAS when we no longer
+  // support a non-Slimming Paint path.
+  enum RecordingMode {
+    RECORD_NORMALLY,
+    RECORD_WITH_SK_NULL_CANVAS,
+    RECORD_WITH_PAINTING_DISABLED,
+    RECORD_WITH_CACHING_DISABLED,
+    RECORD_WITH_CONSTRUCTION_DISABLED,
+    RECORD_WITH_SUBSEQUENCE_CACHING_DISABLED,
+    RECORDING_MODE_COUNT,  // Must be the last entry.
+  };
+
   static scoped_refptr<PictureLayer> Create(ContentLayerClient* client);
 
   void ClearClient();
 
   void SetNearestNeighbor(bool nearest_neighbor);
 
   // Layer interface.
   std::unique_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl) override;
   void SetLayerTreeHost(LayerTreeHost* host) override;
   void PushPropertiesTo(LayerImpl* layer) override;
   void SetNeedsDisplayRect(const gfx::Rect& layer_rect) override;
   bool Update() override;
   void SetIsMask(bool is_mask) override;
   sk_sp<SkPicture> GetPicture() const override;
   bool IsSuitableForGpuRasterization() const override;
 
   void RunMicroBenchmark(MicroBenchmark* benchmark) override;
 
   ContentLayerClient* client() { return inputs_.client; }
 
-  RecordingSource* GetRecordingSourceForTesting() {
-    return recording_source_.get();
-  }
+  bool UpdateAndExpandInvalidation(
+      Region* invalidation,
+      const gfx::Size& layer_size,
+      PictureLayer::RecordingMode recording_mode,
+      PictureLayerData* layer_data,
+      ContentLayerClientData* client_data,
+      InvalidationRegion* invalidation_state) const;
+
+  void ResetLayerAndClientData();
+  void SetGenerateDiscardableImagesMetadata(bool generate_metadata);
+  void SetBackgroundColorSimple(SkColor background_color);
+  void SetRequiresClear(bool requires_clear);
+  void SetNeedsDisplayRectSimple(const gfx::Rect& layer_rect);
+  gfx::Size GetSizeInLayerData() const;
+  const DisplayItemList* GetDisplayItemList();
+
+  // These functions are virtual for testing.
+  virtual scoped_refptr<RasterSource> CreateRasterSource(
+      const PictureLayerData& layer_data,
+      const ContentLayerClientData& client_data,
+      bool can_use_lcd_text) const;
 
  protected:
   explicit PictureLayer(ContentLayerClient* client);
-  // Allow tests to inject a recording source.
+  // Tests will pass in data instead of a RecordingSource.
   PictureLayer(ContentLayerClient* client,
-               std::unique_ptr<RecordingSource> source);
+               const PictureLayerData& layer_data,
+               const ContentLayerClientData& client_data);
   ~PictureLayer() override;
 
   bool HasDrawableContent() const override;
   void SetTypeForProtoSerialization(proto::LayerNode* proto) const override;
   void LayerSpecificPropertiesToProto(proto::LayerProperties* proto) override;
   void FromLayerSpecificPropertiesProto(
       const proto::LayerProperties& proto) override;
 
   bool is_mask() const { return is_mask_; }
 
+  PictureLayerData layer_data_;
+  ContentLayerClientData client_data_;
+
  private:
   friend class TestSerializationPictureLayer;
 
   void DropRecordingSourceContentIfInvalid();
 
-  std::unique_ptr<RecordingSource> recording_source_;
+  void UpdateInvalidationForNewViewport(const gfx::Rect& old_recorded_viewport,
+                                        const gfx::Rect& new_recorded_viewport,
+                                        Region* invalidation) const;
+
+  void FinishDisplayItemListUpdate(PictureLayerData* layer_data,
+                                   ContentLayerClientData* client_data) const;
+
+  void DetermineIfSolidColor(PictureLayerData* layer_data,
+                             ContentLayerClientData* client_data) const;
+
   devtools_instrumentation::
       ScopedLayerObjectTracker instrumentation_object_tracker_;
 
   Region last_updated_invalidation_;
 
   int update_source_frame_number_;
   bool is_mask_;
 
   // Encapsulates all data, callbacks or interfaces received from the embedder.
   struct Inputs {
     ContentLayerClient* client = nullptr;
     bool nearest_neighbor = false;
   };
 
   Inputs inputs_;
 
+  InvalidationRegion invalidation_;
+
   DISALLOW_COPY_AND_ASSIGN(PictureLayer);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYERS_PICTURE_LAYER_H_