cc: Optimize decode scheduling for checker-images.

cc/tiles/tile.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_TILES_TILE_H_
 #define CC_TILES_TILE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "cc/paint/draw_image.h"
 #include "cc/raster/tile_task.h"
 #include "cc/tiles/tile_draw_info.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace cc {
 
 class PictureLayerTiling;
 class TileManager;
 
@@ skipping 83 matching lines @@
 
   bool HasRasterTask() const { return !!raster_task_.get(); }
 
   void set_solid_color_analysis_performed(bool performed) {
     is_solid_color_analysis_performed_ = performed;
   }
   bool is_solid_color_analysis_performed() const {
     return is_solid_color_analysis_performed_;
   }
 
+  void SetImageAnalysisResult(
+      std::vector<DrawImage> images_to_decode_before_raster,
+      std::vector<sk_sp<const SkImage>> images_to_checker);
+  bool is_image_analysis_performed() const {
+    return is_image_analysis_performed_;
+  }
+  const std::vector<DrawImage>& images_to_decode_before_raster() const {
+    return images_to_decode_before_raster_;
+  }
+  const std::vector<sk_sp<const SkImage>>& images_to_checker() const {
+    return images_to_checker_;
+  }
+
+  bool set_raster_task_scheduled_with_checker_images(bool has_checker_images) {
+    bool previous_raster_task_scheduled_with_checker_images =
+        raster_task_scheduled_with_checker_images_;
+    raster_task_scheduled_with_checker_images_ = has_checker_images;
+    return previous_raster_task_scheduled_with_checker_images;
+  }
+  bool raster_task_scheduled_with_checker_images() const {
+    return raster_task_scheduled_with_checker_images_;
+  }
+
   const PictureLayerTiling* tiling() const { return tiling_; }
   void set_tiling(const PictureLayerTiling* tiling) { tiling_ = tiling; }
 
  private:
   friend class TileManager;
   friend class FakeTileManager;
   friend class FakePictureLayerImpl;
 
   // Methods called by by tile manager.
   Tile(TileManager* tile_manager,
        const CreateInfo& info,
        int layer_id,
        int source_frame_number,
        int flags);
 
   TileManager* const tile_manager_;
   const PictureLayerTiling* tiling_;
   const gfx::Rect content_rect_;
   const gfx::Rect enclosing_layer_rect_;
   const float contents_scale_;
 
+  // Image analysis is used partitions the images in a tile into 2 sets:
+  // 1) The images for which the decode must be available *before* the
+  //    rasterization of a tile can be started.
+  // 2) The images which are checkered, i.e., will be skipped when rasterizing
+  //    this tile.
+  // Note that these sets are only valid for tiles that are considered for
+  // rasterization with images. For instance, for low resolution tiles, all
+  // images are skipped.
+  bool is_image_analysis_performed_ = false;
+  std::vector<DrawImage> images_to_decode_before_raster_;

[vmpstr, 2017/04/18 00:20:00]

Don't put this here, because it might be very memory inefficient.

+  std::vector<sk_sp<const SkImage>> images_to_checker_;
+
   TileDrawInfo draw_info_;
 
   const int layer_id_;
   const int source_frame_number_;
   const int flags_;
   const int tiling_i_index_;
   const int tiling_j_index_;
   bool required_for_activation_ : 1;
   bool required_for_draw_ : 1;
   bool is_solid_color_analysis_performed_ : 1;
 
   Id id_;
 
   // The rect bounding the changes in this Tile vs the previous tile it
   // replaced.
   gfx::Rect invalidated_content_rect_;
   // The |id_| of the Tile that was invalidated and replaced by this tile.
   Id invalidated_id_;
 
   unsigned scheduled_priority_;
+
+  // Set to true if there is a raster task scheduled for this tile that will
+  // rasterize a resource with checker images.
+  bool raster_task_scheduled_with_checker_images_ = false;
   scoped_refptr<TileTask> raster_task_;
 
   DISALLOW_COPY_AND_ASSIGN(Tile);
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_TILE_H_