[4/5] Add translated rasterization support for PictureLayerTilingSet & below

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>
 
 #include <map>
 #include <memory>
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "cc/base/region.h"
+#include "cc/base/scale_translate2d.h"
 #include "cc/base/tiling_data.h"
 #include "cc/cc_export.h"
 #include "cc/tiles/tile.h"
 #include "cc/tiles/tile_priority.h"
 #include "cc/trees/occlusion.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace base {
 namespace trace_event {
 class TracedValue;
@@ skipping 45 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,
-                     float raster_scale,
+                     const ScaleTranslate2d& raster_transform,
                      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() const { return contents_scale_; }
+  float contents_scale_key() const { return raster_transform_.scale(); }

[enne (OOO), 2017/03/29 12:57:37]

Can you leave some more documentation here about how key relates to everything
else? I think this might be confusing to people who aren't familiar with these
classes.  Maybe at least saying that tilings have a unique scale, and then also
have a fixed translation to adjust for pixel alignment.  And also maybe that we
don't ever have tilings with the same scale and different translations, so the
scale itself can be used as the key to identify the tiling?

[trchen, 2017/03/30 22:17:32]

Done.

+  const ScaleTranslate2d& raster_transform() const { return raster_transform_; }
   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 28 matching lines @@
     for (const auto& key_tile_pair : tiles_) {
       Tile* tile = key_tile_pair.second.get();
       UpdateRequiredStatesOnTile(tile);
     }
   }
   std::map<const Tile*, PrioritizedTile>
   UpdateAndGetAllPrioritizedTilesForTesting() const;
 
   void SetAllTilesOccludedForTesting() {
     gfx::Rect viewport_in_layer_space =
-        ScaleToEnclosingRect(current_visible_rect_, 1.f / contents_scale_);
+        EnclosingLayerRectFromContentsRect(current_visible_rect_);
     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,
@@ skipping 30 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_;
-    float coverage_to_content_scale_;
+    ScaleTranslate2d coverage_to_content_;
 
     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 89 matching lines @@
     return current_skewport_rect_;
   }
   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);
 
+  gfx::Rect EnclosingContentsRectFromLayerRect(
+      const gfx::Rect& layer_rect) const;
+  gfx::Rect EnclosingLayerRectFromContentsRect(
+      const gfx::Rect& contents_rect) const;
+
   // Given properties.
-  const float contents_scale_;
+  const ScaleTranslate2d raster_transform_;
   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.
-  float current_content_to_screen_scale_;
+  float current_content_to_screen_scale_ = 0.f;
   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_