cc: Route offscreen context creation for compositor to the browser.

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 "cc/gl_renderer.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "build/build_config.h"
 #include "cc/compositor_frame.h"
 #include "cc/compositor_frame_metadata.h"
 #include "cc/damage_tracker.h"
+#include "cc/ganesh_resource_provider.h"
 #include "cc/geometry_binding.h"
 #include "cc/gl_frame_data.h"
 #include "cc/layer_quad.h"
 #include "cc/math_util.h"
 #include "cc/priority_calculator.h"
 #include "cc/proxy.h"
 #include "cc/render_pass.h"
 #include "cc/render_surface_filters.h"
 #include "cc/scoped_resource.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/stream_video_draw_quad.h"
 #include "cc/texture_draw_quad.h"
 #include "cc/video_layer_impl.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebGraphicsContext3D.h"
-#include "third_party/WebKit/Source/Platform/chromium/public/WebSharedGraphicsContext3D.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/GrTexture.h"
 #include "third_party/skia/include/gpu/SkGpuDevice.h"
 #include "third_party/skia/include/gpu/SkGrTexturePixelRef.h"
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/rect_conversions.h"
 
 using WebKit::WebGraphicsContext3D;
 using WebKit::WebGraphicsMemoryAllocation;
-using WebKit::WebSharedGraphicsContext3D;
 
 namespace cc {
 
 namespace {
 
 bool needsIOSurfaceReadbackWorkaround()
 {
 #if defined(OS_MACOSX)
     return true;
 #else
@@ skipping 67 matching lines @@
     m_capabilities.usingDiscardBackbuffer = extensions.count("GL_CHROMIUM_discard_backbuffer");
 
     m_capabilities.usingEglImage = extensions.count("GL_OES_EGL_image_external");
 
     m_capabilities.maxTextureSize = m_resourceProvider->maxTextureSize();
     m_capabilities.bestTextureFormat = m_resourceProvider->bestTextureFormat();
 
     // The updater can access textures while the GLRenderer is using them.
     m_capabilities.allowPartialTextureUpdates = true;
 
+    m_capabilities.usingOffscreenContext3d = true;
+
     m_isUsingBindUniform = extensions.count("GL_CHROMIUM_bind_uniform_location");
 
     // Make sure scissoring starts as disabled.
     GLC(m_context, m_context->disable(GL_SCISSOR_TEST));
     DCHECK(!m_isScissorEnabled);
 
     if (!initializeSharedObjects())
         return false;
 
     // Make sure the viewport and context gets initialized, even if it is to zero.
@@ skipping 197 matching lines @@
     float alpha = SkColorGetA(color) / 255.0;
 
     GLC(context(), context()->uniform4f(program->fragmentShader().colorLocation(), (SkColorGetR(color) / 255.0) * alpha, (SkColorGetG(color) / 255.0) * alpha, (SkColorGetB(color) / 255.0) * alpha, alpha));
 
     GLC(context(), context()->lineWidth(quad->width));
 
     // The indices for the line are stored in the same array as the triangle indices.
     GLC(context(), context()->drawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 0));
 }
 
-static WebGraphicsContext3D* getFilterContext(bool hasImplThread)
-{
-    if (hasImplThread)
-        return WebSharedGraphicsContext3D::compositorThreadContext();
-    else
-        return WebSharedGraphicsContext3D::mainThreadContext();
-}
-
-static GrContext* getFilterGrContext(bool hasImplThread)
-{
-    if (hasImplThread)
-        return WebSharedGraphicsContext3D::compositorThreadGrContext();
-    else
-        return WebSharedGraphicsContext3D::mainThreadGrContext();
-}
-
-static inline SkBitmap applyFilters(GLRenderer* renderer, const WebKit::WebFilterOperations& filters, ScopedResource* sourceTexture, bool hasImplThread)
+static inline SkBitmap applyFilters(GLRenderer* renderer, const WebKit::WebFilterOperations& filters, ScopedResource* sourceResource)
 {
     if (filters.isEmpty())
         return SkBitmap();
 
-    WebGraphicsContext3D* filterContext = getFilterContext(hasImplThread);
-    GrContext* filterGrContext = getFilterGrContext(hasImplThread);
-
-    if (!filterContext || !filterGrContext)
+    if (!renderer->resourceProvider()->ganeshResourceProvider()->has_contexts())
         return SkBitmap();
 
-    renderer->context()->flush();
-
-    ResourceProvider::ScopedWriteLockGL lock(renderer->resourceProvider(), sourceTexture->id());
-    SkBitmap source = RenderSurfaceFilters::apply(filters, lock.textureId(), sourceTexture->size(), filterContext, filterGrContext);
+    ResourceProvider::ScopedWriteLockGL lock(renderer->resourceProvider(), sourceResource->id());
+    GaneshResourceProvider::ScopedContextsFlushed ganeshContexts(renderer->resourceProvider(), renderer->resourceProvider()->ganeshResourceProvider());
+    SkBitmap source = RenderSurfaceFilters::apply(filters, lock.textureId(), sourceResource->size(), ganeshContexts.gr_context());
     return source;
 }
 
-static SkBitmap applyImageFilter(GLRenderer* renderer, SkImageFilter* filter, ScopedResource* sourceTexture, bool hasImplThread)
+static SkBitmap applyImageFilter(GLRenderer* renderer, SkImageFilter* filter, ScopedResource* sourceResource)
 {
     if (!filter)
         return SkBitmap();
 
-    WebGraphicsContext3D* context3d = getFilterContext(hasImplThread);
-    GrContext* grContext = getFilterGrContext(hasImplThread);
-
-    if (!context3d || !grContext)
+    if (!renderer->resourceProvider()->ganeshResourceProvider()->has_contexts())
         return SkBitmap();
 
-    renderer->context()->flush();
+    ResourceProvider::ScopedWriteLockGL lock(renderer->resourceProvider(), sourceResource->id());
 
-    ResourceProvider::ScopedWriteLockGL lock(renderer->resourceProvider(), sourceTexture->id());
+    // Flush after locking the resource on the compositor context.
+    GaneshResourceProvider::ScopedContextsFlushed ganeshContexts(renderer->resourceProvider(), renderer->resourceProvider()->ganeshResourceProvider());
 
     // Wrap the source texture in a Ganesh platform texture.
     GrPlatformTextureDesc platformTextureDescription;
-    platformTextureDescription.fWidth = sourceTexture->size().width();
-    platformTextureDescription.fHeight = sourceTexture->size().height();
+    platformTextureDescription.fWidth = sourceResource->size().width();
+    platformTextureDescription.fHeight = sourceResource->size().height();
     platformTextureDescription.fConfig = kSkia8888_GrPixelConfig;
     platformTextureDescription.fTextureHandle = lock.textureId();
-    skia::RefPtr<GrTexture> texture = skia::AdoptRef(grContext->createPlatformTexture(platformTextureDescription));
+    skia::RefPtr<GrTexture> texture = skia::AdoptRef(ganeshContexts.gr_context()->createPlatformTexture(platformTextureDescription));
 
     // Place the platform texture inside an SkBitmap.
     SkBitmap source;
-    source.setConfig(SkBitmap::kARGB_8888_Config, sourceTexture->size().width(), sourceTexture->size().height());
+    source.setConfig(SkBitmap::kARGB_8888_Config, sourceResource->size().width(), sourceResource->size().height());
     skia::RefPtr<SkGrPixelRef> pixelRef = skia::AdoptRef(new SkGrPixelRef(texture.get()));
     source.setPixelRef(pixelRef.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;
-    GrAutoScratchTexture scratchTexture(grContext, desc, GrContext::kExact_ScratchTexMatch);
+    GrAutoScratchTexture scratchTexture(ganeshContexts.gr_context(), desc, GrContext::kExact_ScratchTexMatch);
     skia::RefPtr<GrTexture> backingStore = skia::AdoptRef(scratchTexture.detach());
 
     // Create a device and canvas using that backing store.
-    SkGpuDevice device(grContext, backingStore.get());
+    SkGpuDevice device(ganeshContexts.gr_context(), backingStore.get());
     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();

[Stephen White, 2013/02/07 22:07:52]

I hate to be a pain, but couldn't this simply be fixed by changing this
canvas.flush() to grContext->flush()?  It just seems like the guard class is a
bit overkill, in this case.  (I assume that GrContext::flush() subsumes the
functionality of canvas.flush(), but Brian can correct me if I'm wrong).

[danakj, 2013/02/07 22:11:14]

I like the guard class because it makes it impossible to miss the flush. We have
3 code paths that use these contexts and they each do different flushing. I'd
like to prevent that from happening in the future.

if we can drop the canvas.flush() here that'd be cool.

[bsalomon_chromium, 2013/02/08 01:55:57]

Calling GrContext::flush() is sufficient. You don't need to also call
SkCanvas::flush().

-    context3d->flush();
     return device.accessBitmap(false);
 }
 
 scoped_ptr<ScopedResource> GLRenderer::drawBackgroundFilters(
     DrawingFrame& frame, const RenderPassDrawQuad* quad,
     const gfx::Transform& contentsDeviceTransform,
     const gfx::Transform& contentsDeviceTransformInverse)
 {
     // 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:
@@ skipping 27 matching lines @@
     int top, right, bottom, left;
     filters.getOutsets(top, right, bottom, left);
     deviceRect.Inset(-left, -top, -right, -bottom);
 
     deviceRect.Intersect(frame.currentRenderPass->output_rect);
 
     scoped_ptr<ScopedResource> deviceBackgroundTexture = ScopedResource::create(m_resourceProvider);
     if (!getFramebufferTexture(deviceBackgroundTexture.get(), deviceRect))
         return scoped_ptr<ScopedResource>();
 
-    SkBitmap filteredDeviceBackground = applyFilters(this, filters, deviceBackgroundTexture.get(), m_client->hasImplThread());
+    SkBitmap filteredDeviceBackground = applyFilters(this, filters, deviceBackgroundTexture.get());
     if (!filteredDeviceBackground.getTexture())
         return scoped_ptr<ScopedResource>();
 
     GrTexture* texture = reinterpret_cast<GrTexture*>(filteredDeviceBackground.getTexture());
     int filteredDeviceBackgroundTextureId = texture->getTextureHandle();
 
     scoped_ptr<ScopedResource> backgroundTexture = ScopedResource::create(m_resourceProvider);
     if (!backgroundTexture->Allocate(quad->rect.size(), GL_RGBA, ResourceProvider::TextureUsageFramebuffer))
         return scoped_ptr<ScopedResource>();
 
@@ skipping 32 matching lines @@
     if (!contentsDeviceTransform.GetInverse(&contentsDeviceTransformInverse))
         return;
 
     scoped_ptr<ScopedResource> backgroundTexture = drawBackgroundFilters(
         frame, quad, contentsDeviceTransform, contentsDeviceTransformInverse);
 
     // 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;
     if (quad->filter) {
-        filterBitmap = applyImageFilter(this, quad->filter.get(), contentsTexture, m_client->hasImplThread());
+        filterBitmap = applyImageFilter(this, quad->filter.get(), contentsTexture);
     } else {
-        filterBitmap = applyFilters(this, quad->filters, contentsTexture, m_client->hasImplThread());
+        filterBitmap = applyFilters(this, quad->filters, contentsTexture);
     }
 
     // Draw the background texture if there is one.
     if (backgroundTexture) {
         DCHECK(backgroundTexture->size() == quad->rect.size());
         ResourceProvider::ScopedReadLockGL lock(m_resourceProvider, backgroundTexture->id());
         copyTextureToFramebuffer(frame, lock.textureId(), quad->rect, quad->quadTransform());
     }
 
     bool clipped = false;
@@ skipping 1239 matching lines @@
 
     releaseRenderPassTextures();
 }
 
 bool GLRenderer::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc