cc: Anchor quad offsets to a visible quad.

cc/layers/picture_layer_impl.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/layers/picture_layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 262 matching lines @@
   // normally the same as draw viewport but can be independently overridden by
   // embedders like Android WebView with SetExternalTilePriorityConstraints.
   gfx::Rect scaled_viewport_for_tile_priority = gfx::ScaleToEnclosingRect(
       viewport_rect_for_tile_priority_in_content_space_, max_contents_scale);
 
   size_t missing_tile_count = 0u;
   size_t on_demand_missing_tile_count = 0u;
   only_used_low_res_last_append_quads_ = true;
   gfx::Rect scaled_recorded_viewport = gfx::ScaleToEnclosingRect(
       raster_source_->RecordedViewport(), max_contents_scale);
+
+  bool have_origin = false;
+  gfx::Point quad_origin;
+  gfx::Rect visible_quad_layer_rect =
+      shared_quad_state->visible_quad_layer_rect;
+
   for (PictureLayerTilingSet::CoverageIterator iter(
-           tilings_.get(), max_contents_scale,
-           shared_quad_state->visible_quad_layer_rect, ideal_contents_scale_);
+           tilings_.get(), max_contents_scale, visible_quad_layer_rect,
+           ideal_contents_scale_);
        iter; ++iter) {
     gfx::Rect geometry_rect = iter.geometry_rect();
     gfx::Rect opaque_rect = contents_opaque() ? geometry_rect : gfx::Rect();
     gfx::Rect visible_geometry_rect =
         scaled_occlusion.GetUnoccludedContentRect(geometry_rect);
     if (visible_geometry_rect.IsEmpty())
       continue;
 
     append_quads_data->visible_layer_area +=
         visible_geometry_rect.width() * visible_geometry_rect.height();
 
     bool has_draw_quad = false;
     if (*iter && iter->draw_info().IsReadyToDraw()) {
       const TileDrawInfo& draw_info = iter->draw_info();
+
+      if (!have_origin) {
+        have_origin = true;
+        quad_origin.SetPoint(geometry_rect.x(), geometry_rect.y());
+        shared_quad_state->quad_to_target_transform.Translate(quad_origin.x(),
+                                                              quad_origin.y());
+        shared_quad_state->visible_quad_layer_rect.Offset(-quad_origin.x(),
+                                                          -quad_origin.y());
+      }
+
+      geometry_rect.Offset(-quad_origin.x(), -quad_origin.y());
+      opaque_rect.Offset(-quad_origin.x(), -quad_origin.y());
+      visible_geometry_rect.Offset(-quad_origin.x(), -quad_origin.y());
+
       switch (draw_info.mode()) {
         case TileDrawInfo::RESOURCE_MODE: {
           gfx::RectF texture_rect = iter.texture_rect();
 
           // The raster_contents_scale_ is the best scale that the layer is
           // trying to produce, even though it may not be ideal. Since that's
           // the best the layer can promise in the future, consider those as
           // complete. But if a tile is ideal scale, we don't want to consider
           // it incomplete and trying to replace it with a tile at a worse
           // scale.
@@ skipping 991 matching lines @@
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
   return IsOnActiveOrPendingTree() &&
          is_drawn_render_surface_layer_list_member();
 }
 
 }  // namespace cc