Prioritize tiles near the viewport in out-of-viewport layers

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 509 matching lines @@
 
 scoped_ptr<base::Value> PictureLayerTiling::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   state->SetInteger("num_tiles", tiles_.size());
   state->SetDouble("content_scale", contents_scale_);
   state->Set("content_bounds",
              MathUtil::AsValue(ContentRect().size()).release());
   return state.PassAs<base::Value>();
 }
 
+namespace {
+
 // This struct represents an event at which the expending rect intersects
 // one of its boundaries.  4 intersection events will occur during expansion.
 struct EdgeEvent {
   enum { BOTTOM, TOP, LEFT, RIGHT } edge;
   int* num_edges;
   int distance;
 };
 
+// Compute the delta to expand from edges to cover target_area.
+int ComputeExpansionDelta(int num_x_edges, int num_y_edges,
+                          int width, int height,
+                          int64 target_area) {
+  // Compute coefficients for the quadratic equation:
+  //   a*x^2 + b*x + c = 0
+  int a = num_y_edges * num_x_edges;
+  int b = num_y_edges * width + num_x_edges * height;
+  int64 c = static_cast<int64>(width) * height - target_area;
+
+  // Compute the delta for our edges using the quadratic equation.
+  return a == 0 ? -c / b :
+     (-b + static_cast<int>(
+         std::sqrt(static_cast<int64>(b) * b - 4.0 * a * c))) / (2 * a);
+}
+
+}  // namespace
+
 gfx::Rect PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
     gfx::Rect starting_rect,
     int64 target_area,
     gfx::Rect bounding_rect) {
   DCHECK(!starting_rect.IsEmpty());
   DCHECK(!bounding_rect.IsEmpty());
   DCHECK_GT(target_area, 0);
 
-  gfx::Rect rect = IntersectRects(starting_rect, bounding_rect);
-  if (rect.IsEmpty())
+  // Expand the starting rect to cover target_area.
+  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);
+
+  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.
+    return rect;
+  }
+
+  // Continue to expand 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;
@@ skipping 16 matching lines @@
   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;
     }
 
-    // Compute coefficients for the quadraic equation.
-    int a = num_y_edges * num_x_edges;
-    int b = num_y_edges * width + num_x_edges * height;
-    int c = width * height - target_area;
-
-    // Compute the delta for our edges using the quadratic equation.
-    int delta = a == 0 ? -c / b :
-       (-b + static_cast<int>(std::sqrt(b * b - 4.0 * a * c))) / (2 * a);
+    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;
 
     // Apply the delta to the edges and edge events.
     for (int i = event_index; i < 4; i++) {
@@ skipping 18 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