cc: Stop using contents_scale_x() in PictureLayerImpl since it's 1.

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 <limits>
 #include <set>
 
@@ skipping 404 matching lines @@
   // 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
   // finer tilings.
   CleanUpTilingsOnActiveLayer(seen_tilings);
 }
 
 void PictureLayerImpl::UpdateTiles(
     const Occlusion& occlusion_in_content_space) {
   TRACE_EVENT0("cc", "PictureLayerImpl::UpdateTiles");
+  DCHECK_EQ(1.f, contents_scale_x());
+  DCHECK_EQ(1.f, contents_scale_y());
 
   DoPostCommitInitializationIfNeeded();
 
   visible_rect_for_tile_priority_ = visible_content_rect();
   viewport_rect_for_tile_priority_ =
       layer_tree_impl()->ViewportRectForTilePriority();
   screen_space_transform_for_tile_priority_ = screen_space_transform();
 
   if (!CanHaveTilings()) {
     ideal_page_scale_ = 0.f;
@@ skipping 42 matching lines @@
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     if (tilings_->tiling_at(i)->NeedsUpdateForFrameAtTime(
             current_frame_time_in_seconds)) {
       tiling_needs_update = true;
       break;
     }
   }
   if (!tiling_needs_update)
     return;
 
-  gfx::Rect visible_rect_in_content_space(
-      GetViewportForTilePriorityInContentSpace());
-  gfx::Rect visible_layer_rect = gfx::ScaleToEnclosingRect(
-      visible_rect_in_content_space, 1.f / contents_scale_x());
+  gfx::Rect visible_layer_rect = GetViewportForTilePriorityInContentSpace();
   WhichTree tree =
       layer_tree_impl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
+    // Pass |occlusion_in_content_space| for |occlusion_in_layer_space| since
+    // they are the same space in picture lbayer, as contents scale is always 1.
     tilings_->tiling_at(i)->UpdateTilePriorities(tree,
                                                  visible_layer_rect,
                                                  ideal_contents_scale_,
                                                  current_frame_time_in_seconds,
                                                  occlusion_in_content_space);
   }
 
   // Tile priorities were modified.
   layer_tree_impl()->DidModifyTilePriorities();
 }
@@ skipping 243 matching lines @@
     // TODO(danakj): Add a DCHECK() that we are not using occlusion tracking
     // when we stop using the pending tree in the browser compositor. If we want
     // to support occlusion tracking here, we need to dirty the draw properties
     // or save occlusion as a draw property.
     UpdateTilePriorities(Occlusion());
   }
 }
 
 ResourceProvider::ResourceId PictureLayerImpl::ContentsResourceId() const {
   gfx::Rect content_rect(content_bounds());
-  float scale = MaximumTilingContentsScale();
   PictureLayerTilingSet::CoverageIterator iter(
-      tilings_.get(), scale, content_rect, ideal_contents_scale_);
+      tilings_.get(), 1.f, content_rect, ideal_contents_scale_);
 
   // Mask resource not ready yet.
   if (!iter || !*iter)
     return 0;
 
   // Masks only supported if they fit on exactly one tile.
   DCHECK(iter.geometry_rect() == content_rect)
       << "iter rect " << iter.geometry_rect().ToString() << " content rect "
       << content_rect.ToString();
 
@@ skipping 54 matching lines @@
       DCHECK(!low_res) << "There can only be one low res tiling";
       low_res = tiling;
     }
     if (tiling->contents_scale() < min_acceptable_scale)
       continue;
     if (tiling->resolution() == HIGH_RESOLUTION) {
       DCHECK(!high_res) << "There can only be one high res tiling";
       high_res = tiling;
       continue;
     }
-    for (PictureLayerTiling::CoverageIterator iter(tiling,
-                                                   contents_scale_x(),
-                                                   rect);
-         iter;
+    for (PictureLayerTiling::CoverageIterator iter(tiling, 1.f, rect); iter;
          ++iter) {
       if (!*iter || !iter->IsReadyToDraw())
         continue;
 
       missing_region.Subtract(iter.geometry_rect());
       iter->MarkRequiredForActivation();
     }
   }
   DCHECK(high_res) << "There must be one high res tiling";
 
