cc: Rename visible_content_rect and content stuff on quads.

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 <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 143 matching lines @@
       render_pass->CreateAndAppendSharedQuadState();
 
   if (raster_source_->IsSolidColor()) {
     PopulateSharedQuadState(shared_quad_state);
 
     AppendDebugBorderQuad(
         render_pass, bounds(), shared_quad_state, append_quads_data);
 
     SolidColorLayerImpl::AppendSolidQuads(
         render_pass, draw_properties().occlusion_in_content_space,
-        shared_quad_state, visible_content_rect(),
+        shared_quad_state, visible_layer_rect(),
         raster_source_->GetSolidColor(), append_quads_data);
     return;
   }
 
   float max_contents_scale = MaximumTilingContentsScale();
   PopulateScaledSharedQuadState(shared_quad_state, max_contents_scale);
   Occlusion scaled_occlusion =
       draw_properties()
           .occlusion_in_content_space.GetOcclusionWithGivenDrawTransform(
-              shared_quad_state->content_to_target_transform);
+              shared_quad_state->quad_to_target_transform);
 
   if (current_draw_mode_ == DRAW_MODE_RESOURCELESS_SOFTWARE) {
     AppendDebugBorderQuad(
-        render_pass, shared_quad_state->content_bounds, shared_quad_state,
+        render_pass, shared_quad_state->quad_layer_bounds, shared_quad_state,
         append_quads_data, DebugColors::DirectPictureBorderColor(),
         DebugColors::DirectPictureBorderWidth(layer_tree_impl()));
 
-    gfx::Rect geometry_rect = shared_quad_state->visible_content_rect;
+    gfx::Rect geometry_rect = shared_quad_state->visible_quad_layer_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())
       return;
 
-    gfx::Rect quad_content_rect = shared_quad_state->visible_content_rect;
+    gfx::Rect quad_content_rect = shared_quad_state->visible_quad_layer_rect;
     gfx::Size texture_size = quad_content_rect.size();
     gfx::RectF texture_rect = gfx::RectF(texture_size);
 
     PictureDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
     quad->SetNew(shared_quad_state, geometry_rect, opaque_rect,
                  visible_geometry_rect, texture_rect, texture_size,
                  nearest_neighbor_, RGBA_8888, quad_content_rect,
                  max_contents_scale, raster_source_);
     ValidateQuadResources(quad);
     return;
   }
 
