cc: Simplify picture layer tiling update tile priorities.

cc/resources/picture_layer_tiling_unittest.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/resources/picture_layer_tiling.h"
 
 #include <limits>
 
 #include "cc/base/math_util.h"
 #include "cc/resources/picture_layer_tiling_set.h"
 #include "cc/test/fake_picture_layer_tiling_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace cc {
 namespace {
 
 static gfx::Rect ViewportInLayerSpace(
     const gfx::Transform& transform,
     const gfx::Size& device_viewport) {
 
   gfx::Transform inverse;
   if (!transform.GetInverse(&inverse))
     return gfx::Rect();
 
   gfx::RectF viewport_in_layer_space = MathUtil::ProjectClippedRect(
       inverse, gfx::RectF(gfx::Point(0, 0), device_viewport));
-
   return ToEnclosingRect(viewport_in_layer_space);
 }
 
 class TestablePictureLayerTiling : public PictureLayerTiling {
  public:
   using PictureLayerTiling::SetLiveTilesRect;
   using PictureLayerTiling::TileAt;
 
   static scoped_ptr<TestablePictureLayerTiling> Create(
       float contents_scale,
       const gfx::Size& layer_bounds,
       PictureLayerTilingClient* client) {
     return make_scoped_ptr(new TestablePictureLayerTiling(
         contents_scale,
         layer_bounds,
         client));
   }
 
+  using PictureLayerTiling::ComputeSkewport;
+
  protected:
   TestablePictureLayerTiling(float contents_scale,
                              const gfx::Size& layer_bounds,
                              PictureLayerTilingClient* client)
       : PictureLayerTiling(contents_scale, layer_bounds, client) { }
 };
 
 class PictureLayerTilingIteratorTest : public testing::Test {
  public:
   PictureLayerTilingIteratorTest() {}
@@ skipping 90 matching lines @@
 
   void VerifyTilesCoverNonContainedRect(float rect_scale,
                                         const gfx::Rect& dest_rect) {
     float dest_to_contents_scale = tiling_->contents_scale() / rect_scale;
     gfx::Rect clamped_rect = gfx::ScaleToEnclosingRect(
         tiling_->ContentRect(), 1.f / dest_to_contents_scale);
     clamped_rect.Intersect(dest_rect);
     VerifyTilesExactlyCoverRect(rect_scale, dest_rect, clamped_rect);
   }
 
+  void set_max_tiles_for_interest_area(size_t area) {
+    client_.set_max_tiles_for_interest_area(area);
+  }
+
  protected:
   FakePictureLayerTilingClient client_;
   scoped_ptr<TestablePictureLayerTiling> tiling_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PictureLayerTilingIteratorTest);
 };
 
 TEST_F(PictureLayerTilingIteratorTest, LiveTilesExactlyCoverLiveTileRect) {
   Initialize(gfx::Size(100, 100), 1, gfx::Size(1099, 801));
@@ skipping 89 matching lines @@
   VerifyTilesCoverNonContainedRect(1.0f, gfx::Rect(-1000, -1000, 2000, 2000));
   VerifyTilesCoverNonContainedRect(1.5f, gfx::Rect(-1000, -1000, 2000, 2000));
   VerifyTilesCoverNonContainedRect(0.5f, gfx::Rect(-1000, -1000, 2000, 2000));
 
   // Partially covering content, but too large
   VerifyTilesCoverNonContainedRect(1.0f, gfx::Rect(-1000, 100, 2000, 100));
   VerifyTilesCoverNonContainedRect(1.5f, gfx::Rect(-1000, 100, 2000, 100));
   VerifyTilesCoverNonContainedRect(0.5f, gfx::Rect(-1000, 100, 2000, 100));
 }
 
