cc: Use gather pixel refs with positions util.

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 <limits>
 #include <set>
 
 #include "base/base64.h"
 #include "base/debug/trace_event.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
 #include "cc/base/util.h"
 #include "cc/debug/rendering_stats.h"
 #include "cc/debug/traced_picture.h"
 #include "cc/debug/traced_value.h"
 #include "cc/layers/content_layer_client.h"
-#include "skia/ext/analysis_canvas.h"
+#include "skia/ext/lazy_pixel_ref_utils.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/core/SkStream.h"
 #include "third_party/skia/include/utils/SkPictureUtils.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
@@ skipping 54 matching lines @@
   // SkDrawFilter interface.
   virtual bool filter(SkPaint* paint, SkDrawFilter::Type type) OVERRIDE {
     if (type != SkDrawFilter::kText_Type)
       return true;
 
     paint->setLCDRenderText(false);
     return true;
   }
 };
 
-// URI label for a lazily decoded SkPixelRef.
-const char kLabelLazyDecoded[] = "lazy";
-
-void GatherPixelRefsForRect(
-    SkPicture* picture,
-    gfx::Rect rect,
-    Picture::PixelRefs* pixel_refs) {
-  DCHECK(picture);
-  SkData* pixel_ref_data = SkPictureUtils::GatherPixelRefs(
-      picture,
-      gfx::RectToSkRect(rect));
-  if (!pixel_ref_data)
-    return;
-
-  void* data = const_cast<void*>(pixel_ref_data->data());
-  if (!data) {
-    pixel_ref_data->unref();
-    return;
-  }
-
-  SkPixelRef** refs = reinterpret_cast<SkPixelRef**>(data);
-  for (size_t i = 0; i < pixel_ref_data->size() / sizeof(*refs); ++i) {
-    if (*refs && (*refs)->getURI() &&
-        !strncmp((*refs)->getURI(), kLabelLazyDecoded, 4)) {
-      pixel_refs->push_back(static_cast<skia::LazyPixelRef*>(*refs));
-    }
-    refs++;
-  }
-  pixel_ref_data->unref();
-}
-
 }  // namespace
 
 scoped_refptr<Picture> Picture::Create(gfx::Rect layer_rect) {
   return make_scoped_refptr(new Picture(layer_rect));
 }
 
 scoped_refptr<Picture> Picture::CreateFromValue(const base::Value* value) {
   bool success;
   scoped_refptr<Picture> picture =
     make_scoped_refptr(new Picture(value, &success));
@@ skipping 159 matching lines @@
 
   int min_x = std::numeric_limits<int>::max();
   int min_y = std::numeric_limits<int>::max();
   int max_x = 0;
   int max_y = 0;
 
   base::TimeTicks begin_image_gathering_time;
   if (stats)
     begin_image_gathering_time = base::TimeTicks::Now();
 
-  gfx::Size layer_size(layer_rect_.size());
+  skia::LazyPixelRefList pixel_refs;
+  skia::LazyPixelRefUtils::GatherPixelRefs(picture_.get(), &pixel_refs);
+  for (skia::LazyPixelRefList::const_iterator it = pixel_refs.begin();
+       it != pixel_refs.end();
+       ++it) {
+    gfx::Point min(
+        RoundDown(static_cast<int>(it->pixel_ref_rect.x()),
+                  cell_size_.width()),
+        RoundDown(static_cast<int>(it->pixel_ref_rect.y()),
+                  cell_size_.height()));
+    gfx::Point max(
+        RoundDown(static_cast<int>(std::ceil(it->pixel_ref_rect.right())),
+                  cell_size_.width()),
+        RoundDown(static_cast<int>(std::ceil(it->pixel_ref_rect.bottom())),
+                  cell_size_.height()));
 
-  // Capture pixel refs for this picture in a grid
-  // with cell_size_ sized cells.
-  pixel_refs_.clear();
-  for (int y = 0; y < layer_rect_.height(); y += cell_size_.height()) {
-    for (int x = 0; x < layer_rect_.width(); x += cell_size_.width()) {
-      gfx::Rect rect(gfx::Point(x, y), cell_size_);
-      rect.Intersect(gfx::Rect(gfx::Point(), layer_rect_.size()));
-
-      PixelRefs pixel_refs;
-      GatherPixelRefsForRect(picture_.get(), rect, &pixel_refs);
-
-      // Only capture non-empty cells.
-      if (!pixel_refs.empty()) {
+    for (int y = min.y(); y <= max.y(); y += cell_size_.height()) {
+      for (int x = min.x(); x <= max.x(); x += cell_size_.width()) {
         PixelRefMapKey key(x, y);
-        pixel_refs_[key].swap(pixel_refs);
-        min_x = std::min(min_x, x);
-        min_y = std::min(min_y, y);
-        max_x = std::max(max_x, x);
-        max_y = std::max(max_y, y);
+        pixel_refs_[key].push_back(it->lazy_pixel_ref);
       }
     }
+
+    min_x = std::min(min_x, min.x());
+    min_y = std::min(min_y, min.y());
+    max_x = std::max(max_x, max.x());
+    max_y = std::max(max_y, max.y());
   }
 
   if (stats) {
     stats->total_image_gathering_time +=
         base::TimeTicks::Now() - begin_image_gathering_time;
     stats->total_image_gathering_count++;
   }
 
   min_pixel_cell_ = gfx::Point(min_x, min_y);
   max_pixel_cell_ = gfx::Point(max_x, max_y);
@@ skipping 154 matching lines @@
   raster_data->Set("picture_id", TracedValue::CreateIDRef(this).release());
   raster_data->SetDouble("scale", scale);
   raster_data->SetDouble("rect_x", rect.x());
   raster_data->SetDouble("rect_y", rect.y());
   raster_data->SetDouble("rect_width", rect.width());
   raster_data->SetDouble("rect_height", rect.height());
   return TracedValue::FromValue(raster_data.release());
 }
 
 }  // namespace cc