cc: optimize texture allocation.

cc/output/gl_renderer.cc

 // Copyright 2010 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/output/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 123 matching lines @@
     case SkXfermode::kColor_Mode:
       return BLEND_MODE_COLOR;
     case SkXfermode::kLuminosity_Mode:
       return BLEND_MODE_LUMINOSITY;
     default:
       NOTREACHED();
       return BLEND_MODE_NONE;
   }
 }
 
+void RoundUpToPow2(gfx::RectF* rect) {
+  int w, h;

[danakj, 2016/05/04 21:24:58]

you're using ints here but it's a RectF.

[Stephen White, 2016/05/04 21:27:31]

Yep. There are implicit casts in the comparisons and the call to set_width() and
set_height(), but the multiplies are faster. :)

+  for (w = 1; w < rect->width(); w *= 2) {

[enne (OOO), 2016/05/04 21:32:22]

If you're casting to ints here for performance, might as well go all the way and
https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2 instead of
a loop.

[Stephen White, 2016/05/04 21:47:17]

Cute! I don't really care about performance here; I was just being annoying.
I've changed them to floats for clarity.

+  }
+  for (h = 1; h < rect->height(); h *= 2) {
+  }
+  rect->set_width(w);
+  rect->set_height(h);
+}
+
 // Smallest unit that impact anti-aliasing output. We use this to
 // determine when anti-aliasing is unnecessary.
 const float kAntiAliasingEpsilon = 1.0f / 1024.0f;
 
 // Block or crash if the number of pending sync queries reach this high as
 // something is seriously wrong on the service side if this happens.
 const size_t kMaxPendingSyncQueries = 16;
 
 }  // anonymous namespace
 
@@ skipping 871 matching lines @@
         gfx::Transform transform =
             quad->shared_quad_state->quad_to_target_transform;
         gfx::QuadF clip_quad = gfx::QuadF(gfx::RectF(clip_rect));
         gfx::QuadF local_clip = MapQuadToLocalSpace(transform, clip_quad);
         dst_rect.Intersect(local_clip.BoundingBox());
         // If we've been fully clipped out (by crop rect or clipping), there's
         // nothing to draw.
         if (dst_rect.IsEmpty()) {
           return;
         }
+        // Expand dst_rect size to the nearest power of 2, in order to get

[enne (OOO), 2016/05/04 21:32:22]

Are there limits on the size that is supported here? Like, very big textures now
becoming ~2-4 times as big?

[Stephen White, 2016/05/04 21:47:17]

If you mean, will the allocation fail due to an invalid texture dimension, I'm
pretty sure all GL texture limits are a power of 2, so no.

For overall size, these textures count against Skia's texture budget, so they
may cause other scratch textures to be evicted or reused, but they shouldn't
increase the VRAM footprint on balance.

(Note that the internal textures allocated for filter processing in Skia are
already rounded up the same way.)

+        // more cache hits in Skia's texture cache.
+        RoundUpToPow2(&dst_rect);
         filter_image = ApplyImageFilter(
             ScopedUseGrContext::Create(this, frame), resource_provider_, rect,
             dst_rect, scale, std::move(filter), contents_texture);
         if (filter_image) {
           filter_image_id = skia::GrBackendObjectToGrGLTextureInfo(
                                 filter_image->getTextureHandle(true))
                                 ->fID;
           DCHECK(filter_image_id);
           rect = dst_rect;
         }
@@ skipping 2603 matching lines @@
       texture_id = pending_overlay_resources_.back()->texture_id();
     }
 
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order, overlay.transform, texture_id,
         ToNearestRect(overlay.display_rect), overlay.uv_rect);
   }
 }
 
 }  // namespace cc