+TEST(PictureLayerTilingTest, ComputeSkewport) {

[enne (OOO), 2014/02/11 00:43:56]

Can you test the pixel limits too? It might make sense to make the 2000 content
pixel limit a setting somewhere so that the test doesn't have to assume it?

I think there also should be some tests about correct distances under content
scale != 1, to at least make sure that you're not multiplying a scale when you
should be dividing, etc.

Maybe also a test where you get all the tiles from the map in a layer and make
sure that if they intersect the viewport they're now, if they intersect the
skewport they're soon, and otherwise are listed as eventually? And maybe have
sane distances?

[vmpstr, 2014/02/11 23:45:25]

Done.

+  FakePictureLayerTilingClient client;
+  scoped_ptr<TestablePictureLayerTiling> tiling;
+
+  gfx::Rect viewport(0, 0, 100, 100);
+  gfx::Size layer_bounds(200, 200);
+
+  client.SetTileSize(gfx::Size(100, 100));
+  tiling = TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client);
+
+  tiling->UpdateTilePriorities(ACTIVE_TREE, viewport, 1.f, 1.0);
+
+  // Move viewport down 50 pixels in 0.5 seconds.
+  gfx::Rect down_skewport =
+      tiling->ComputeSkewport(1.5, gfx::Rect(0, 50, 100, 100));
+
+  EXPECT_EQ(0, down_skewport.x());
+  EXPECT_EQ(50, down_skewport.y());
+  EXPECT_EQ(100, down_skewport.width());
+  EXPECT_EQ(200, down_skewport.height());
+
+  // Shrink viewport.
+  gfx::Rect shrink_skewport =
+      tiling->ComputeSkewport(1.5, gfx::Rect(25, 25, 50, 50));
+
+  EXPECT_EQ(25, shrink_skewport.x());
+  EXPECT_EQ(25, shrink_skewport.y());
+  EXPECT_EQ(50, shrink_skewport.width());
+  EXPECT_EQ(50, shrink_skewport.height());
+
+  // Move viewport down 50 and right 10 pixels.
+  gfx::Rect down_right_skewport =
+      tiling->ComputeSkewport(1.5, gfx::Rect(10, 50, 100, 100));
+
+  EXPECT_EQ(10, down_right_skewport.x());
+  EXPECT_EQ(50, down_right_skewport.y());
+  EXPECT_EQ(120, down_right_skewport.width());
+  EXPECT_EQ(200, down_right_skewport.height());
+
+  // Move viewport left.
+  gfx::Rect left_skewport =
+      tiling->ComputeSkewport(1.5, gfx::Rect(-20, 0, 100, 100));
+
+  EXPECT_EQ(-60, left_skewport.x());
+  EXPECT_EQ(0, left_skewport.y());
+  EXPECT_EQ(140, left_skewport.width());
+  EXPECT_EQ(100, left_skewport.height());
+
+  // Expand viewport in 0.2 seconds.
+  gfx::Rect expanded_skewport =
+      tiling->ComputeSkewport(1.2, gfx::Rect(-5, -5, 110, 110));
+
+  EXPECT_EQ(-30, expanded_skewport.x());
+  EXPECT_EQ(-30, expanded_skewport.y());
+  EXPECT_EQ(160, expanded_skewport.width());
+  EXPECT_EQ(160, expanded_skewport.height());
+}
+
 TEST(PictureLayerTilingTest, ExpandRectEqual) {
   gfx::Rect in(40, 50, 100, 200);
   gfx::Rect bounds(-1000, -1000, 10000, 10000);
   int64 target_area = 100 * 200;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
       in, target_area, bounds, NULL);
   EXPECT_EQ(in.ToString(), out.ToString());
 }
 
 TEST(PictureLayerTilingTest, ExpandRectSmaller) {
@@ skipping 209 matching lines @@
                        const gfx::Rect& geometry_rect) {
   EXPECT_EQ(exists, tile != NULL) << geometry_rect.ToString();
 }
 
 TEST_F(PictureLayerTilingIteratorTest, TilesExist) {
   gfx::Size layer_bounds(1099, 801);
   Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 
+  set_max_tiles_for_interest_area(1000);
   tiling_->UpdateTilePriorities(
       ACTIVE_TREE,
-      layer_bounds,  // device viewport
-      gfx::Rect(layer_bounds),  // viewport in layer space
       gfx::Rect(layer_bounds),  // visible content rect
-      layer_bounds,  // last layer bounds
-      layer_bounds,  // current layer bounds
-      1.f,  // last contents scale
-      1.f,  // current contents scale
-      gfx::Transform(),  // last screen transform
-      gfx::Transform(),  // current screen transform
-      1.0,  // current frame time
-      10000);  // max tiles in tile manager
+      1.f,                      // current contents scale
+      1.0);                     // current frame time
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
 
   // Make the viewport rect empty. All tiles are killed and become zombies.
