cc: Find a better prioritized rect when the viewport rect is huge.

cc/resources/picture_layer_tiling.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 <algorithm>
 #include <cmath>
 
 #include "base/debug/trace_event.h"
@@ skipping 324 matching lines @@
 }
 
 gfx::Size PictureLayerTiling::CoverageIterator::texture_size() const {
   return tiling_->tiling_data_.max_texture_size();
 }
 
 void PictureLayerTiling::UpdateTilePriorities(
     WhichTree tree,
     gfx::Size device_viewport,
     const gfx::RectF& viewport_in_layer_space,
+    const gfx::RectF& visible_layer_rect,
     gfx::Size last_layer_bounds,
     gfx::Size current_layer_bounds,
     float last_layer_contents_scale,
     float current_layer_contents_scale,
     const gfx::Transform& last_screen_transform,
     const gfx::Transform& current_screen_transform,
     int current_source_frame_number,
     double current_frame_time,
     bool store_screen_space_quads_on_tiles,
     size_t max_tiles_for_interest_area) {
@@ skipping 16 matching lines @@
   if (!first_update_in_new_impl_frame && !first_update_in_new_source_frame)
     return;
 
   double time_delta = 0;
   if (last_impl_frame_time_ != 0 && last_layer_bounds == current_layer_bounds)
     time_delta = current_frame_time - last_impl_frame_time_;
 
   gfx::Rect viewport_in_content_space =
       gfx::ToEnclosingRect(gfx::ScaleRect(viewport_in_layer_space,
                                           contents_scale_));
+  gfx::Rect visible_content_rect =
+      gfx::ToEnclosingRect(gfx::ScaleRect(visible_layer_rect,
+                                          contents_scale_));
 
   gfx::Size tile_size = tiling_data_.max_texture_size();
   int64 prioritized_rect_area =
       max_tiles_for_interest_area *
       tile_size.width() * tile_size.height();
 
+  gfx::Rect starting_rect = visible_content_rect.IsEmpty()
+                            ? viewport_in_content_space
+                            : visible_content_rect;
   gfx::Rect prioritized_rect = ExpandRectEquallyToAreaBoundedBy(
-      viewport_in_content_space,
+      starting_rect,
       prioritized_rect_area,
       ContentRect());
   DCHECK(ContentRect().Contains(prioritized_rect));
 
   // Iterate through all of the tiles that were live last frame but will
   // not be live this frame, and mark them as being dead.
   for (TilingData::DifferenceIterator iter(&tiling_data_,
                                            last_prioritized_rect_,
                                            prioritized_rect);
        iter;
@@ skipping 159 matching lines @@
 gfx::Rect PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
     gfx::Rect starting_rect,
     int64 target_area,
     gfx::Rect bounding_rect) {
   if (starting_rect.IsEmpty())
     return starting_rect;
 
   DCHECK(!bounding_rect.IsEmpty());
   DCHECK_GT(target_area, 0);
 
-  // Expand the starting rect to cover target_area.
+  // Expand the starting rect to cover target_area, if it is smaller than it.
   int delta = ComputeExpansionDelta(
       2, 2, starting_rect.width(), starting_rect.height(), target_area);
   gfx::Rect expanded_starting_rect = starting_rect;
-  expanded_starting_rect.Inset(-delta, -delta);
+  if (delta > 0)
+    expanded_starting_rect.Inset(-delta, -delta);
 
   gfx::Rect rect = IntersectRects(expanded_starting_rect, bounding_rect);
   if (rect.IsEmpty()) {
     // The starting_rect and bounding_rect are far away.
     return rect;
   }
-  if (rect == expanded_starting_rect) {
-    // The expanded starting rect already covers target_area on bounding_rect.
+  if (delta >= 0 && rect == expanded_starting_rect) {
+    // The starting rect already covers the entire bounding_rect and isn't too
+    // large for the target_area.
     return rect;
   }
 
-  // Continue to expand rect to let it cover target_area.
+  // Continue to expand/shrink rect to let it cover target_area.
 
   // These values will be updated by the loop and uses as the output.
   int origin_x = rect.x();
   int origin_y = rect.y();
   int width = rect.width();
   int height = rect.height();
 
   // In the beginning we will consider 2 edges in each dimension.
   int num_y_edges = 2;
   int num_x_edges = 2;
 
   // Create an event list.
   EdgeEvent events[] = {
     { EdgeEvent::BOTTOM, &num_y_edges, rect.y() - bounding_rect.y() },
     { EdgeEvent::TOP, &num_y_edges, bounding_rect.bottom() - rect.bottom() },
     { EdgeEvent::LEFT, &num_x_edges, rect.x() - bounding_rect.x() },
     { EdgeEvent::RIGHT, &num_x_edges, bounding_rect.right() - rect.right() }
   };
 
   // Sort the events by distance (closest first).
   if (events[0].distance > events[1].distance) std::swap(events[0], events[1]);
   if (events[2].distance > events[3].distance) std::swap(events[2], events[3]);
   if (events[0].distance > events[2].distance) std::swap(events[0], events[2]);
   if (events[1].distance > events[3].distance) std::swap(events[1], events[3]);
   if (events[1].distance > events[2].distance) std::swap(events[1], events[2]);
 
   for (int event_index = 0; event_index < 4; event_index++) {
     const EdgeEvent& event = events[event_index];
 
-    // Early out if our distance to event is 0.
-    // This optimization is not required for correctness.
-    if (event.distance == 0) {
-      --*event.num_edges;
-      continue;
-    }
-
     int delta = ComputeExpansionDelta(
         num_x_edges, num_y_edges, width, height, target_area);
 
     // Clamp delta to our event distance.
     if (delta > event.distance)
       delta = event.distance;
 
     // Adjust the edge count for this kind of edge.
     --*event.num_edges;
 
@@ skipping 20 matching lines @@
 
     // If our delta is less then our event distance, we're done.
     if (delta < event.distance)
       break;
   }
 
   return gfx::Rect(origin_x, origin_y, width, height);
 }
 
 }  // namespace cc