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

cc/resource_update_controller.cc

 // Copyright 2012 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/resource_update_controller.h"
 
 #include <limits>
 
 #include "base/debug/trace_event.h"
 #include "cc/prioritized_resource.h"
 #include "cc/resource_provider.h"
 #include "cc/texture_copier.h"
 #include "cc/thread.h"
 #include "skia/ext/refptr.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/skia/include/gpu/SkGpuDevice.h"
+#include "ui/gl/context_provider.h"
 
 using WebKit::WebGraphicsContext3D;
-using WebKit::WebSharedGraphicsContext3D;
 
 namespace {
 
 // Number of partial updates we allow.
 const size_t partialTextureUpdatesMax = 12;
 
 // Measured in seconds.
 const double textureUpdateTickRate = 0.004;
 
 // Measured in seconds.
@@ skipping 28 matching lines @@
 }
 
 size_t ResourceUpdateController::maxFullUpdatesPerTick(
     ResourceProvider* resourceProvider)
 {
     double texturesPerSecond = resourceProvider->estimatedUploadsPerSecond();
     size_t texturesPerTick = floor(textureUpdateTickRate * texturesPerSecond);
     return texturesPerTick ? texturesPerTick : 1;
 }
 
-ResourceUpdateController::ResourceUpdateController(ResourceUpdateControllerClient* client, Thread* thread, scoped_ptr<ResourceUpdateQueue> queue, ResourceProvider* resourceProvider, bool hasImplThread)
+ResourceUpdateController::ResourceUpdateController(ResourceUpdateControllerClient* client, Thread* thread, scoped_ptr<ResourceUpdateQueue> queue, ResourceProvider* resourceProvider)
     : m_client(client)
-    , m_hasImplThread(hasImplThread)
     , m_queue(queue.Pass())
     , m_resourceProvider(resourceProvider)
     , m_textureUpdatesPerTick(maxFullUpdatesPerTick(resourceProvider))
     , m_firstUpdateAttempt(true)
     , m_thread(thread)
     , m_weakFactory(ALLOW_THIS_IN_INITIALIZER_LIST(this))
     , m_taskPosted(false)
 {
 }
 
@@ skipping 40 matching lines @@
         gfx::Rect pictureRect = update.content_rect;
         gfx::Rect sourceRect = update.source_rect;
         gfx::Vector2d destOffset = update.dest_offset;
 
         texture->acquireBackingTexture(m_resourceProvider);
         DCHECK(texture->haveBackingTexture());
 
         DCHECK(m_resourceProvider->resourceType(texture->resourceId()) ==
                ResourceProvider::GLTexture);
 
-        WebGraphicsContext3D* paintContext = m_hasImplThread ?
-            WebSharedGraphicsContext3D::compositorThreadContext() :
-            WebSharedGraphicsContext3D::mainThreadContext();
-        GrContext* paintGrContext = m_hasImplThread ?
-            WebSharedGraphicsContext3D::compositorThreadGrContext() :
-            WebSharedGraphicsContext3D::mainThreadGrContext();
+        ui::ContextProvider* offscreenContexts = m_resourceProvider->offscreenContextProvider();
 
-        // Flush the context in which the backing texture is created so that it
-        // is available in other shared contexts. It is important to do here
-        // because the backing texture is created in one context while it is
-        // being written to in another.
         ResourceProvider::ScopedWriteLockGL lock(
             m_resourceProvider, texture->resourceId());
+
+        // Flush the compositor context to ensure that textures there are available
+        // in the shared context.  Do this after locking/creating the compositor
+        // texture.
         m_resourceProvider->flush();
 
         // Make sure ganesh uses the correct GL context.
-        paintContext->makeContextCurrent();
+        offscreenContexts->Context3d()->makeContextCurrent();
 
         // Create an accelerated canvas to draw on.
         skia::RefPtr<SkCanvas> canvas = createAcceleratedCanvas(
-            paintGrContext, texture->size(), lock.textureId());
+            offscreenContexts->GrContext(), texture->size(), lock.textureId());
 
         // The compositor expects the textures to be upside-down so it can flip
         // the final composited image. Ganesh renders the image upright so we
         // need to do a y-flip.
         canvas->translate(0.0, texture->size().height());
         canvas->scale(1.0, -1.0);
         // Clip to the destination on the texture that must be updated.
         canvas->clipRect(SkRect::MakeXYWH(destOffset.x(),
                                           destOffset.y(),
                                           sourceRect.width(),
                                           sourceRect.height()));
         // Translate the origin of pictureRect to destOffset.
         // Note that destOffset is defined relative to sourceRect.
         canvas->translate(
             pictureRect.x() - sourceRect.x() + destOffset.x(),
             pictureRect.y() - sourceRect.y() + destOffset.y());
         canvas->drawPicture(*update.picture);
 
         // Flush ganesh context so that all the rendered stuff appears on the
         // texture.
-        paintGrContext->flush();
+        offscreenContexts->GrContext()->flush();
 
         // Flush the GL context so rendering results from this context are
         // visible in the compositor's context.
-        paintContext->flush();
+        offscreenContexts->Context3d()->flush();
     }
 
     if (update.bitmap) {
         update.bitmap->lockPixels();
         update.texture->setPixels(
             m_resourceProvider,
             static_cast<const uint8_t*>(update.bitmap->getPixels()),
             update.content_rect,
             update.source_rect,
             update.dest_offset);
@@ skipping 94 matching lines @@
     if (!uploads)
         return;
 
     while (m_queue->fullUploadSize() && uploads--)
         updateTexture(m_queue->takeFirstFullUpload());
 
     m_resourceProvider->flushUploads();
 }
 
 }  // namespace cc