Optimize render passes with single quads

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 571 matching lines @@
 
   gl_->LineWidth(quad->width);
 
   // The indices for the line are stored in the same array as the triangle
   // indices.
   gl_->DrawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 0);
 }
 
 static sk_sp<SkImage> WrapTexture(
     const ResourceProvider::ScopedReadLockGL& lock,
-    GrContext* context) {
+    GrContext* context,
+    bool flip_texture) {
   // Wrap a given texture in a Ganesh platform texture.
   GrBackendTextureDesc backend_texture_description;
   GrGLTextureInfo texture_info;
   texture_info.fTarget = lock.target();
   texture_info.fID = lock.texture_id();
   backend_texture_description.fWidth = lock.texture_size().width();
   backend_texture_description.fHeight = lock.texture_size().height();
   backend_texture_description.fConfig = kSkia8888_GrPixelConfig;
   backend_texture_description.fTextureHandle =
       skia::GrGLTextureInfoToGrBackendObject(texture_info);
-  backend_texture_description.fOrigin = kBottomLeft_GrSurfaceOrigin;
+  backend_texture_description.fOrigin =
+      flip_texture ? kBottomLeft_GrSurfaceOrigin : kTopLeft_GrSurfaceOrigin;
 
   return SkImage::MakeFromTexture(context, backend_texture_description);
 }
 
 static sk_sp<SkImage> ApplyImageFilter(
     std::unique_ptr<GLRenderer::ScopedUseGrContext> use_gr_context,
     ResourceProvider* resource_provider,
     const gfx::RectF& src_rect,
     const gfx::RectF& dst_rect,
     const gfx::Vector2dF& scale,
     sk_sp<SkImageFilter> filter,
-    ScopedResource* source_texture_resource,
+    const Resource* source_texture_resource,
     SkIPoint* offset,
-    SkIRect* subset) {
+    SkIRect* subset,
+    bool flip_texture) {
   if (!filter || !use_gr_context)
     return nullptr;
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider,
                                           source_texture_resource->id());
 
-  sk_sp<SkImage> src_image = WrapTexture(lock, use_gr_context->context());
+  sk_sp<SkImage> src_image =
+      WrapTexture(lock, use_gr_context->context(), flip_texture);
+
   if (!src_image) {
     TRACE_EVENT_INSTANT0("cc",
                          "ApplyImageFilter wrap background texture failed",
                          TRACE_EVENT_SCOPE_THREAD);
     return nullptr;
   }
 
   SkMatrix local_matrix;
   local_matrix.setTranslate(-src_rect.x(), -src_rect.y());
   local_matrix.postScale(scale.x(), scale.y());
 
   SkIRect clip_bounds = gfx::RectFToSkRect(dst_rect).roundOut();
   clip_bounds.offset(-src_rect.x(), -src_rect.y());
   filter = filter->makeWithLocalMatrix(local_matrix);
-  SkIRect in_subset = SkIRect::MakeWH(src_image->width(), src_image->height());
+  SkIRect in_subset = SkIRect::MakeWH(src_rect.width(), src_rect.height());

[enne (OOO), 2016/06/09 18:52:29]

OOPS.  Here was the issue.  This fixes all the egregious reflection issues (and
makes the blurs look better too, unsurprisingly).

[Stephen White, 2016/06/09 19:48:28]

That makes sense! It should also improve performance, since we'll be filtering
fewer pixels.

   sk_sp<SkImage> image = src_image->makeWithFilter(filter.get(), in_subset,
                                                    clip_bounds, subset, offset);
 
   if (!image || !image->isTextureBacked()) {
     return nullptr;
   }
 
   // Force a flush of the Skia pipeline before we switch back to the compositor
   // context.
   image->getTextureHandle(true);
@@ skipping 195 matching lines @@
 
   // TODO(senorblanco): background filters should be moved to the
   // makeWithFilter fast-path, and go back to calling ApplyImageFilter().
   // See http://crbug.com/613233.
   if (!filter || !use_gr_context)
     return nullptr;
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider_,
                                           background_texture->id());
 
