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 int kRegionWidth = 512;
+const int kRegionHeight = 512;
 
 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) {
+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 kRegionWidth by kRegionHeight cells.
+  for (int y = layer_rect_.y(); y < layer_rect_.bottom(); y += kRegionHeight) {
+    for (int x = layer_rect_.x(); x < layer_rect_.right(); x += kRegionWidth) {
+      gfx::Size extent(std::min(kRegionWidth, layer_rect_.right() - x),
+                       std::min(kRegionHeight, 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);
+    }
+  }
+}
+
+Picture::LazyPixelRefsIterator::LazyPixelRefsIterator()

[enne (OOO), 2013/04/22 16:47:26]

What's the default ctor for?

+  : picture_(0),
+    current_pixel_ref_(0),
+    min_point_(-1, -1),
+    max_point_(-1, -1),
+    current_x_(0),
+    current_y_(0) {
+}
+
+Picture::LazyPixelRefsIterator::LazyPixelRefsIterator(

[enne (OOO), 2013/04/22 16:47:26]

To be consistent with other code, could you call this PixelRefIterator? 
Generally data structures seem to be named in the style of ValueIterator or
ValueMap, but not ValuesMap or ValuesIterator.

+    gfx::Rect layer_rect,
+    const Picture* picture)
+    : picture_(picture),
+      current_pixel_ref_(NULL) {
+  // The min/max point calculation assumes that layer_rect
+  // origin's coordinates are non-negative.
+  DCHECK(layer_rect.x() >= 0 && layer_rect.y() >= 0);
+  min_point_ = gfx::Point(
+      (layer_rect.x() / kRegionWidth) * kRegionWidth,
+      (layer_rect.y() / kRegionHeight) * kRegionHeight);
+  max_point_ = gfx::Point(
+      (layer_rect.right() / kRegionWidth) * kRegionWidth,
+      (layer_rect.bottom() / kRegionHeight) * kRegionHeight);
+
+  // Make the current x be kRegionWidth less than min point, so that
+  // the first increment will point at min_point_.
+  current_x_ = min_point_.x() - kRegionWidth;
+  current_y_ = min_point_.y();
+  ++(*this);
+}
+
+Picture::LazyPixelRefsIterator::~LazyPixelRefsIterator() {
+}
+
+Picture::LazyPixelRefsIterator& Picture::LazyPixelRefsIterator::operator++() {
+  // If we're not at the end of the list, then just get the next item.
+  if (!current_list_.empty()) {
+    current_pixel_ref_ = current_list_.front();
+    current_list_.pop_front();
+    return *this;
+  }
+
+  // If we already passed the max y, do nothing.
+  if (current_y_ > max_point_.y())
+    return *this;
+
+  while (true) {
+    // Advance the current grid cell.
+    current_x_ += kRegionWidth;
+    if (current_x_ > max_point_.x()) {
+      current_y_ += kRegionHeight;
+      current_x_ = min_point_.x();
+      if (current_y_ > max_point_.y()) {
+        current_pixel_ref_ = NULL;
+        break;
+      }
+    }
+
+    // If there are no pixel refs at this grid cell, keep incrementing.
+    PixelRefsMap::const_iterator iter =
+        picture_->lazy_pixel_refs_.find(std::make_pair(current_x_, current_y_));
+    if (iter == picture_->lazy_pixel_refs_.end() || iter->second.empty())
+      continue;
+
+    // We found a non-empty list: store it and get the first pixel ref.
+    current_list_ = iter->second;
+    current_pixel_ref_ = current_list_.front();
+    current_list_.pop_front();
+    break;
+  }
+  return *this;
+}
+
 }  // namespace cc