cc: Plumb more details about pixel refs to tile manager.

cc/playback/pixel_ref_map.cc

 // Copyright 2015 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/playback/pixel_ref_map.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "cc/base/math_util.h"
 #include "cc/playback/display_item_list.h"
 #include "cc/playback/picture.h"
 #include "skia/ext/pixel_ref_utils.h"
 
 namespace cc {
 
 PixelRefMap::PixelRefMap(const gfx::Size& cell_size) : cell_size_(cell_size) {
   DCHECK(!cell_size.IsEmpty());
 }
 
 PixelRefMap::~PixelRefMap() {
 }
 
-void PixelRefMap::GatherPixelRefsFromPicture(SkPicture* picture) {
+void PixelRefMap::GatherPixelRefsFromPicture(SkPicture* picture,
+                                             const gfx::Rect& layer_rect) {
   DCHECK(picture);
 
   int min_x = std::numeric_limits<int>::max();
   int min_y = std::numeric_limits<int>::max();
   int max_x = 0;
   int max_y = 0;
 
   skia::DiscardablePixelRefList pixel_refs;
   skia::PixelRefUtils::GatherDiscardablePixelRefs(picture, &pixel_refs);
   for (skia::DiscardablePixelRefList::const_iterator it = pixel_refs.begin();
        it != pixel_refs.end(); ++it) {
     gfx::Point min(
         MathUtil::UncheckedRoundDown(static_cast<int>(it->pixel_ref_rect.x()),
                                      cell_size_.width()),
         MathUtil::UncheckedRoundDown(static_cast<int>(it->pixel_ref_rect.y()),
                                      cell_size_.height()));
     gfx::Point max(MathUtil::UncheckedRoundDown(
                        static_cast<int>(std::ceil(it->pixel_ref_rect.right())),
                        cell_size_.width()),
                    MathUtil::UncheckedRoundDown(
                        static_cast<int>(std::ceil(it->pixel_ref_rect.bottom())),
                        cell_size_.height()));
 
+    // We recorded the picture as if it was at (0, 0) by translating by layer

[weiliangc, 2015/08/07 22:56:00]

Do you mean in skia::PixelRefUtils::GatherDiscardablePixelRefs? Isn't the line
that translates picture by layer rect origin removed?

[vmpstr, 2015/08/10 17:36:05]

No I mean here at record time when we record the picture we offset it by the
layer rect origin. Here's kind of a picture:

a---------------a
|.b-----------b.|
|.|.....c---c.|.|
|.|.....|...|.|.|
|.|.....c---c.|.|
|.b-----------b.|
|...............|
a---------------a

"a" is layer rect here, and within it we have a picture "b". When we record, we
offset by -(b's origin) so internally (in the picture) b's origin is (0, 0).
Then inside the picture we also have a cull rect "c", which is the bounds of any
useful information within the picture. The line that I removed in pixel ref
utils was the offset by -(c's origin), since we want to get the pixel_ref_rect
relative to b's origin. Here, however, the final rect that we want is relative
to a's origin, so I add the layer rect's origin back in. 

Does that make sense? Or is that more confusing? :P

+    // rect origin. However, now the matrix stores this offset, and the rect is
+    // also offset. Add the rect origin back here. It really doesn't make much
+    // of a difference, since the query for pixel refs doesn't use this
+    // information. However, since picture pile / display list also returns this
+    // information, it would be nice to express it relative to the layer, not
+    // relative to the particular implementation of the raster source.
+    skia::PositionPixelRef position_pixel_ref = *it;
+    position_pixel_ref.pixel_ref_rect.setXYWH(
+        position_pixel_ref.pixel_ref_rect.x() + layer_rect.x(),
+        position_pixel_ref.pixel_ref_rect.y() + layer_rect.y(),
+        position_pixel_ref.pixel_ref_rect.width(),
+        position_pixel_ref.pixel_ref_rect.height());
+
+    // The pixel refs are relative to the picture origin, but we want to store
+    // positions here

[ericrk, 2015/08/07 00:33:56]

nit: This second comment is a bit hard to follow. From your first comment it
seems pretty clear that we want to store positions relative to layer, not sure
we need this additional comment.

[vmpstr, 2015/08/10 17:36:05]

Ya sorry this was an unfinished comment that evolved into the above comment.
Removed this one.

     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);
-        data_hash_map_[key].push_back(it->pixel_ref);
+        data_hash_map_[key].push_back(position_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());
   }
 
   min_pixel_cell_ = gfx::Point(min_x, min_y);
@@ skipping 105 matching lines @@
 
   // Make the current x be cell_size.width() less than min point, so that
   // the first increment will point at min_point_.
   current_x_ = min_point_.x() - cell_size.width();
   current_y_ = min_point_.y();
   if (current_y_ <= max_point_.y())
     ++(*this);
 }
 
 }  // namespace cc