Implement SkImageFilter support in the compositor.

cc/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 "config.h"
 
 #include "cc/gl_renderer.h"
 
 #include "CCDamageTracker.h"
 #include "CCLayerQuad.h"
 #include "FloatQuad.h"
+#include "GrContext.h"
 #include "GrTexture.h"
 #include "NotImplemented.h"
+#include "SkGpuDevice.h"
+#include "SkGrTexturePixelRef.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "cc/geometry_binding.h"
 #include "cc/math_util.h"
 #include "cc/platform_color.h"
 #include "cc/proxy.h"
 #include "cc/render_pass.h"
 #include "cc/render_surface_filters.h"
@@ skipping 318 matching lines @@
     if (!filterContext || !filterGrContext)
         return SkBitmap();
 
     renderer->context()->flush();
 
     CCResourceProvider::ScopedWriteLockGL lock(renderer->resourceProvider(), sourceTexture->id());
     SkBitmap source = CCRenderSurfaceFilters::apply(filters, lock.textureId(), sourceTexture->size(), filterContext, filterGrContext);
     return source;
 }
 
+static SkBitmap applyImageFilter(CCRendererGL* renderer, SkImageFilter* filter, CCScopedTexture* sourceTexture)
+{
+    if (!filter)
+        return SkBitmap();
+
+    WebGraphicsContext3D* context3d = CCProxy::hasImplThread() ? WebSharedGraphicsContext3D::compositorThreadContext() : WebSharedGraphicsContext3D::mainThreadContext();
+    GrContext* grContext = CCProxy::hasImplThread() ? WebSharedGraphicsContext3D::compositorThreadGrContext() : WebSharedGraphicsContext3D::mainThreadGrContext();
+
+    if (!context3d || !grContext)
+        return SkBitmap();
+
+    renderer->context()->flush();
+
+    CCResourceProvider::ScopedWriteLockGL lock(renderer->resourceProvider(), sourceTexture->id());
+
+    // Wrap the source texture in a Ganesh platform texture.
+    GrPlatformTextureDesc platformTextureDescription;
+    platformTextureDescription.fWidth = sourceTexture->size().width();
+    platformTextureDescription.fHeight = sourceTexture->size().height();
+    platformTextureDescription.fConfig = kSkia8888_GrPixelConfig;
+    platformTextureDescription.fTextureHandle = lock.textureId();
+    SkAutoTUnref<GrTexture> texture(grContext->createPlatformTexture(platformTextureDescription));
+
+    // Place the platform texture inside an SkBitmap.
+    SkBitmap source;
+    source.setConfig(SkBitmap::kARGB_8888_Config, sourceTexture->size().width(), sourceTexture->size().height());
+    source.setPixelRef(new SkGrPixelRef(texture.get()))->unref();
+    
+    // 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;
+    GrAutoScratchTexture scratchTexture(grContext, desc, GrContext::kExact_ScratchTexMatch);
+
+    // Create a device and canvas using that backing store.
+    SkGpuDevice device(grContext, scratchTexture.detach());
+    SkCanvas canvas(&device);
+
+    // Draw the source bitmap through the filter to the canvas.
+    SkPaint paint;
+    paint.setImageFilter(filter);
+    canvas.clear(0x0);
+    canvas.drawSprite(source, 0, 0, &paint);
+    canvas.flush();
+    context3d->flush();
+    return device.accessBitmap(false);
+}
+
 scoped_ptr<CCScopedTexture> CCRendererGL::drawBackgroundFilters(DrawingFrame& frame, const CCRenderPassDrawQuad* quad, const WebKit::WebFilterOperations& filters, const WebTransformationMatrix& contentsDeviceTransform)
 {
     // This method draws a background filter, which applies a filter to any pixels behind the quad and seen through its background.
     // The algorithm works as follows:
     // 1. Compute a bounding box around the pixels that will be visible through the quad.
     // 2. Read the pixels in the bounding box into a buffer R.
     // 3. Apply the background filter to R, so that it is applied in the pixels' coordinate space.
     // 4. Apply the quad's inverse transform to map the pixels in R into the quad's content space. This implicitly
     // clips R by the content bounds of the quad since the destination texture has bounds matching the quad's content.
     // 5. Draw the background texture for the contents using the same transform as used to draw the contents itself. This is done
@@ skipping 73 matching lines @@
     WebTransformationMatrix contentsDeviceTransform = (frame.windowMatrix * frame.projectionMatrix * quadRectMatrix).to2dTransform();
 
     // Can only draw surface if device matrix is invertible.
     if (!contentsDeviceTransform.isInvertible())
         return;
 
     scoped_ptr<CCScopedTexture> backgroundTexture = drawBackgroundFilters(frame, quad, renderPass->backgroundFilters(), contentsDeviceTransform);
 
     // FIXME: 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 filterBitmap = applyFilters(this, renderPass->filters(), contentsTexture);
+    SkBitmap filterBitmap;
+    if (renderPass->filter()) {
+        filterBitmap = applyImageFilter(this, renderPass->filter(), contentsTexture);
+    } else {
+        filterBitmap = applyFilters(this, renderPass->filters(), contentsTexture);
+    }
     scoped_ptr<CCResourceProvider::ScopedReadLockGL> contentsResourceLock;
     unsigned contentsTextureId = 0;
     if (filterBitmap.getTexture()) {
         GrTexture* texture = reinterpret_cast<GrTexture*>(filterBitmap.getTexture());
         contentsTextureId = texture->getTextureHandle();
     } else {
         contentsResourceLock = make_scoped_ptr(new CCResourceProvider::ScopedReadLockGL(m_resourceProvider, contentsTexture->id()));
         contentsTextureId = contentsResourceLock->textureId();
     }
 
@@ skipping 1057 matching lines @@
 
     releaseRenderPassTextures();
 }
 
 bool CCRendererGL::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 } // namespace cc