@@ skipping 24 matching lines @@
         draw_properties().screen_space_transform !=
             twin_layer_->draw_properties().screen_space_transform) {
       twin_high_res = NULL;
       twin_low_res = NULL;
     }
   }
 
   // As a second pass, mark as required any visible high res tiles not filled in
   // by acceptable non-ideal tiles from the first pass.
   if (MarkVisibleTilesAsRequired(
-      high_res, twin_high_res, contents_scale_x(), rect, missing_region)) {
+          high_res, twin_high_res, rect, missing_region)) {
     // As an optional third pass, if a high res tile was skipped because its
     // twin was also missing, then fall back to mark low res tiles as required
     // in case the active twin is substituting those for missing high res
     // content. Only suitable, when low res is enabled.
     if (low_res) {
-      MarkVisibleTilesAsRequired(
-          low_res, twin_low_res, contents_scale_x(), rect, missing_region);
+      MarkVisibleTilesAsRequired(low_res, twin_low_res, rect, missing_region);
     }
   }
 }
 
 bool PictureLayerImpl::MarkVisibleTilesAsRequired(
     PictureLayerTiling* tiling,
     const PictureLayerTiling* optional_twin_tiling,
-    float contents_scale,
     const gfx::Rect& rect,
     const Region& missing_region) const {
   bool twin_had_missing_tile = false;
-  for (PictureLayerTiling::CoverageIterator iter(tiling,
-                                                 contents_scale,
-                                                 rect);
-       iter;
+  for (PictureLayerTiling::CoverageIterator iter(tiling, 1.f, rect); iter;
        ++iter) {
     Tile* tile = *iter;
     // A null tile (i.e. missing recording) can just be skipped.
     if (!tile)
       continue;
 
     // If the tile is occluded, don't mark it as required for activation.
     if (tile->is_occluded(PENDING_TREE))
       continue;
 
@@ skipping 497 matching lines @@
   state->BeginArray("pictures");
   pile_->AsValueInto(state);
   state->EndArray();
 
   state->BeginArray("invalidation");
   invalidation_.AsValueInto(state);
   state->EndArray();
 
   state->BeginArray("coverage_tiles");
   for (PictureLayerTilingSet::CoverageIterator iter(tilings_.get(),
-                                                    contents_scale_x(),
+                                                    1.f,
                                                     gfx::Rect(content_bounds()),
                                                     ideal_contents_scale_);
        iter;
        ++iter) {
     state->BeginDictionary();
 
     state->BeginArray("geometry_rect");
     MathUtil::AddToTracedValue(iter.geometry_rect(), state);
     state->EndArray();
 
@@ skipping 39 matching lines @@
   if (visible_content_rect().IsEmpty())
     return true;
 
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = tilings_->tiling_at(i);
     if (tiling->resolution() != HIGH_RESOLUTION &&
         tiling->resolution() != LOW_RESOLUTION)
       continue;
 
     gfx::Rect rect(visible_content_rect());
-    for (PictureLayerTiling::CoverageIterator iter(
-             tiling, contents_scale_x(), rect);
-         iter;
+    for (PictureLayerTiling::CoverageIterator iter(tiling, 1.f, rect); iter;
          ++iter) {
       const Tile* tile = *iter;
       // A null tile (i.e. missing recording) can just be skipped.
       if (!tile)
         continue;
 
       if (tile->required_for_activation() && !tile->IsReadyToDraw())
         return false;
     }
   }
@@ skipping 269 matching lines @@
       PictureLayerTilingSet::TilingRange tiling_range = CurrentTilingRange();
       size_t current_tiling_range_offset = current_tiling_ - tiling_range.start;
       return tiling_range.end - 1 - current_tiling_range_offset;
     }
   }
   NOTREACHED();
   return 0;
 }
 
 }  // namespace cc