Home | History | Annotate | Download | only in resources 
      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_RESOURCES_PICTURE_PILE_IMPL_H_
      6 #define CC_RESOURCES_PICTURE_PILE_IMPL_H_
      7 
      8 #include <list>
      9 #include <map>
     10 #include <set>
     11 #include <vector>
     12 
     13 #include "base/time/time.h"
     14 #include "cc/base/cc_export.h"
     15 #include "cc/debug/rendering_stats_instrumentation.h"
     16 #include "cc/resources/picture_pile_base.h"
     17 #include "skia/ext/analysis_canvas.h"
     18 #include "skia/ext/refptr.h"
     19 #include "third_party/skia/include/core/SkPicture.h"
     20 
     21 namespace cc {
     22 
     23 class CC_EXPORT PicturePileImpl : public PicturePileBase {
     24  public:
     25   static scoped_refptr<PicturePileImpl> Create();
     26   static scoped_refptr<PicturePileImpl> CreateFromOther(
     27       const PicturePileBase* other);
     28 
     29   // Raster a subrect of this PicturePileImpl into the given canvas. It is
     30   // assumed that contents_scale has already been applied to this canvas.
     31   // Writes the total number of pixels rasterized and the time spent
     32   // rasterizing to the stats if the respective pointer is not NULL. When
     33   // slow-down-raster-scale-factor is set to a value greater than 1, the
     34   // reported rasterize time is the minimum measured value over all runs.
     35   void RasterDirect(
     36       SkCanvas* canvas,
     37       const gfx::Rect& canvas_rect,
     38       float contents_scale,
     39       RenderingStatsInstrumentation* rendering_stats_instrumentation);
     40 
     41   // Similar to the above RasterDirect method, but this is a convenience method
     42   // for when it is known that the raster is going to an intermediate bitmap
     43   // that itself will then be blended and thus that a canvas clear is required.
     44   // Note that this function may write outside the canvas_rect.
     45   void RasterToBitmap(
     46       SkCanvas* canvas,
     47       const gfx::Rect& canvas_rect,
     48       float contents_scale,
     49       RenderingStatsInstrumentation* stats_instrumentation) const;
     50 
     51   // Called when analyzing a tile. We can use AnalysisCanvas as
     52   // SkDrawPictureCallback, which allows us to early out from analysis.
     53   void RasterForAnalysis(
     54       skia::AnalysisCanvas* canvas,
     55       const gfx::Rect& canvas_rect,
     56       float contents_scale,
     57       RenderingStatsInstrumentation* stats_instrumentation) const;
     58 
     59   skia::RefPtr<SkPicture> GetFlattenedPicture();
     60 
     61   struct CC_EXPORT Analysis {
     62     Analysis();
     63     ~Analysis();
     64 
     65     bool is_solid_color;
     66     SkColor solid_color;
     67   };
     68 
     69   void AnalyzeInRect(const gfx::Rect& content_rect,
     70                      float contents_scale,
     71                      Analysis* analysis) const;
     72 
     73   void AnalyzeInRect(
     74       const gfx::Rect& content_rect,
     75       float contents_scale,
     76       Analysis* analysis,
     77       RenderingStatsInstrumentation* stats_instrumentation) const;
     78 
     79   class CC_EXPORT PixelRefIterator {
     80    public:
     81     PixelRefIterator(const gfx::Rect& content_rect,
     82                      float contents_scale,
     83                      const PicturePileImpl* picture_pile);
     84     ~PixelRefIterator();
     85 
     86     SkPixelRef* operator->() const { return *pixel_ref_iterator_; }
     87     SkPixelRef* operator*() const { return *pixel_ref_iterator_; }
     88     PixelRefIterator& operator++();
     89     operator bool() const { return pixel_ref_iterator_; }
     90 
     91    private:
     92     void AdvanceToTilePictureWithPixelRefs();
     93 
     94     const PicturePileImpl* picture_pile_;
     95     gfx::Rect layer_rect_;
     96     TilingData::Iterator tile_iterator_;
     97     Picture::PixelRefIterator pixel_ref_iterator_;
     98     std::set<const void*> processed_pictures_;
     99   };
    100 
    101   void DidBeginTracing();
    102 
    103  protected:
    104   friend class PicturePile;
    105   friend class PixelRefIterator;
    106 
    107   PicturePileImpl();
    108   explicit PicturePileImpl(const PicturePileBase* other);
    109   virtual ~PicturePileImpl();
    110 
    111  private:
    112   typedef std::map<const Picture*, Region> PictureRegionMap;
    113 
    114   void CoalesceRasters(const gfx::Rect& canvas_rect,
    115                        const gfx::Rect& content_rect,
    116                        float contents_scale,
    117                        PictureRegionMap* result) const;
    118 
    119   void RasterCommon(
    120       SkCanvas* canvas,
    121       SkDrawPictureCallback* callback,
    122       const gfx::Rect& canvas_rect,
    123       float contents_scale,
    124       RenderingStatsInstrumentation* rendering_stats_instrumentation,
    125       bool is_analysis) const;
    126 
    127   DISALLOW_COPY_AND_ASSIGN(PicturePileImpl);
    128 };
    129 
    130 }  // namespace cc
    131 
    132 #endif  // CC_RESOURCES_PICTURE_PILE_IMPL_H_
    133