-  tiling_->UpdateTilePriorities(
-      ACTIVE_TREE,
-      layer_bounds,  // device viewport
-      gfx::Rect(),  // viewport in layer space
-      gfx::Rect(),  // visible content rect
-      layer_bounds,  // last layer bounds
-      layer_bounds,  // current layer bounds
-      1.f,  // last contents scale
-      1.f,  // current contents scale
-      gfx::Transform(),  // last screen transform
-      gfx::Transform(),  // current screen transform
-      2.0,  // current frame time
-      10000);  // max tiles in tile manager
+  tiling_->UpdateTilePriorities(ACTIVE_TREE,
+                                gfx::Rect(),  // visible content rect
+                                1.f,          // current contents scale
+                                2.0);         // current frame time
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 }
 
 TEST_F(PictureLayerTilingIteratorTest, TilesExistGiantViewport) {
   gfx::Size layer_bounds(1099, 801);
   Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 
   gfx::Rect giant_rect(-10000000, -10000000, 1000000000, 1000000000);
 
+  set_max_tiles_for_interest_area(1000);
   tiling_->UpdateTilePriorities(
       ACTIVE_TREE,
-      layer_bounds,  // device viewport
-      giant_rect,  // viewport in layer space
       gfx::Rect(layer_bounds),  // visible content rect
-      layer_bounds,  // last layer bounds
-      layer_bounds,  // current layer bounds
-      1.f,  // last contents scale
-      1.f,  // current contents scale
-      gfx::Transform(),  // last screen transform
-      gfx::Transform(),  // current screen transform
-      1.0,  // current frame time
-      10000);  // max tiles in tile manager
+      1.f,                      // current contents scale
+      1.0);                     // current frame time
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
 
   // If the visible content rect is empty, it should still have live tiles.