-  AppendDebugBorderQuad(render_pass, shared_quad_state->content_bounds,
+  AppendDebugBorderQuad(render_pass, shared_quad_state->quad_layer_bounds,
                         shared_quad_state, append_quads_data);
 
   if (ShowDebugBorders()) {
     for (PictureLayerTilingSet::CoverageIterator iter(
              tilings_.get(), max_contents_scale,
-             shared_quad_state->visible_content_rect, ideal_contents_scale_);
+             shared_quad_state->visible_quad_layer_rect, ideal_contents_scale_);
          iter; ++iter) {
       SkColor color;
       float width;
       if (*iter && iter->draw_info().IsReadyToDraw()) {
         TileDrawInfo::Mode mode = iter->draw_info().mode();
         if (mode == TileDrawInfo::SOLID_COLOR_MODE) {
           color = DebugColors::SolidColorTileBorderColor();
           width = DebugColors::SolidColorTileBorderWidth(layer_tree_impl());
         } else if (mode == TileDrawInfo::OOM_MODE) {
           color = DebugColors::OOMTileBorderColor();
@@ skipping 36 matching lines @@
   // normally the same as draw viewport but can be independently overridden by
   // embedders like Android WebView with SetExternalDrawConstraints.
   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;
   for (PictureLayerTilingSet::CoverageIterator iter(
            tilings_.get(), max_contents_scale,
-           shared_quad_state->visible_content_rect, ideal_contents_scale_);
+           shared_quad_state->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_content_area +=
+    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();
       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
@@ skipping 48 matching lines @@
                      visible_geometry_rect,
                      color,
                      false);
         ValidateQuadResources(quad);
       }
 
       if (geometry_rect.Intersects(scaled_viewport_for_tile_priority)) {
         append_quads_data->num_missing_tiles++;
         ++missing_tile_count;
       }
-      append_quads_data->approximated_visible_content_area +=
+      append_quads_data->approximated_visible_layer_area +=
           visible_geometry_rect.width() * visible_geometry_rect.height();
-      append_quads_data->checkerboarded_visible_content_area +=
+      append_quads_data->checkerboarded_visible_layer_area +=

[enne (OOO), 2015/06/18 21:02:15]

This is not true.  I think this in the space of max content scale, which is a
bit weird.  Can you file a bug for making this be more real? Or maybe making
them be in layer space?

[danakj, 2015/06/18 21:06:34]

I reverted this name and will file a bug.

           visible_geometry_rect.width() * visible_geometry_rect.height();
       continue;
     }
 
     if (iter.resolution() != HIGH_RESOLUTION) {
-      append_quads_data->approximated_visible_content_area +=
+      append_quads_data->approximated_visible_layer_area +=
           visible_geometry_rect.width() * visible_geometry_rect.height();
     }
 
     // If we have a draw quad, but it's not low resolution, then
     // mark that we've used something other than low res to draw.
     if (iter.resolution() != LOW_RESOLUTION)
       only_used_low_res_last_append_quads_ = false;
 
     if (last_append_quads_tilings_.empty() ||
         last_append_quads_tilings_.back() != iter.CurrentTiling()) {
       last_append_quads_tilings_.push_back(iter.CurrentTiling());
     }
   }
 
   if (missing_tile_count) {
     TRACE_EVENT_INSTANT2("cc",
                          "PictureLayerImpl::AppendQuads checkerboard",
                          TRACE_EVENT_SCOPE_THREAD,
                          "missing_tile_count",
                          missing_tile_count,
                          "on_demand_missing_tile_count",
                          on_demand_missing_tile_count);
   }
 
   // Aggressively remove any tilings that are not seen to save memory. Note
   // that this is at the expense of doing cause more frequent re-painting. A
-  // better scheme would be to maintain a tighter visible_content_rect for the
+  // better scheme would be to maintain a tighter visible_layer_rect for the
   // finer tilings.
   CleanUpTilingsOnActiveLayer(last_append_quads_tilings_);
 }
 
 bool PictureLayerImpl::UpdateTiles(bool resourceless_software_draw) {
   if (!resourceless_software_draw) {
-    visible_rect_for_tile_priority_ = visible_content_rect();
+    visible_rect_for_tile_priority_ = visible_layer_rect();
   }
 
   if (!CanHaveTilings()) {
     ideal_page_scale_ = 0.f;
     ideal_device_scale_ = 0.f;
     ideal_contents_scale_ = 0.f;
     ideal_source_scale_ = 0.f;
     SanityCheckTilingState();
     return false;
   }
@@ skipping 788 matching lines @@
   LayerImpl::AsValueInto(state);
   state->SetDouble("ideal_contents_scale", ideal_contents_scale_);
   state->SetDouble("geometry_contents_scale", MaximumTilingContentsScale());
   state->BeginArray("tilings");
   tilings_->AsValueInto(state);
   state->EndArray();
 
   MathUtil::AddToTracedValue("tile_priority_rect",
                              viewport_rect_for_tile_priority_in_content_space_,
                              state);
-  MathUtil::AddToTracedValue("visible_rect", visible_content_rect(), state);
+  MathUtil::AddToTracedValue("visible_rect", visible_layer_rect(), state);
 
   state->BeginArray("pictures");
   raster_source_->AsValueInto(state);
   state->EndArray();
 
   state->BeginArray("invalidation");
   invalidation_.AsValueInto(state);
   state->EndArray();
 
   state->BeginArray("coverage_tiles");
@@ skipping 27 matching lines @@
 
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
   return IsOnActiveOrPendingTree() && IsDrawnRenderSurfaceLayerListMember();
 }
 
 }  // namespace cc