cc: Do GatherPixelRefs from skia at record time

cc/resources/picture.cc

 // 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.
 
+#include "cc/resources/picture.h"
+
+#include <algorithm>
+#include <set>
+
 #include "base/debug/trace_event.h"
 #include "cc/debug/rendering_stats.h"
 #include "cc/layers/content_layer_client.h"
-#include "cc/resources/picture.h"
 #include "skia/ext/analysis_canvas.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkDrawFilter.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/utils/SkPictureUtils.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 
 namespace {
 // URI label for a lazily decoded SkPixelRef.
 const char kLabelLazyDecoded[] = "lazy";
+// Size of each of the grid cells for storing lazy pixel refs.
+const gfx::Size kRegionSize(512, 512);

[reveman, 2013/04/17 00:42:57]

only POD is allowed for objects with static storage. you would have to make this
int kRegionWidth and int kRegionHeight..

 
 class DisableLCDTextFilter : public SkDrawFilter {
  public:
   // SkDrawFilter interface.
   virtual bool filter(SkPaint* paint, SkDrawFilter::Type type) OVERRIDE {
     if (type != SkDrawFilter::kText_Type)
       return true;
 
     paint->setLCDRenderText(false);
     return true;
   }
 };
 }  // namespace
 
 namespace cc {
 
 scoped_refptr<Picture> Picture::Create(gfx::Rect layer_rect) {
   return make_scoped_refptr(new Picture(layer_rect));
 }
 
 Picture::Picture(gfx::Rect layer_rect)
     : layer_rect_(layer_rect) {
 }
 
 Picture::Picture(const skia::RefPtr<SkPicture>& picture,
                  gfx::Rect layer_rect,
-                 gfx::Rect opaque_rect) :
+                 gfx::Rect opaque_rect,
+                 const PixelRefsMap& lazy_pixel_refs) :
     layer_rect_(layer_rect),
     opaque_rect_(opaque_rect),