-  tiling_->UpdateTilePriorities(
-      ACTIVE_TREE,
-      layer_bounds,  // device viewport
-      giant_rect,  // viewport in layer space
-      gfx::Rect(),  // visible content rect
-      layer_bounds,  // last layer bounds
-      layer_bounds,  // current layer bounds
-      1.f,  // last contents scale
-      1.f,  // current contents scale
-      gfx::Transform(),  // last screen transform
-      gfx::Transform(),  // current screen transform
-      2.0,  // current frame time
-      10000);  // max tiles in tile manager
+  tiling_->UpdateTilePriorities(ACTIVE_TREE,
+                                giant_rect,  // visible content rect
+                                1.f,         // current contents scale
+                                2.0);        // current frame time
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
 }
 
 TEST_F(PictureLayerTilingIteratorTest, TilesExistOutsideViewport) {
   gfx::Size layer_bounds(1099, 801);
   Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 
   // This rect does not intersect with the layer, as the layer is outside the
   // viewport.
   gfx::Rect viewport_rect(1100, 0, 1000, 1000);
   EXPECT_FALSE(viewport_rect.Intersects(gfx::Rect(layer_bounds)));
 
-  tiling_->UpdateTilePriorities(
-      ACTIVE_TREE,
-      layer_bounds,  // device viewport
-      viewport_rect,  // viewport in layer space
-      gfx::Rect(),  // visible content rect
-      layer_bounds,  // last layer bounds
-      layer_bounds,  // current layer bounds
-      1.f,  // last contents scale
-      1.f,  // current contents scale
-      gfx::Transform(),  // last screen transform
-      gfx::Transform(),  // current screen transform
-      1.0,  // current frame time
-      10000);  // max tiles in tile manager
+  set_max_tiles_for_interest_area(1000);
+  tiling_->UpdateTilePriorities(ACTIVE_TREE,
+                                viewport_rect,  // visible content rect
+                                1.f,            // current contents scale
+                                1.0);           // current frame time
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
 }
 
 static void TilesIntersectingRectExist(const gfx::Rect& rect,
                                        bool intersect_exists,
                                        Tile* tile,
                                        const gfx::Rect& geometry_rect) {
   bool intersects = rect.Intersects(geometry_rect);
   bool expected_exists = intersect_exists ? intersects : !intersects;
   EXPECT_EQ(expected_exists, tile != NULL)
       << "Rects intersecting " << rect.ToString() << " should exist. "
       << "Current tile rect is " << geometry_rect.ToString();
 }
 
 TEST_F(PictureLayerTilingIteratorTest,
        TilesExistLargeViewportAndLayerWithSmallVisibleArea) {
   gfx::Size layer_bounds(10000, 10000);
   Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 
   gfx::Rect visible_rect(8000, 8000, 50, 50);
 
-  tiling_->UpdateTilePriorities(
-      ACTIVE_TREE,
-      layer_bounds,  // device viewport
-      gfx::Rect(layer_bounds),  // viewport in layer space
-      visible_rect,  // visible content rect
-      layer_bounds,  // last layer bounds
-      layer_bounds,  // current layer bounds
-      1.f,  // last contents scale
-      1.f,  // current contents scale
-      gfx::Transform(),  // last screen transform
-      gfx::Transform(),  // current screen transform
-      1.0,  // current frame time
-      1);  // max tiles in tile manager
+  set_max_tiles_for_interest_area(1);
+  tiling_->UpdateTilePriorities(ACTIVE_TREE,
+                                visible_rect,  // visible content rect
+                                1.f,           // current contents scale
+                                1.0);          // current frame time
   VerifyTiles(1.f,
               gfx::Rect(layer_bounds),
               base::Bind(&TilesIntersectingRectExist, visible_rect, true));
 }
 
 static void CountExistingTiles(int *count,
                                Tile* tile,
                                const gfx::Rect& geometry_rect) {
   if (tile != NULL)
     ++(*count);
 }
 
 TEST_F(PictureLayerTilingIteratorTest,
        TilesExistLargeViewportAndLayerWithLargeVisibleArea) {
   gfx::Size layer_bounds(10000, 10000);
   Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 
+  set_max_tiles_for_interest_area(1);
   tiling_->UpdateTilePriorities(
       ACTIVE_TREE,
-      layer_bounds,  // device viewport
-      gfx::Rect(layer_bounds),  // viewport in layer space
       gfx::Rect(layer_bounds),  // visible content rect
-      layer_bounds,  // last layer bounds
-      layer_bounds,  // current layer bounds
-      1.f,  // last contents scale
-      1.f,  // current contents scale
-      gfx::Transform(),  // last screen transform
-      gfx::Transform(),  // current screen transform
-      1.0,  // current frame time
-      1);  // max tiles in tile manager
+      1.f,                      // current contents scale
+      1.0);                     // current frame time
 
   int num_tiles = 0;
   VerifyTiles(1.f,
               gfx::Rect(layer_bounds),
               base::Bind(&CountExistingTiles, &num_tiles));
   // If we're making a rect the size of one tile, it can only overlap up to 4
   // tiles depending on its position.
   EXPECT_LE(num_tiles, 4);
   VerifyTiles(1.f, gfx::Rect(), base::Bind(&TileExists, false));
 }
 
 TEST_F(PictureLayerTilingIteratorTest, AddTilingsToMatchScale) {
   gfx::Size layer_bounds(1099, 801);
   gfx::Size tile_size(100, 100);
 
   client_.SetTileSize(tile_size);
 
   PictureLayerTilingSet active_set(&client_, layer_bounds);
 
   active_set.AddTiling(1.f);
 
   VerifyTiles(active_set.tiling_at(0),
               1.f,
               gfx::Rect(layer_bounds),
               base::Bind(&TileExists, false));
 
+  set_max_tiles_for_interest_area(10000);
   active_set.UpdateTilePriorities(
       PENDING_TREE,
-      layer_bounds,  // device viewport
-      gfx::Rect(layer_bounds),  // viewport in layer space
       gfx::Rect(layer_bounds),  // visible content rect
-      layer_bounds,  // last layer bounds
-      layer_bounds,  // current layer bounds
-      1.f,  // last contents scale
-      1.f,  // current contents scale
-      gfx::Transform(),  // last screen transform
-      gfx::Transform(),  // current screen transform
-      1.0,  // current frame time
-      10000);  // max tiles in tile manager
+      1.f,                      // current contents scale
+      1.0);                     // current frame time
 
   // The active tiling has tiles now.
   VerifyTiles(active_set.tiling_at(0),
               1.f,
               gfx::Rect(layer_bounds),
               base::Bind(&TileExists, true));
 
   // Add the same tilings to the pending set.
   PictureLayerTilingSet pending_set(&client_, layer_bounds);
   Region invalidation;
   pending_set.SyncTilings(active_set, layer_bounds, invalidation, 0.f);
 
   // The pending tiling starts with no tiles.
   VerifyTiles(pending_set.tiling_at(0),
               1.f,
               gfx::Rect(layer_bounds),
               base::Bind(&TileExists, false));
 
   // UpdateTilePriorities on the pending tiling at the same frame time. The
   // pending tiling should get tiles.
   pending_set.UpdateTilePriorities(
       PENDING_TREE,
-      layer_bounds,  // device viewport
-      gfx::Rect(layer_bounds),  // viewport in layer space
       gfx::Rect(layer_bounds),  // visible content rect
-      layer_bounds,  // last layer bounds
-      layer_bounds,  // current layer bounds
-      1.f,  // last contents scale
-      1.f,  // current contents scale
-      gfx::Transform(),  // last screen transform
-      gfx::Transform(),  // current screen transform
-      1.0,  // current frame time
-      10000);  // max tiles in tile manager
+      1.f,                      // current contents scale
+      1.0);                     // current frame time
 
   VerifyTiles(pending_set.tiling_at(0),
               1.f,
               gfx::Rect(layer_bounds),
               base::Bind(&TileExists, true));
 }
 
 TEST(UpdateTilePrioritiesTest, VisibleTiles) {
   // The TilePriority of visible tiles should have zero distance_to_visible
   // and time_to_visible.
 
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
-  gfx::Rect visible_layer_rect(0, 0, 200, 200);
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
-  float last_layer_contents_scale = 1.f;
   float current_layer_contents_scale = 1.f;
-  gfx::Transform last_screen_transform;
   gfx::Transform current_screen_transform;
   double current_frame_time_in_seconds = 1.0;
   size_t max_tiles_for_interest_area = 10000;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
 
-  tiling->UpdateTilePriorities(
-      ACTIVE_TREE,
-      device_viewport,
-      viewport_in_layer_space,
-      visible_layer_rect,
-      last_layer_bounds,
-      current_layer_bounds,
-      last_layer_contents_scale,
-      current_layer_contents_scale,
-      last_screen_transform,
-      current_screen_transform,
-      current_frame_time_in_seconds,
-      max_tiles_for_interest_area);
+  client.set_max_tiles_for_interest_area(max_tiles_for_interest_area);

[enne (OOO), 2014/02/11 00:43:56]

Can the fake client just set a "really large" max tiles for interest area by
default?

[vmpstr, 2014/02/11 23:45:25]

Done.

+  tiling->UpdateTilePriorities(ACTIVE_TREE,
+                               viewport_in_layer_space,
+                               current_layer_contents_scale,
+                               current_frame_time_in_seconds);
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
   TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
-  EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
+  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+  EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
-  EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
+  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+  EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
-  EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
+  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+  EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
-  EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
+  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+  EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
 }
 
 TEST(UpdateTilePrioritiesTest, OffscreenTiles) {
   // The TilePriority of offscreen tiles (without movement) should have nonzero
   // distance_to_visible and infinite time_to_visible.
 
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
-  gfx::Rect visible_layer_rect(0, 0, 0, 0);  // offscreen; nothing is visible.
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
-  float last_layer_contents_scale = 1.f;
   float current_layer_contents_scale = 1.f;
   gfx::Transform last_screen_transform;
   gfx::Transform current_screen_transform;
   double current_frame_time_in_seconds = 1.0;
   size_t max_tiles_for_interest_area = 10000;
 
   current_screen_transform.Translate(850, 0);
   last_screen_transform = current_screen_transform;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
 
-  tiling->UpdateTilePriorities(
-      ACTIVE_TREE,
-      device_viewport,
-      viewport_in_layer_space,
-      visible_layer_rect,
-      last_layer_bounds,
-      current_layer_bounds,
-      last_layer_contents_scale,
-      current_layer_contents_scale,
-      last_screen_transform,
-      current_screen_transform,
-      current_frame_time_in_seconds,
-      max_tiles_for_interest_area);
+  client.set_max_tiles_for_interest_area(max_tiles_for_interest_area);
+  tiling->UpdateTilePriorities(ACTIVE_TREE,
+                               viewport_in_layer_space,
+                               current_layer_contents_scale,
+                               current_frame_time_in_seconds);
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
   TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
+  EXPECT_GT(priority.distance_to_visible, 0.f);
+  EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
+  EXPECT_GT(priority.distance_to_visible, 0.f);
+  EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
+  EXPECT_GT(priority.distance_to_visible, 0.f);
+  EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
+  EXPECT_GT(priority.distance_to_visible, 0.f);
+  EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   // Furthermore, in this scenario tiles on the right hand side should have a
   // larger distance to visible.
   TilePriority left = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
   TilePriority right = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
-  EXPECT_GT(right.distance_to_visible_in_pixels,
-            left.distance_to_visible_in_pixels);
+  EXPECT_GT(right.distance_to_visible, left.distance_to_visible);
 
   left = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
   right = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
-  EXPECT_GT(right.distance_to_visible_in_pixels,
-            left.distance_to_visible_in_pixels);
+  EXPECT_GT(right.distance_to_visible, left.distance_to_visible);
 }
 
 TEST(UpdateTilePrioritiesTest, PartiallyOffscreenLayer) {
   // Sanity check that a layer with some tiles visible and others offscreen has
   // correct TilePriorities for each tile.
 
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
-  gfx::Rect visible_layer_rect(0, 0, 100, 100);  // only top quarter.
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
-  float last_layer_contents_scale = 1.f;
   float current_layer_contents_scale = 1.f;
   gfx::Transform last_screen_transform;
   gfx::Transform current_screen_transform;
   double current_frame_time_in_seconds = 1.0;
   size_t max_tiles_for_interest_area = 10000;
 
   current_screen_transform.Translate(705, 505);
   last_screen_transform = current_screen_transform;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
 
-  tiling->UpdateTilePriorities(
-      ACTIVE_TREE,
-      device_viewport,
-      viewport_in_layer_space,
-      visible_layer_rect,
-      last_layer_bounds,
-      current_layer_bounds,
-      last_layer_contents_scale,
-      current_layer_contents_scale,
-      last_screen_transform,
-      current_screen_transform,
-      current_frame_time_in_seconds,
-      max_tiles_for_interest_area);
+  client.set_max_tiles_for_interest_area(max_tiles_for_interest_area);
+  tiling->UpdateTilePriorities(ACTIVE_TREE,
+                               viewport_in_layer_space,
+                               current_layer_contents_scale,
+                               current_frame_time_in_seconds);
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
   TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
-  EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
+  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+  EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
+  EXPECT_GT(priority.distance_to_visible, 0.f);
+  EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
+  EXPECT_GT(priority.distance_to_visible, 0.f);
+  EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
+  EXPECT_GT(priority.distance_to_visible, 0.f);
+  EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 }
 
 TEST(UpdateTilePrioritiesTest, PartiallyOffscreenRotatedLayer) {
   // Each tile of a layer may be affected differently by a transform; Check
   // that UpdateTilePriorities correctly accounts for the transform between
   // layer space and screen space.
 
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
-  gfx::Rect visible_layer_rect(0, 0, 100, 100);  // only top-left quarter.
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
-  float last_layer_contents_scale = 1.f;
   float current_layer_contents_scale = 1.f;
   gfx::Transform last_screen_transform;
   gfx::Transform current_screen_transform;
   double current_frame_time_in_seconds = 1.0;
   size_t max_tiles_for_interest_area = 10000;
 
   // A diagonally rotated layer that is partially off the bottom of the screen.
   // In this configuration, only the top-left tile would be visible.
-  current_screen_transform.Translate(400, 550);
+  current_screen_transform.Translate(600, 750);
   current_screen_transform.RotateAboutZAxis(45);
   last_screen_transform = current_screen_transform;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
 
-  tiling->UpdateTilePriorities(
-      ACTIVE_TREE,
-      device_viewport,
-      viewport_in_layer_space,
-      visible_layer_rect,
-      last_layer_bounds,
-      current_layer_bounds,
-      last_layer_contents_scale,
-      current_layer_contents_scale,
-      last_screen_transform,
-      current_screen_transform,
-      current_frame_time_in_seconds,
-      max_tiles_for_interest_area);
+  client.set_max_tiles_for_interest_area(max_tiles_for_interest_area);
+  tiling->UpdateTilePriorities(ACTIVE_TREE,
+                               viewport_in_layer_space,
+                               current_layer_contents_scale,
+                               current_frame_time_in_seconds);
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
   TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
-  EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
+  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+  EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
+  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+  EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
+  EXPECT_GT(priority.distance_to_visible, 0.f);
+  EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
+  EXPECT_GT(priority.distance_to_visible, 0.f);
+  EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   // Furthermore, in this scenario the bottom-right tile should have the larger
   // distance to visible.
   TilePriority top_left = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
   TilePriority top_right = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
-  TilePriority bottom_left = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
   TilePriority bottom_right = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
-  EXPECT_GT(top_right.distance_to_visible_in_pixels,
-            top_left.distance_to_visible_in_pixels);
-  EXPECT_GT(bottom_left.distance_to_visible_in_pixels,
-            top_left.distance_to_visible_in_pixels);
+  EXPECT_GT(top_right.distance_to_visible, top_left.distance_to_visible);
 
-  EXPECT_GT(bottom_right.distance_to_visible_in_pixels,
-            bottom_left.distance_to_visible_in_pixels);
-  EXPECT_GT(bottom_right.distance_to_visible_in_pixels,
-            top_right.distance_to_visible_in_pixels);
+  EXPECT_EQ(bottom_right.distance_to_visible, top_right.distance_to_visible);
 }
 
 TEST(UpdateTilePrioritiesTest, PerspectiveLayer) {
   // Perspective transforms need to take a different code path.
   // This test checks tile priorities of a perspective layer.
 
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Rect visible_layer_rect(0, 0, 0, 0);  // offscreen.
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
-  float last_layer_contents_scale = 1.f;
   float current_layer_contents_scale = 1.f;
   gfx::Transform last_screen_transform;
   gfx::Transform current_screen_transform;
   double current_frame_time_in_seconds = 1.0;
   size_t max_tiles_for_interest_area = 10000;
 
   // A 3d perspective layer rotated about its Y axis, translated to almost
   // fully offscreen. The left side will appear closer (i.e. larger in 2d) than
   // the right side, so the top-left tile will technically be closer than the
   // top-right.
@@ skipping 15 matching lines @@
   ASSERT_FALSE(clipped);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
 
-  tiling->UpdateTilePriorities(
-      ACTIVE_TREE,
-      device_viewport,
-      viewport_in_layer_space,
-      visible_layer_rect,
-      last_layer_bounds,
-      current_layer_bounds,
-      last_layer_contents_scale,
-      current_layer_contents_scale,
-      last_screen_transform,
-      current_screen_transform,
-      current_frame_time_in_seconds,
-      max_tiles_for_interest_area);
+  client.set_max_tiles_for_interest_area(max_tiles_for_interest_area);
+  tiling->UpdateTilePriorities(ACTIVE_TREE,
+                               viewport_in_layer_space,
+                               current_layer_contents_scale,
+                               current_frame_time_in_seconds);
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
   // All tiles will have a positive distance_to_visible
   // and an infinite time_to_visible.
   TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
+  EXPECT_FLOAT_EQ(priority.distance_to_visible, 0.f);
+  EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
+  EXPECT_GT(priority.distance_to_visible, 0.f);
+  EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
+  EXPECT_FLOAT_EQ(priority.distance_to_visible, 0.f);
+  EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
+  EXPECT_GT(priority.distance_to_visible, 0.f);
+  EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   // Furthermore, in this scenario the top-left distance_to_visible
   // will be smallest, followed by top-right. The bottom layers
   // will of course be further than the top layers.
   TilePriority top_left = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
   TilePriority top_right = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
   TilePriority bottom_left = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
   TilePriority bottom_right = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
-  EXPECT_GT(top_right.distance_to_visible_in_pixels,
-            top_left.distance_to_visible_in_pixels);
 
-  EXPECT_GT(bottom_right.distance_to_visible_in_pixels,
-            top_right.distance_to_visible_in_pixels);
+  EXPECT_GT(bottom_right.distance_to_visible, top_right.distance_to_visible);
 
-  EXPECT_GT(bottom_left.distance_to_visible_in_pixels,
-            top_left.distance_to_visible_in_pixels);
+  EXPECT_GT(bottom_left.distance_to_visible, top_left.distance_to_visible);
 }
 
 TEST(UpdateTilePrioritiesTest, PerspectiveLayerClippedByW) {
   // Perspective transforms need to take a different code path.
   // This test checks tile priorities of a perspective layer.
 
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
-  gfx::Rect visible_layer_rect(0, 0, 0, 0);  // offscreen.
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
-  float last_layer_contents_scale = 1.f;
   float current_layer_contents_scale = 1.f;
   gfx::Transform last_screen_transform;
   gfx::Transform current_screen_transform;
   double current_frame_time_in_seconds = 1.0;
   size_t max_tiles_for_interest_area = 10000;
 
   // A 3d perspective layer rotated about its Y axis, translated to almost
   // fully offscreen. The left side will appear closer (i.e. larger in 2d) than
   // the right side, so the top-left tile will technically be closer than the
   // top-right.
@@ skipping 21 matching lines @@
   ASSERT_FALSE(clipped);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
 
-  tiling->UpdateTilePriorities(
-      ACTIVE_TREE,
-      device_viewport,
-      viewport_in_layer_space,
-      visible_layer_rect,
-      last_layer_bounds,
-      current_layer_bounds,
-      last_layer_contents_scale,
-      current_layer_contents_scale,
-      last_screen_transform,
-      current_screen_transform,
-      current_frame_time_in_seconds,
-      max_tiles_for_interest_area);
+  client.set_max_tiles_for_interest_area(max_tiles_for_interest_area);
+  tiling->UpdateTilePriorities(ACTIVE_TREE,
+                               viewport_in_layer_space,
+                               current_layer_contents_scale,
+                               current_frame_time_in_seconds);
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
   // Left-side tiles will be clipped by the transform, so we have to assume
   // they are visible just in case.
   TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
-  EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
+  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+  EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
-  EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
+  EXPECT_GT(priority.distance_to_visible, 0.f);
+  EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   // Right-side tiles will have a positive distance_to_visible
   // and an infinite time_to_visible.
   priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
+  EXPECT_FLOAT_EQ(priority.distance_to_visible, 0.f);
+  EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
+  EXPECT_GT(priority.distance_to_visible, 0.f);
+  EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 }
 
 TEST(UpdateTilePrioritiesTest, BasicMotion) {
   // Test that time_to_visible is computed correctly when
   // there is some motion.
 
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
@@ skipping 13 matching lines @@
   last_screen_transform.Translate(2800, 0);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
 
+  client.set_max_tiles_for_interest_area(max_tiles_for_interest_area);
   // previous ("last") frame
-  tiling->UpdateTilePriorities(
-      ACTIVE_TREE,
-      device_viewport,
-      viewport_in_layer_space,
-      visible_layer_rect,
-      last_layer_bounds,
-      last_layer_bounds,
-      last_layer_contents_scale,
-      last_layer_contents_scale,
-      last_screen_transform,
-      last_screen_transform,
-      last_frame_time_in_seconds,
-      max_tiles_for_interest_area);
+  tiling->UpdateTilePriorities(ACTIVE_TREE,
+                               viewport_in_layer_space,
+                               last_layer_contents_scale,
+                               last_frame_time_in_seconds);
 
   // current frame
-  tiling->UpdateTilePriorities(
-      ACTIVE_TREE,
-      device_viewport,
-      viewport_in_layer_space,
-      visible_layer_rect,
-      last_layer_bounds,
-      current_layer_bounds,
-      last_layer_contents_scale,
-      current_layer_contents_scale,
-      last_screen_transform,
-      current_screen_transform,
-      current_frame_time_in_seconds,
-      max_tiles_for_interest_area);
+  tiling->UpdateTilePriorities(ACTIVE_TREE,
+                               viewport_in_layer_space,
+                               current_layer_contents_scale,
+                               current_frame_time_in_seconds);
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
   TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(1.f,
-                  priority.time_to_visible_in_seconds);
+  EXPECT_GT(priority.distance_to_visible, 0.f);
+  EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(1.f,
-                  priority.time_to_visible_in_seconds);
+  EXPECT_GT(priority.distance_to_visible, 0.f);
+  EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   // time_to_visible for the right hand side layers needs an extra 0.099
   // seconds because this tile is 99 pixels further away.
   priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(1.099f,
-                  priority.time_to_visible_in_seconds);
+  EXPECT_GT(priority.distance_to_visible, 0.f);
+  EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(1.099f,
-                  priority.time_to_visible_in_seconds);
+  EXPECT_GT(priority.distance_to_visible, 0.f);
+  EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 }
 
 TEST(UpdateTilePrioritiesTest, RotationMotion) {
   // Each tile of a layer may be affected differently by a transform; Check
   // that UpdateTilePriorities correctly accounts for the transform between
   // layer space and screen space.
 
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
@@ skipping 22 matching lines @@
   last_screen_transform.Translate(400, 550);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
 
+  client.set_max_tiles_for_interest_area(max_tiles_for_interest_area);
+
   // previous ("last") frame
-  tiling->UpdateTilePriorities(
-      ACTIVE_TREE,
-      device_viewport,
-      viewport_in_layer_space,
-      visible_layer_rect,
-      last_layer_bounds,
-      last_layer_bounds,
-      last_layer_contents_scale,
-      last_layer_contents_scale,
-      last_screen_transform,
-      last_screen_transform,
-      last_frame_time_in_seconds,
-      max_tiles_for_interest_area);
+  tiling->UpdateTilePriorities(ACTIVE_TREE,
+                               viewport_in_layer_space,
+                               last_layer_contents_scale,
+                               last_frame_time_in_seconds);
 
   // current frame
-  tiling->UpdateTilePriorities(
-      ACTIVE_TREE,
-      device_viewport,
-      viewport_in_layer_space,
-      visible_layer_rect,
-      last_layer_bounds,
-      current_layer_bounds,
-      last_layer_contents_scale,
-      current_layer_contents_scale,
-      last_screen_transform,
-      current_screen_transform,
-      current_frame_time_in_seconds,
-      max_tiles_for_interest_area);
+  tiling->UpdateTilePriorities(ACTIVE_TREE,
+                               viewport_in_layer_space,
+                               current_layer_contents_scale,
+                               current_frame_time_in_seconds);
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
   TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
-  EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
+  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+  EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_GT(priority.time_to_visible_in_seconds, 0.f);
+  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+  EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
+  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
+  EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 }
 
 }  // namespace
 }  // namespace cc