-  sk_sp<SkImage> src_image = WrapTexture(lock, use_gr_context->context());
+  bool flip_texture = true;
+  sk_sp<SkImage> src_image =
+      WrapTexture(lock, use_gr_context->context(), flip_texture);
   if (!src_image) {
     TRACE_EVENT_INSTANT0(
         "cc", "ApplyBackgroundFilters wrap background texture failed",
         TRACE_EVENT_SCOPE_THREAD);
     return nullptr;
   }
 
   // Create surface to draw into.
   SkImageInfo dst_info =
       SkImageInfo::MakeN32Premul(rect.width(), rect.height());
@@ skipping 37 matching lines @@
   DCHECK(did_invert);
   bool clipped = false;
   gfx::QuadF local_quad =
       MathUtil::MapQuad(inverse_device_transform, device_quad, &clipped);
   // We should not DCHECK(!clipped) here, because anti-aliasing inflation may
   // cause device_quad to become clipped. To our knowledge this scenario does
   // not need to be handled differently than the unclipped case.
   return local_quad;
 }
 
+const TileDrawQuad* GLRenderer::CanPassBeDrawnDirectly(const RenderPass* pass) {
+  // Can only collapse a single tile quad.
+  if (pass->quad_list.size() != 1)
+    return nullptr;
+  // If we need copy requests, then render pass has to exist.
+  if (!pass->copy_requests.empty())
+    return nullptr;
+
+  const DrawQuad* quad = *pass->quad_list.BackToFrontBegin();
+  // Hack: this could be supported by concatenating transforms, but
+  // in practice if there is one quad, it is at the origin of the render pass.
+  if (!quad->shared_quad_state->quad_to_target_transform.IsIdentity())
+    return nullptr;
+  // The quad is expected to be the entire layer so that AA edges are correct.
+  if (gfx::Rect(quad->shared_quad_state->quad_layer_bounds) != quad->rect)
+    return nullptr;
+  if (quad->material != DrawQuad::TILED_CONTENT)
+    return nullptr;
+
+  const TileDrawQuad* tile_quad = TileDrawQuad::MaterialCast(quad);
+  // Hack: this could be supported by passing in a subrectangle to draw
+  // render pass, although in practice if there is only one quad there
+  // will be no border texels on the input.
+  if (tile_quad->tex_coord_rect != gfx::RectF(tile_quad->rect))
+    return nullptr;
+  // Tile quad features not supported in render pass shaders.
+  if (tile_quad->swizzle_contents || tile_quad->nearest_neighbor)
+    return nullptr;
+  // BUG=skia:3868, Skia currently doesn't support texture rectangle inputs.
+  // See also the DCHECKs about GL_TEXTURE_2D in DrawRenderPassQuad.
+  GLenum target =
+      resource_provider_->GetResourceTextureTarget(tile_quad->resource_id());
+  if (target != GL_TEXTURE_2D)
+    return nullptr;
+#if defined(OS_MACOSX)
+  // On Macs, this path can sometimes lead to all black output.
+  // TODO(enne): investigate this and remove this hack.
+  return nullptr;
+#endif
+
+  return tile_quad;
+}
+
 void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
                                     const RenderPassDrawQuad* quad,
                                     const gfx::QuadF* clip_region) {
-  ScopedResource* contents_texture =
-      render_pass_textures_[quad->render_pass_id].get();
-  DCHECK(contents_texture);
-  DCHECK(contents_texture->id());
+  auto bypass = render_pass_bypass_quads_.find(quad->render_pass_id);
+  if (bypass != render_pass_bypass_quads_.end()) {
+    TileDrawQuad* tile_quad = &bypass->second;
+    // RGBA_8888 here is arbitrary and unused.
+    Resource tile_resource(tile_quad->resource_id(), tile_quad->texture_size,
+                           ResourceFormat::RGBA_8888);
+    // The projection matrix used by GLRenderer has a flip.  As tile texture
+    // inputs are oriented opposite to framebuffer outputs, don't flip via
+    // texture coords and let the projection matrix naturallyd o it.
+    bool flip_texture = false;
+    DrawRenderPassQuadInternal(frame, quad, clip_region, &tile_resource,
+                               flip_texture);
+  } else {
+    ScopedResource* contents_texture =
+        render_pass_textures_[quad->render_pass_id].get();
+    DCHECK(contents_texture);
+    DCHECK(contents_texture->id());
+    // See above comments about texture flipping.  When the input is a
+    // render pass, it needs to an extra flip to be oriented correctly.
+    bool flip_texture = true;
+    DrawRenderPassQuadInternal(frame, quad, clip_region, contents_texture,
+                               flip_texture);
+  }
+}
 
+void GLRenderer::DrawRenderPassQuadInternal(DrawingFrame* frame,
+                                            const RenderPassDrawQuad* quad,
+                                            const gfx::QuadF* clip_region,
+                                            const Resource* contents_texture,
+                                            bool flip_texture) {
   SkMatrix scale_matrix;
   scale_matrix.setScale(quad->filters_scale.x(), quad->filters_scale.y());
   gfx::RectF dst_rect(quad->filters.MapRect(quad->rect, scale_matrix));
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix,
                     quad->shared_quad_state->quad_to_target_transform,
                     dst_rect);
   gfx::Transform contents_device_transform =
       frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
   contents_device_transform.FlattenTo2d();
@@ skipping 84 matching lines @@
       !use_shaders_for_blending &&
       (quad->ShouldDrawWithBlending() || !IsDefaultBlendMode(blend_mode)));
 
   // TODO(senorblanco): Cache this value so that we don't have to do it for both
   // the surface and its replica.  Apply filters to the contents texture.
   sk_sp<SkImage> filter_image;
   GLuint filter_image_id = 0;
   SkScalar color_matrix[20];
   bool use_color_matrix = false;
   gfx::Size texture_size = contents_texture->size();
-  bool flip_texture = true;
   gfx::Point src_offset;
   if (!quad->filters.IsEmpty()) {
     sk_sp<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
         quad->filters, gfx::SizeF(contents_texture->size()));
     if (filter) {
       SkColorFilter* colorfilter_rawptr = NULL;
       filter->asColorFilter(&colorfilter_rawptr);
       sk_sp<SkColorFilter> cf(colorfilter_rawptr);
 
       if (cf && cf->asColorMatrix(color_matrix)) {
@@ skipping 14 matching lines @@
         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;
         }
         SkIPoint offset;
         SkIRect subset;
         gfx::RectF src_rect(quad->rect);
-        filter_image = ApplyImageFilter(ScopedUseGrContext::Create(this, frame),
-                                        resource_provider_, src_rect, dst_rect,
-                                        quad->filters_scale, std::move(filter),
-                                        contents_texture, &offset, &subset);
-        if (!filter_image) {
+        filter_image = ApplyImageFilter(
+            ScopedUseGrContext::Create(this, frame), resource_provider_,
+            src_rect, dst_rect, quad->filters_scale, std::move(filter),
+            contents_texture, &offset, &subset, flip_texture);
+        if (!filter_image)
           return;
-        }
         filter_image_id = skia::GrBackendObjectToGrGLTextureInfo(
                               filter_image->getTextureHandle(true))
                               ->fID;
         texture_size.set_width(filter_image->width());
         texture_size.set_height(filter_image->height());
         DCHECK(filter_image_id);
         dst_rect =
             gfx::RectF(src_rect.x() + offset.fX, src_rect.y() + offset.fY,
                        subset.width(), subset.height());
         src_offset.SetPoint(subset.x(), subset.y());
+        // If the output of the filter needs to be flipped.
         flip_texture =
             filter_image->getTexture()->origin() == kBottomLeft_GrSurfaceOrigin;
       }
     }
   }
 
   std::unique_ptr<ResourceProvider::ScopedSamplerGL> mask_resource_lock;
   unsigned mask_texture_id = 0;
   SamplerType mask_sampler = SAMPLER_TYPE_NA;
   if (quad->mask_resource_id()) {
@@ skipping 105 matching lines @@
   tex_rect.Scale(1.0f / texture_size.width(), 1.0f / texture_size.height());
 
   DCHECK(locations.tex_transform != -1 || IsContextLost());
   if (flip_texture) {
     // Flip the content vertically in the shader, as the RenderPass input
     // texture is already oriented the same way as the framebuffer, but the
     // projection transform does a flip.
     gl_->Uniform4f(locations.tex_transform, tex_rect.x(), 1.0f - tex_rect.y(),
                    tex_rect.width(), -tex_rect.height());
   } else {
+    // Tile textures are oriented opposite the framebuffer, so can use
+    // the projection transform to do the flip.
     gl_->Uniform4f(locations.tex_transform, tex_rect.x(), tex_rect.y(),
                    tex_rect.width(), tex_rect.height());
   }
 
   GLint last_texture_unit = 0;
   if (locations.mask_sampler != -1) {
     DCHECK_NE(locations.mask_tex_coord_scale, 1);
     DCHECK_NE(locations.mask_tex_coord_offset, 1);
     gl_->Uniform1i(locations.mask_sampler, 1);
 
     gfx::RectF mask_uv_rect = quad->MaskUVRect();
     if (mask_sampler != SAMPLER_TYPE_2D) {
       mask_uv_rect.Scale(quad->mask_texture_size.width(),
                          quad->mask_texture_size.height());
     }
-
-    // Mask textures are oriented vertically flipped relative to the framebuffer
-    // and the RenderPass contents texture, so we flip the tex coords from the
-    // RenderPass texture to find the mask texture coords.
-    gl_->Uniform2f(
-        locations.mask_tex_coord_offset, mask_uv_rect.x(),
-        mask_uv_rect.height() / tex_rect.height() + mask_uv_rect.y());
-    gl_->Uniform2f(locations.mask_tex_coord_scale,
-                   mask_uv_rect.width() / tex_rect.width(),
-                   -mask_uv_rect.height() / tex_rect.height());
+    if (flip_texture) {
+      // Mask textures are oriented vertically flipped relative to the
+      // framebuffer and the RenderPass contents texture, so we flip the tex
+      // coords from the RenderPass texture to find the mask texture coords.
+      gl_->Uniform2f(
+          locations.mask_tex_coord_offset, mask_uv_rect.x(),
+          mask_uv_rect.height() / tex_rect.height() + mask_uv_rect.y());
+      gl_->Uniform2f(locations.mask_tex_coord_scale,
+                     mask_uv_rect.width() / tex_rect.width(),
+                     -mask_uv_rect.height() / tex_rect.height());
+    } else {
+      // Tile textures are oriented the same way as mask textures.
+      gl_->Uniform2f(locations.mask_tex_coord_offset, mask_uv_rect.x(),
+                     mask_uv_rect.y());
+      gl_->Uniform2f(locations.mask_tex_coord_scale,
+                     mask_uv_rect.width() / tex_rect.width(),
+                     mask_uv_rect.height() / tex_rect.height());
+    }
 
     last_texture_unit = 1;
   }
 
   if (locations.edge != -1)
     gl_->Uniform3fv(locations.edge, 8, edge);
 
   if (locations.viewport != -1) {
     float viewport[4] = {
         static_cast<float>(current_window_space_viewport_.x()),
@@ skipping 2407 matching lines @@
       texture_id = pending_overlay_resources_.back()->GetTextureId();
     }
 
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order, overlay.transform, texture_id,
         ToNearestRect(overlay.display_rect), overlay.uv_rect);
   }
 }
 
 }  // namespace cc