cc/layers/picture_layer_impl.h

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CC_LAYERS_PICTURE_LAYER_IMPL_H_
   6 #define CC_LAYERS_PICTURE_LAYER_IMPL_H_
   7
   8 #include <set>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "cc/base/cc_export.h"
  13 #include "cc/base/scoped_ptr_vector.h"
  14 #include "cc/layers/layer_impl.h"
  15 #include "cc/resources/picture_layer_tiling.h"
  16 #include "cc/resources/picture_layer_tiling_set.h"
  17 #include "cc/resources/picture_pile_impl.h"
  18 #include "cc/resources/tiling_set_eviction_queue.h"
  19 #include "skia/ext/refptr.h"
  20 #include "third_party/skia/include/core/SkPicture.h"
  21
  22 namespace cc {
  23
  24 struct AppendQuadsData;
  25 class MicroBenchmarkImpl;
  26 class Tile;
  27
  28 class CC_EXPORT PictureLayerImpl
  29     : public LayerImpl,
  30       NON_EXPORTED_BASE(public PictureLayerTilingClient) {
  31  public:
  32   struct CC_EXPORT Pair {
  33     Pair();
  34     Pair(PictureLayerImpl* active_layer, PictureLayerImpl* pending_layer);
  35     ~Pair();
  36
  37     PictureLayerImpl* active;
  38     PictureLayerImpl* pending;
  39   };
  40
  41   static scoped_ptr<PictureLayerImpl> Create(
  42       LayerTreeImpl* tree_impl,
  43       int id,
  44       bool is_mask,
  45       scoped_refptr<SyncedScrollOffset> scroll_offset) {
  46     return make_scoped_ptr(
  47         new PictureLayerImpl(tree_impl, id, is_mask, scroll_offset));
  48   }
  49   ~PictureLayerImpl() override;
  50
  51   bool is_mask() const { return is_mask_; }
  52
  53   // LayerImpl overrides.
  54   const char* LayerTypeAsString() const override;
  55   scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl) override;
  56   void PushPropertiesTo(LayerImpl* layer) override;
  57   void AppendQuads(RenderPass* render_pass,
  58                    AppendQuadsData* append_quads_data) override;
  59   void NotifyTileStateChanged(const Tile* tile) override;
  60   void DidBeginTracing() override;
  61   void ReleaseResources() override;
  62   void RecreateResources() override;
  63   skia::RefPtr<SkPicture> GetPicture() override;
  64
  65   // PictureLayerTilingClient overrides.
  66   scoped_refptr<Tile> CreateTile(float contents_scale,
  67                                  const gfx::Rect& content_rect) override;
  68   gfx::Size CalculateTileSize(const gfx::Size& content_bounds) const override;
  69   const Region* GetPendingInvalidation() override;
  70   const PictureLayerTiling* GetPendingOrActiveTwinTiling(
  71       const PictureLayerTiling* tiling) const override;
  72   PictureLayerTiling* GetRecycledTwinTiling(
  73       const PictureLayerTiling* tiling) override;
  74   TilePriority::PriorityBin GetMaxTilePriorityBin() const override;
  75   WhichTree GetTree() const override;
  76   bool RequiresHighResToDraw() const override;
  77
  78   void UpdateRasterSource(scoped_refptr<RasterSource> raster_source,
  79                           Region* new_invalidation,
  80                           const PictureLayerTilingSet* pending_set);
  81   bool UpdateTiles(bool resourceless_software_draw);
  82   void UpdateCanUseLCDTextAfterCommit();
  83   bool RasterSourceUsesLCDText() const;
  84
  85   // Mask-related functions.
  86   void GetContentsResourceId(ResourceProvider::ResourceId* resource_id,
  87                              gfx::Size* resource_size) const override;
  88
  89   void SetNearestNeighbor(bool nearest_neighbor);
  90
  91   size_t GPUMemoryUsageInBytes() const override;
  92
  93   void RunMicroBenchmark(MicroBenchmarkImpl* benchmark) override;
  94
  95   bool CanHaveTilings() const;
  96
  97   PictureLayerTilingSet* picture_layer_tiling_set() { return tilings_.get(); }
  98
  99   // Functions used by tile manager.
 100   PictureLayerImpl* GetPendingOrActiveTwinLayer() const;
 101   bool IsOnActiveOrPendingTree() const;
 102   // Virtual for testing.
 103   virtual bool HasValidTilePriorities() const;
 104
 105   // Used for benchmarking
 106   RasterSource* GetRasterSource() const { return raster_source_.get(); }
 107
 108  protected:
 109   friend class LayerRasterTileIterator;
 110   using TileRequirementCheck = bool (PictureLayerTiling::*)(const Tile*) const;
 111
 112   PictureLayerImpl(LayerTreeImpl* tree_impl,
 113                    int id,
 114                    bool is_mask,
 115                    scoped_refptr<SyncedScrollOffset> scroll_offset);
 116   PictureLayerTiling* AddTiling(float contents_scale);
 117   void RemoveAllTilings();
 118   void AddTilingsForRasterScale();
 119   virtual bool ShouldAdjustRasterScale() const;
 120   virtual void RecalculateRasterScales();
 121   void CleanUpTilingsOnActiveLayer(
 122       const std::vector<PictureLayerTiling*>& used_tilings);
 123   float MinimumContentsScale() const;
 124   float MaximumContentsScale() const;
 125   void ResetRasterScale();
 126   void UpdateViewportRectForTilePriorityInContentSpace();
 127   PictureLayerImpl* GetRecycledTwinLayer() const;
 128
 129   void SanityCheckTilingState() const;
 130   bool ShouldAdjustRasterScaleDuringScaleAnimations() const;
 131
 132   void GetDebugBorderProperties(SkColor* color, float* width) const override;
 133   void GetAllTilesForTracing(std::set<const Tile*>* tiles) const override;
 134   void AsValueInto(base::trace_event::TracedValue* dict) const override;
 135
 136   virtual void UpdateIdealScales();
 137   float MaximumTilingContentsScale() const;
 138   scoped_ptr<PictureLayerTilingSet> CreatePictureLayerTilingSet();
 139
 140   PictureLayerImpl* twin_layer_;
 141
 142   scoped_ptr<PictureLayerTilingSet> tilings_;
 143   scoped_refptr<RasterSource> raster_source_;
 144   Region invalidation_;
 145
 146   float ideal_page_scale_;
 147   float ideal_device_scale_;
 148   float ideal_source_scale_;
 149   float ideal_contents_scale_;
 150
 151   float raster_page_scale_;
 152   float raster_device_scale_;
 153   float raster_source_scale_;
 154   float raster_contents_scale_;
 155   float low_res_raster_contents_scale_;
 156
 157   bool raster_source_scale_is_fixed_;
 158   bool was_screen_space_transform_animating_;
 159   bool only_used_low_res_last_append_quads_;
 160   const bool is_mask_;
 161
 162   bool nearest_neighbor_;
 163
 164   // Any draw properties derived from |transform|, |viewport|, and |clip|
 165   // parameters in LayerTreeHostImpl::SetExternalDrawConstraints are not valid
 166   // for prioritizing tiles during resourceless software draws. This is because
 167   // resourceless software draws can have wildly different transforms/viewports
 168   // from regular draws. Save a copy of the required draw properties of the last
 169   // frame that has a valid viewport for prioritizing tiles.
 170   gfx::Rect visible_rect_for_tile_priority_;
 171   gfx::Rect viewport_rect_for_tile_priority_in_content_space_;
 172
 173   // List of tilings that were used last time we appended quads. This can be
 174   // used as an optimization not to remove tilings if they are still being
 175   // drawn. Note that accessing this vector should only be done in the context
 176   // of comparing pointers, since objects pointed to are not guaranteed to
 177   // exist.
 178   std::vector<PictureLayerTiling*> last_append_quads_tilings_;
 179
 180   DISALLOW_COPY_AND_ASSIGN(PictureLayerImpl);
 181 };
 182
 183 }  // namespace cc
 184
 185 #endif  // CC_LAYERS_PICTURE_LAYER_IMPL_H_