-    picture_(picture) {
+    picture_(picture),
+    lazy_pixel_refs_(lazy_pixel_refs) {
 }
 
 Picture::~Picture() {
 }
 
 scoped_refptr<Picture> Picture::GetCloneForDrawingOnThread(
     unsigned thread_index) const {
   // SkPicture is not thread-safe to rasterize with, this returns a clone
   // to rasterize with on a specific thread.
   CHECK_GT(clones_.size(), thread_index);
   return clones_[thread_index];
 }
 
 void Picture::CloneForDrawing(int num_threads) {
   TRACE_EVENT1("cc", "Picture::CloneForDrawing", "num_threads", num_threads);
 
   DCHECK(picture_);
   scoped_ptr<SkPicture[]> clones(new SkPicture[num_threads]);
   picture_->clone(&clones[0], num_threads);
 
   clones_.clear();
   for (int i = 0; i < num_threads; i++) {
     scoped_refptr<Picture> clone = make_scoped_refptr(
         new Picture(skia::AdoptRef(new SkPicture(clones[i])),
                     layer_rect_,
-                    opaque_rect_));
+                    opaque_rect_,
+                    lazy_pixel_refs_));
     clones_.push_back(clone);
   }
 }
 
 void Picture::Record(ContentLayerClient* painter,
                      RenderingStats* stats,
                      const SkTileGridPicture::TileGridInfo& tile_grid_info) {
   TRACE_EVENT2("cc", "Picture::Record",
                "width", layer_rect_.width(), "height", layer_rect_.height());
 
@@ skipping 31 matching lines @@
   if (stats) {
     stats->total_paint_time += base::TimeTicks::Now() - begin_paint_time;
     stats->total_pixels_painted +=
         layer_rect_.width() * layer_rect_.height();
   }
 
   canvas->restore();
   picture_->endRecording();
 
   opaque_rect_ = gfx::ToEnclosedRect(opaque_layer_rect);
+
+  GatherAllPixelRefs();
 }
 
 void Picture::Raster(
     SkCanvas* canvas,
     gfx::Rect content_rect,
     float contents_scale,
     bool enable_lcd_text) {
   TRACE_EVENT2("cc", "Picture::Raster",
                "layer width", layer_rect_.width(),
                "layer height", layer_rect_.height());
   DCHECK(picture_);
 
   DisableLCDTextFilter disable_lcd_text_filter;
 
   canvas->save();
   canvas->clipRect(gfx::RectToSkRect(content_rect));
   canvas->scale(contents_scale, contents_scale);
   canvas->translate(layer_rect_.x(), layer_rect_.y());
   // Pictures by default have LCD text enabled.
   if (!enable_lcd_text)
     canvas->setDrawFilter(&disable_lcd_text_filter);
   canvas->drawPicture(*picture_);
   canvas->restore();
 }
 
 void Picture::GatherPixelRefs(const gfx::Rect& layer_rect,
                               std::list<skia::LazyPixelRef*>& pixel_ref_list) {

[reveman, 2013/04/17 00:42:57]

How about adding a Picture::PixelRefIterator instead of having this function
that returns a list?

I think that would be cleaner to use in the tile manager. It could even be
allowed to iterate over the same pixel ref twice as the tile manager needs to
handle that properly anyhow.

+  std::list<skia::LazyPixelRef*> pixel_refs;
+  // The min/max point calculation assumes that layer_rect
+  // origin's coordinates are non-negative.
+  DCHECK(layer_rect.x() >= 0 && layer_rect.y() >= 0);
+  gfx::Point min_point(
+    (layer_rect.x() / kRegionSize.width()) * kRegionSize.width(),
+    (layer_rect.y() / kRegionSize.height()) * kRegionSize.height());
+  gfx::Point max_point(
+    (layer_rect.right() / kRegionSize.width()) * kRegionSize.width(),
+    (layer_rect.bottom() / kRegionSize.height()) * kRegionSize.height());
+
+  for (int y = min_point.y(); y <= max_point.y(); y += kRegionSize.height()) {
+    for (int x = min_point.x(); x <= max_point.x(); x += kRegionSize.width()) {
+      PixelRefsMap::const_iterator iter =
+          lazy_pixel_refs_.find(std::make_pair(x, y));
+      if (iter != lazy_pixel_refs_.end()) {
+        pixel_refs.insert(pixel_refs.end(),
+                          iter->second.begin(),
+                          iter->second.end());
+      }
+    }
+  }
+  std::set<skia::LazyPixelRef*> unique_pixel_refs(pixel_refs.begin(),
+                                                  pixel_refs.end());
+  pixel_ref_list.insert(pixel_ref_list.end(),
+                        unique_pixel_refs.begin(),
+                        unique_pixel_refs.end());
+}
+
+void Picture::GatherPixelRefsFromSkia(
+    const gfx::Rect& layer_rect,
+    std::list<skia::LazyPixelRef*>& pixel_ref_list) {
   DCHECK(picture_);
   SkData* pixel_refs = SkPictureUtils::GatherPixelRefs(
       picture_.get(), SkRect::MakeXYWH(layer_rect.x(),
                                        layer_rect.y(),
                                        layer_rect.width(),
                                        layer_rect.height()));
   if (!pixel_refs)
     return;
 
   void* data = const_cast<void*>(pixel_refs->data());
   if (!data) {
     pixel_refs->unref();
     return;
   }
 
   SkPixelRef** refs = reinterpret_cast<SkPixelRef**>(data);
   for (size_t i = 0; i < pixel_refs->size() / sizeof(*refs); ++i) {
     if (*refs && (*refs)->getURI() && !strncmp(
         (*refs)->getURI(), kLabelLazyDecoded, 4)) {
       pixel_ref_list.push_back(static_cast<skia::LazyPixelRef*>(*refs));
     }
     refs++;
   }
   pixel_refs->unref();
 }
 
+void Picture::GatherAllPixelRefs() {
+  // Capture pixel refs for this picture in a grid
+  // with kRegionSize sized cells.
+  for (int y = layer_rect_.y();
+      y < layer_rect_.bottom();
+      y += kRegionSize.height()) {
+    for (int x = layer_rect_.x();
+        x < layer_rect_.right();
+        x += kRegionSize.width()) {
+      gfx::Size extent(
+          std::min(kRegionSize.width(), layer_rect_.right() - x),
+          std::min(kRegionSize.height(), layer_rect_.bottom() - y));
+      gfx::Rect rect(x, y, extent.width(), extent.height());
+
+      std::list<skia::LazyPixelRef*> lazy_pixel_refs;
+      GatherPixelRefsFromSkia(rect, lazy_pixel_refs);
+
+      // Only capture non-empty cells.
+      if (!lazy_pixel_refs.empty())
+        lazy_pixel_refs_[std::make_pair(x, y)].swap(lazy_pixel_refs);
+    }
+  }
+}
+
 }  // namespace cc