cc: Use the onscreen context to perform composited ganesh filters.

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 <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 159 matching lines @@
       return SamplerType2D;
   }
 }
 
 // Smallest unit that impact anti-aliasing output. We use this to
 // determine when anti-aliasing is unnecessary.
 const float kAntiAliasingEpsilon = 1.0f / 1024.0f;
 
 }  // anonymous namespace
 
+class GLRenderer::UseGrContext {

[enne (OOO), 2014/04/23 19:53:41]

ScopedUseGrContext?

[Stephen White, 2014/04/23 19:57:20]

I find this guard class to be too much magic. I like guard classes which do
cleanup on destruction, but I'm not fond of meaty code that's done in a guard's
destructor. Are there actual early-outs that are made cleaner/less verbose by
the use of this guard, or could we simply make the explicit calls when
necessary?

[danakj, 2014/04/23 20:11:10]

 2014/04/23 19:57:20, Stephen White wrote:
This ensures that we clean up before returning to the GLRenderer. There's no
reason we can't add explicit calls and have that work. But then when someone
adds an early out some day in the future, we'll have to fix bugs.

This reminds me a lot of the skia manual-refcounting vs smart pointer
discussions. As with there, I sit on the side of do-it-with-scoped-objects when
you want to do something that is scoped in nature.

+ public:
+  static scoped_ptr<UseGrContext> Create(GLRenderer* renderer,
+                                         DrawingFrame* frame) {
+    if (!renderer->output_surface_->context_provider()->GrContext())
+      return scoped_ptr<UseGrContext>();
+    return make_scoped_ptr(new UseGrContext(renderer, frame));
+  }
+
+  ~UseGrContext() { PassControlToGLRenderer(); }
+
+  GrContext* context() const {
+    return renderer_->output_surface_->context_provider()->GrContext();
+  }
+
+ private:
+  UseGrContext(GLRenderer* renderer, DrawingFrame* frame)
+      : renderer_(renderer), frame_(frame) {
+    PassControlToSkia();
+  }
+
+  void PassControlToSkia() { context()->resetContext(); }
+
+  void PassControlToGLRenderer() {
+    context()->flush();
+    renderer_->RestoreGLState(frame_);
+  }
+
+  GLRenderer* renderer_;
+  DrawingFrame* frame_;
+  DISALLOW_COPY_AND_ASSIGN(UseGrContext);

[enne (OOO), 2014/04/23 19:53:41]

Stick a blank line before DISALLOW for readability?

+};
+
 struct GLRenderer::PendingAsyncReadPixels {
   PendingAsyncReadPixels() : buffer(0) {}
 
   scoped_ptr<CopyOutputRequest> copy_request;
   base::CancelableClosure finished_read_pixels_callback;
   unsigned buffer;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PendingAsyncReadPixels);
 };
@@ skipping 103 matching lines @@
   capabilities_.max_texture_size = resource_provider_->max_texture_size();
   capabilities_.best_texture_format = resource_provider_->best_texture_format();
 
   // The updater can access textures while the GLRenderer is using them.
   capabilities_.allow_partial_texture_updates = true;
 
   // Check for texture fast paths. Currently we always use MO8 textures,
   // so we only need to avoid POT textures if we have an NPOT fast-path.
   capabilities_.avoid_pow2_textures = context_caps.gpu.fast_npot_mo8_textures;
 
-  capabilities_.using_offscreen_context3d = true;
+  capabilities_.using_offscreen_context3d = false;
 
   capabilities_.using_map_image =
       settings_->use_map_image && context_caps.gpu.map_image;
 
   capabilities_.using_discard_framebuffer =
       context_caps.gpu.discard_framebuffer;
 
   capabilities_.allow_rasterize_on_demand = true;
 
   use_sync_query_ = context_caps.gpu.sync_query;
@@ skipping 248 matching lines @@
                      (SkColorGetB(color) * (1.0f / 255.0f)) * alpha,
                      alpha));
 
   GLC(gl_, gl_->LineWidth(quad->width));
 
   // The indices for the line are stored in the same array as the triangle
   // indices.
   GLC(gl_, gl_->DrawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 0));
 }
 
