cc: Remove separate x/y raster scales.

cc/tiles/picture_layer_tiling.h

 // 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.
 
 #ifndef CC_TILES_PICTURE_LAYER_TILING_H_
 #define CC_TILES_PICTURE_LAYER_TILING_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 63 matching lines @@
     uint32_t value1_32 = value1;
     return (value1_32 << 16) | value2;
   }
 };
 
 class CC_EXPORT PictureLayerTiling {
  public:
   static const int kBorderTexels = 1;
 
   PictureLayerTiling(WhichTree tree,
-                     const gfx::SizeF& raster_scales,
+                     float raster_scale,
                      scoped_refptr<RasterSource> raster_source,
                      PictureLayerTilingClient* client,
                      float min_preraster_distance,
                      float max_preraster_distance);
   ~PictureLayerTiling();
 
   PictureLayerTilingClient* client() const { return client_; }
 
   void SetRasterSourceAndResize(scoped_refptr<RasterSource> raster_source);
   void Invalidate(const Region& layer_invalidation);
@@ skipping 18 matching lines @@
   void set_can_require_tiles_for_activation(bool can_require_tiles) {
     can_require_tiles_for_activation_ = can_require_tiles;
   }
 
   const scoped_refptr<RasterSource>& raster_source() const {
     return raster_source_;
   }
   gfx::Size tiling_size() const { return tiling_data_.tiling_size(); }
   gfx::Rect live_tiles_rect() const { return live_tiles_rect_; }
   gfx::Size tile_size() const { return tiling_data_.max_texture_size(); }
-  float contents_scale_key() const { return raster_scales_.width(); }
-  const gfx::SizeF& raster_scales() const { return raster_scales_; }
+  float contents_scale() const { return contents_scale_; }
   const TilingData* tiling_data() const { return &tiling_data_; }
 
   Tile* TileAt(int i, int j) const {
     TileMap::const_iterator iter = tiles_.find(TileMapKey(i, j));
     return iter == tiles_.end() ? nullptr : iter->second.get();
   }
 
   bool has_tiles() const { return !tiles_.empty(); }
   // all_tiles_done() can return false negatives.
   bool all_tiles_done() const { return all_tiles_done_; }
@@ skipping 23 matching lines @@
   }
 
   void UpdateAllRequiredStateForTesting() {
     for (const auto& key_tile_pair : tiles_)
       UpdateRequiredStatesOnTile(key_tile_pair.second.get());
   }
   std::map<const Tile*, PrioritizedTile>
   UpdateAndGetAllPrioritizedTilesForTesting() const;
 
   void SetAllTilesOccludedForTesting() {
-    gfx::Rect viewport_in_layer_space = ScaleToEnclosingRect(
-        current_visible_rect_, 1.f / raster_scales_.width(),
-        1.f / raster_scales_.height());
+    gfx::Rect viewport_in_layer_space =
+        ScaleToEnclosingRect(current_visible_rect_, 1.f / contents_scale_);
     current_occlusion_in_layer_space_ =
         Occlusion(gfx::Transform(),
                   SimpleEnclosedRegion(viewport_in_layer_space),
                   SimpleEnclosedRegion(viewport_in_layer_space));
   }
   const gfx::Rect& GetCurrentVisibleRectForTesting() const {
     return current_visible_rect_;
   }
   void SetTilePriorityRectsForTesting(
       const gfx::Rect& visible_rect_in_content_space,
       const gfx::Rect& skewport,
       const gfx::Rect& soon_border_rect,
       const gfx::Rect& eventually_rect) {
-    SetTilePriorityRects(gfx::SizeF(1.f, 1.f), visible_rect_in_content_space,
-                         skewport, soon_border_rect, eventually_rect,
-                         Occlusion());
+    SetTilePriorityRects(1.f, visible_rect_in_content_space, skewport,
+                         soon_border_rect, eventually_rect, Occlusion());
   }
 
   // Iterate over all tiles to fill content_rect.  Even if tiles are invalid
   // (i.e. no valid resource) this tiling should still iterate over them.
   // The union of all geometry_rect calls for each element iterated over should
   // exactly equal content_rect and no two geometry_rects should intersect.
   class CC_EXPORT CoverageIterator {
    public:
     CoverageIterator();
     // This requests an iterator that produces a coverage of the
@@ skipping 15 matching lines @@
     CoverageIterator& operator++();
     operator bool() const { return tile_j_ <= bottom_; }
 
     int i() const { return tile_i_; }
     int j() const { return tile_j_; }
 
    private:
     const PictureLayerTiling* tiling_ = nullptr;
     gfx::Size coverage_rect_max_bounds_;
     gfx::Rect coverage_rect_;
-    gfx::SizeF coverage_to_content_scale_;
+    float coverage_to_content_scale_;
 
     Tile* current_tile_ = nullptr;
     gfx::Rect current_geometry_rect_;
     int tile_i_ = 0;
     int tile_j_ = 0;
     int left_ = 0;
     int top_ = 0;
     int right_ = -1;
     int bottom_ = -1;
 
@@ skipping 40 matching lines @@
 
   void SetLiveTilesRect(const gfx::Rect& live_tiles_rect);
   void VerifyLiveTilesRect(bool is_on_recycle_tree) const;
   Tile* CreateTile(const Tile::CreateInfo& info);
   std::unique_ptr<Tile> TakeTileAt(int i, int j);
   // Returns true if the Tile existed and was removed from the tiling.
   bool RemoveTileAt(int i, int j);
   bool TilingMatchesTileIndices(const PictureLayerTiling* twin) const;
 
   // Save the required data for computing tile priorities later.
-  void SetTilePriorityRects(const gfx::SizeF& content_to_screen_scale,
+  void SetTilePriorityRects(float content_to_screen_scale,
                             const gfx::Rect& visible_rect_in_content_space,
                             const gfx::Rect& skewport,
                             const gfx::Rect& soon_border_rect,
                             const gfx::Rect& eventually_rect,
                             const Occlusion& occlusion_in_layer_space);
 
   bool IsTileOccludedOnCurrentTree(const Tile* tile) const;
   Tile::CreateInfo CreateInfoForTile(int i, int j) const;
   bool ShouldCreateTileAt(const Tile::CreateInfo& info) const;
   bool IsTileOccluded(const Tile* tile) const;
@@ skipping 28 matching lines @@
   }
   const gfx::Rect& current_soon_border_rect() const {
     return current_soon_border_rect_;
   }
   const gfx::Rect& current_eventually_rect() const {
     return current_eventually_rect_;
   }
   void RemoveTilesInRegion(const Region& layer_region, bool recreate_tiles);
 
   // Given properties.
-  const gfx::SizeF raster_scales_;
+  const float contents_scale_;
   PictureLayerTilingClient* const client_;
   const WhichTree tree_;
   scoped_refptr<RasterSource> raster_source_;
   const float min_preraster_distance_;
   const float max_preraster_distance_;
   TileResolution resolution_ = NON_IDEAL_RESOLUTION;
   bool may_contain_low_resolution_tiles_ = false;
 
   // Internal data.
   TilingData tiling_data_ = TilingData(gfx::Size(), gfx::Size(), kBorderTexels);
   TileMap tiles_;  // It is not legal to have a NULL tile in the tiles_ map.
   gfx::Rect live_tiles_rect_;
 
   bool can_require_tiles_for_activation_ = false;
 
   // Iteration rects in content space.
   gfx::Rect current_visible_rect_;
   gfx::Rect current_skewport_rect_;
   gfx::Rect current_soon_border_rect_;
   gfx::Rect current_eventually_rect_;
   // Other properties used for tile iteration and prioritization.
-  gfx::SizeF current_content_to_screen_scale_;
+  float current_content_to_screen_scale_;
   Occlusion current_occlusion_in_layer_space_;
   float max_skewport_extent_in_screen_space_ = 0.f;
 
   bool has_visible_rect_tiles_ = false;
   bool has_skewport_rect_tiles_ = false;
   bool has_soon_border_rect_tiles_ = false;
   bool has_eventually_rect_tiles_ = false;
   bool all_tiles_done_ = true;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PictureLayerTiling);
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_PICTURE_LAYER_TILING_H_