-static SkBitmap ApplyImageFilter(GLRenderer* renderer,
-                                 ContextProvider* offscreen_contexts,
-                                 const gfx::Point& origin,
-                                 SkImageFilter* filter,
-                                 ScopedResource* source_texture_resource) {
+static SkBitmap ApplyImageFilter(
+    scoped_ptr<GLRenderer::UseGrContext> use_gr_context,
+    ResourceProvider* resource_provider,
+    const gfx::Point& origin,
+    SkImageFilter* filter,
+    ScopedResource* source_texture_resource) {
   if (!filter)
     return SkBitmap();
 
-  if (!offscreen_contexts || !offscreen_contexts->GrContext())
+  if (!use_gr_context)
     return SkBitmap();
 
-  ResourceProvider::ScopedReadLockGL lock(renderer->resource_provider(),
+  ResourceProvider::ScopedReadLockGL lock(resource_provider,
                                           source_texture_resource->id());
 
-  // Flush the compositor context to ensure that textures there are available
-  // in the shared context.  Do this after locking/creating the compositor
-  // texture.
-  renderer->resource_provider()->Flush();
-
   // Wrap the source texture in a Ganesh platform texture.
   GrBackendTextureDesc backend_texture_description;
   backend_texture_description.fWidth = source_texture_resource->size().width();
   backend_texture_description.fHeight =
       source_texture_resource->size().height();
   backend_texture_description.fConfig = kSkia8888_GrPixelConfig;
   backend_texture_description.fTextureHandle = lock.texture_id();
   backend_texture_description.fOrigin = kBottomLeft_GrSurfaceOrigin;
   skia::RefPtr<GrTexture> texture =
-      skia::AdoptRef(offscreen_contexts->GrContext()->wrapBackendTexture(
+      skia::AdoptRef(use_gr_context->context()->wrapBackendTexture(
           backend_texture_description));
 
   SkImageInfo info = {
     source_texture_resource->size().width(),
     source_texture_resource->size().height(),
     kPMColor_SkColorType,
     kPremul_SkAlphaType
   };
   // Place the platform texture inside an SkBitmap.
   SkBitmap source;
   source.setConfig(info);
   skia::RefPtr<SkGrPixelRef> pixel_ref =
       skia::AdoptRef(new SkGrPixelRef(info, texture.get()));
   source.setPixelRef(pixel_ref.get());
 
   // Create a scratch texture for backing store.
   GrTextureDesc desc;
   desc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
   desc.fSampleCnt = 0;
   desc.fWidth = source.width();
   desc.fHeight = source.height();
   desc.fConfig = kSkia8888_GrPixelConfig;
   desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
   GrAutoScratchTexture scratch_texture(
-      offscreen_contexts->GrContext(), desc, GrContext::kExact_ScratchTexMatch);
+      use_gr_context->context(), desc, GrContext::kExact_ScratchTexMatch);
   skia::RefPtr<GrTexture> backing_store =
       skia::AdoptRef(scratch_texture.detach());
 
   // Create a device and canvas using that backing store.
-  SkGpuDevice device(offscreen_contexts->GrContext(), backing_store.get());
+  SkGpuDevice device(use_gr_context->context(), backing_store.get());
   SkCanvas canvas(&device);
 
   // Draw the source bitmap through the filter to the canvas.
   SkPaint paint;
   paint.setImageFilter(filter);
   canvas.clear(SK_ColorTRANSPARENT);
 
   // TODO(senorblanco): in addition to the origin translation here, the canvas
   // should also be scaled to accomodate device pixel ratio and pinch zoom. See
   // crbug.com/281516 and crbug.com/281518.
   canvas.translate(SkIntToScalar(-origin.x()), SkIntToScalar(-origin.y()));
   canvas.drawSprite(source, 0, 0, &paint);
 
-  // Flush skia context so that all the rendered stuff appears on the
-  // texture.
-  offscreen_contexts->GrContext()->flush();
-
-  // Flush the GL context so rendering results from this context are
-  // visible in the compositor's context.
-  offscreen_contexts->ContextGL()->Flush();
-
   return device.accessBitmap(false);
 }
 
 static SkBitmap ApplyBlendModeWithBackdrop(
-    GLRenderer* renderer,
-    ContextProvider* offscreen_contexts,
+    scoped_ptr<GLRenderer::UseGrContext> use_gr_context,
+    ResourceProvider* resource_provider,
     SkBitmap source_bitmap_with_filters,
     ScopedResource* source_texture_resource,
     ScopedResource* background_texture_resource,
     SkXfermode::Mode blend_mode) {
-  if (!offscreen_contexts || !offscreen_contexts->GrContext())
+  if (!use_gr_context)
     return source_bitmap_with_filters;
 
   DCHECK(background_texture_resource);
   DCHECK(source_texture_resource);
 
   gfx::Size source_size = source_texture_resource->size();
   gfx::Size background_size = background_texture_resource->size();
 
   DCHECK_LE(background_size.width(), source_size.width());
   DCHECK_LE(background_size.height(), source_size.height());
 
   int source_texture_with_filters_id;
   scoped_ptr<ResourceProvider::ScopedReadLockGL> lock;
   if (source_bitmap_with_filters.getTexture()) {
     DCHECK_EQ(source_size.width(), source_bitmap_with_filters.width());
     DCHECK_EQ(source_size.height(), source_bitmap_with_filters.height());
     GrTexture* texture =
         reinterpret_cast<GrTexture*>(source_bitmap_with_filters.getTexture());
     source_texture_with_filters_id = texture->getTextureHandle();
   } else {
     lock.reset(new ResourceProvider::ScopedReadLockGL(
-        renderer->resource_provider(), source_texture_resource->id()));
+        resource_provider, source_texture_resource->id()));
     source_texture_with_filters_id = lock->texture_id();
   }
 
   ResourceProvider::ScopedReadLockGL lock_background(
-      renderer->resource_provider(), background_texture_resource->id());
-
-  // Flush the compositor context to ensure that textures there are available
-  // in the shared context.  Do this after locking/creating the compositor
-  // texture.
-  renderer->resource_provider()->Flush();
+      resource_provider, background_texture_resource->id());
 
   // Wrap the source texture in a Ganesh platform texture.
   GrBackendTextureDesc backend_texture_description;
   backend_texture_description.fConfig = kSkia8888_GrPixelConfig;
   backend_texture_description.fOrigin = kBottomLeft_GrSurfaceOrigin;
 
   backend_texture_description.fWidth = source_size.width();
   backend_texture_description.fHeight = source_size.height();
   backend_texture_description.fTextureHandle = source_texture_with_filters_id;
   skia::RefPtr<GrTexture> source_texture =
-      skia::AdoptRef(offscreen_contexts->GrContext()->wrapBackendTexture(
+      skia::AdoptRef(use_gr_context->context()->wrapBackendTexture(
           backend_texture_description));
 
   backend_texture_description.fWidth = background_size.width();
   backend_texture_description.fHeight = background_size.height();
   backend_texture_description.fTextureHandle = lock_background.texture_id();
   skia::RefPtr<GrTexture> background_texture =
-      skia::AdoptRef(offscreen_contexts->GrContext()->wrapBackendTexture(
+      skia::AdoptRef(use_gr_context->context()->wrapBackendTexture(
           backend_texture_description));
 
   SkImageInfo source_info = {
     source_size.width(),
     source_size.height(),
     kPMColor_SkColorType,
     kPremul_SkAlphaType
   };
   // Place the platform texture inside an SkBitmap.
   SkBitmap source;
@@ skipping 18 matching lines @@
 
   // Create a scratch texture for backing store.
   GrTextureDesc desc;
   desc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
   desc.fSampleCnt = 0;
   desc.fWidth = source.width();
   desc.fHeight = source.height();
   desc.fConfig = kSkia8888_GrPixelConfig;
   desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
   GrAutoScratchTexture scratch_texture(
-      offscreen_contexts->GrContext(), desc, GrContext::kExact_ScratchTexMatch);
+      use_gr_context->context(), desc, GrContext::kExact_ScratchTexMatch);
   skia::RefPtr<GrTexture> backing_store =
       skia::AdoptRef(scratch_texture.detach());
 
   // Create a device and canvas using that backing store.
-  SkGpuDevice device(offscreen_contexts->GrContext(), backing_store.get());
+  SkGpuDevice device(use_gr_context->context(), backing_store.get());
   SkCanvas canvas(&device);
 
   // Draw the source bitmap through the filter to the canvas.
   canvas.clear(SK_ColorTRANSPARENT);
   canvas.drawSprite(background, 0, 0);
   SkPaint paint;
   paint.setXfermodeMode(blend_mode);
   canvas.drawSprite(source, 0, 0, &paint);
 
-  // Flush skia context so that all the rendered stuff appears on the
-  // texture.
-  offscreen_contexts->GrContext()->flush();
-
-  // Flush the GL context so rendering results from this context are
-  // visible in the compositor's context.
-  offscreen_contexts->ContextGL()->Flush();
-
   return device.accessBitmap(false);
 }
 
 scoped_ptr<ScopedResource> GLRenderer::GetBackgroundWithFilters(
     DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
     const gfx::Transform& contents_device_transform,
     const gfx::Transform& contents_device_transform_inverse,
     bool* background_changed) {
   // This method draws a background filter, which applies a filter to any pixels
@@ skipping 56 matching lines @@
     GetFramebufferTexture(
         lock.texture_id(), device_background_texture->format(), window_rect);
   }
 
   skia::RefPtr<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
       quad->background_filters, device_background_texture->size());
 
   SkBitmap filtered_device_background;
   if (apply_background_filters) {
     filtered_device_background =
-        ApplyImageFilter(this,
-                         frame->offscreen_context_provider,
+        ApplyImageFilter(UseGrContext::Create(this, frame),
+                         resource_provider_,
                          quad->rect.origin(),
                          filter.get(),
                          device_background_texture.get());
   }
   *background_changed = (filtered_device_background.getTexture() != NULL);
 
   int filtered_device_background_texture_id = 0;
   scoped_ptr<ResourceProvider::ScopedReadLockGL> lock;
   if (filtered_device_background.getTexture()) {
     GrTexture* texture =
@@ skipping 90 matching lines @@
 
     if (disable_blending)
       SetBlendEnabled(true);
   }
 
   // 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.
   SkBitmap filter_bitmap;
   SkScalar color_matrix[20];
   bool use_color_matrix = false;
-  // TODO(ajuma): Always use RenderSurfaceFilters::BuildImageFilter, not just
-  // when we have a reference filter.
   if (!quad->filters.IsEmpty()) {
     skia::RefPtr<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
         quad->filters, contents_texture->size());
     if (filter) {
       skia::RefPtr<SkColorFilter> cf;
 
       {
         SkColorFilter* colorfilter_rawptr = NULL;
         filter->asColorFilter(&colorfilter_rawptr);
         cf = skia::AdoptRef(colorfilter_rawptr);
       }
 
       if (cf && cf->asColorMatrix(color_matrix) && !filter->getInput(0)) {
         // We have a single color matrix as a filter; apply it locally
         // in the compositor.
         use_color_matrix = true;
       } else {
-        filter_bitmap = ApplyImageFilter(this,
-                                         frame->offscreen_context_provider,
+        filter_bitmap = ApplyImageFilter(UseGrContext::Create(this, frame),
+                                         resource_provider_,
                                          quad->rect.origin(),
                                          filter.get(),
                                          contents_texture);
       }
     }
   }
 
   if (quad->shared_quad_state->blend_mode != SkXfermode::kSrcOver_Mode &&
       background_texture) {
     filter_bitmap =
-        ApplyBlendModeWithBackdrop(this,
-                                   frame->offscreen_context_provider,
+        ApplyBlendModeWithBackdrop(UseGrContext::Create(this, frame),
+                                   resource_provider_,
                                    filter_bitmap,
                                    contents_texture,
                                    background_texture.get(),
                                    quad->shared_quad_state->blend_mode);
   }
 
   // Draw the background texture if it has some filters applied.
   if (background_texture && background_changed) {
     DCHECK(background_texture->size() == quad->rect.size());
     ResourceProvider::ScopedReadLockGL lock(resource_provider_,
@@ skipping 2119 matching lines @@
   GLC(gl_, gl_->BlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
   GLC(gl_, gl_->ActiveTexture(GL_TEXTURE0));
   program_shadow_ = 0;
 
   // Make sure scissoring starts as disabled.
   is_scissor_enabled_ = false;
   GLC(gl_, gl_->Disable(GL_SCISSOR_TEST));
   scissor_rect_needs_reset_ = true;
 }
 
+void GLRenderer::RestoreGLState(DrawingFrame* frame) {

[enne (OOO), 2014/04/23 19:53:41]

How does this function compare to ReinitializeGLState?

[danakj, 2014/04/23 19:56:05]

It's similar but

1. It doesn't change any state on the GLRenderer class itself, except the
program.

(Whereas the other resets variables to default states and forces things off/on
which is not valid in the middle of drawing a set of quads.)

2. It does UseRenderPass() to re-setup the viewport.

[enne (OOO), 2014/04/23 20:01:10]

I think you should combine these if possible.  I think you could make
ReinitializeGLState do what you do here, to set stencil and blend to the
shadowed state rather than clobbering.  I also think this doesn't do the right
thing wrt scissor.  You should have to set scissor_rect_needs_reset_ to true and
do something with is_scissor_enabled_ as well, right?
That is different, but maybe that can be moved into the UseGrContext class?

[danakj, 2014/04/23 20:11:10]

I can give merging them a try again.
I don't think so. The scissor_rect_needs_reset_ = true causes gl_->Scissor() to
be called. But we're calling it here. I specifically want to not change any
member variables on GLRenderer, so it can come back in the same state it was in.

Because I've set the Scissor, I could change scissor_rect_needs_reset_ to false
here, but it will always be false during the drawing of the frame if the scissor
was ever enabled.
I'll try making it a separate method on the GLRenderer.

+  shared_geometry_->PrepareForDraw();
+
+  GLC(gl_, gl_->Disable(GL_DEPTH_TEST));
+  GLC(gl_, gl_->Disable(GL_CULL_FACE));
+  GLC(gl_, gl_->ColorMask(true, true, true, true));
+  GLC(gl_, gl_->BlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
+  GLC(gl_, gl_->ActiveTexture(GL_TEXTURE0));
+
+  if (stencil_shadow_)

[Stephen White, 2014/04/23 19:57:20]

I'm a little nervous that this state-setting code is only used by filters, and
not by GPU rasterization, for example, which might leave it fragile.

Is there a way we could refactor this with ReinitializeGLState()? I.e.,
ReinitializeGLState() could set the member vars (stencil_shadow_, blend_shadow_,
is_scissor_enabled_, etc), and then just call this function to actually set GL
state? Then it would get exercised more broadly.

+    GLC(gl_, gl_->Enable(GL_STENCIL_TEST));
+  else
+    GLC(gl_, gl_->Disable(GL_STENCIL_TEST));
+
+  if (blend_shadow_)
+    GLC(gl_, gl_->Enable(GL_BLEND));
+  else
+    GLC(gl_, gl_->Disable(GL_BLEND));
+
+  if (is_scissor_enabled_) {
+    GLC(gl_, gl_->Enable(GL_SCISSOR_TEST));
+    GLC(gl_,
+        gl_->Scissor(scissor_rect_.x(),
+                     scissor_rect_.y(),
+                     scissor_rect_.width(),
+                     scissor_rect_.height()));
+  } else {
+    GLC(gl_, gl_->Disable(GL_SCISSOR_TEST));
+  }
+
+  SetUseProgram(0);
+
+  UseRenderPass(frame, frame->current_render_pass);
+}
+
 bool GLRenderer::IsContextLost() {
   return output_surface_->context_provider()->IsContextLost();
 }
 
 void GLRenderer::ScheduleOverlays(DrawingFrame* frame) {
   if (!frame->overlay_list.size())
     return;
 
   ResourceProvider::ResourceIdArray resources;
   OverlayCandidateList& overlays = frame->overlay_list;
@@ skipping 11 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         overlay.display_rect,
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc