cc: Remove LayerTextureUpdater::Texture::updateRect() callback.

cc/CCResourceProvider.cpp

 // 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 "config.h"
 
 #include "CCResourceProvider.h"
 #ifdef LOG
 #undef LOG
 #endif
 
 #include <limits.h>
 
 #include "base/debug/alias.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "CCProxy.h"
 #include "CCRendererGL.h" // For the GLC() macro.
 #include "Extensions3DChromium.h"
 #include "IntRect.h"
 #include "LayerTextureSubImage.h"
+#include "SkGpuDevice.h"
 #include "ThrottledTextureUploader.h"
 #include "UnthrottledTextureUploader.h"
 #include <public/WebGraphicsContext3D.h>
+#include <public/WebSharedGraphicsContext3D.h>
 #include <wtf/HashSet.h>
 
 using WebKit::WebGraphicsContext3D;
+using WebKit::WebSharedGraphicsContext3D;
 
 namespace {
     // Temporary variables for debugging crashes in issue 151428 in canary.
     // Do not use these!
     const int g_debugMaxResourcesTracked = 64;
     unsigned int g_debugZone = 0;
     int64 g_debugResDestroyedCount = 0;
     cc::CCResourceProvider::ResourceId g_debugResDestroyed[g_debugMaxResourcesTracked] = { 0 };
+
+PassOwnPtr<SkCanvas> createAcceleratedCanvas(GrContext* grContext,
+                                             cc::IntSize canvasSize,
+                                             unsigned textureId)
+{
+    GrPlatformTextureDesc textureDesc;
+    textureDesc.fFlags = kRenderTarget_GrPlatformTextureFlag;
+    textureDesc.fWidth = canvasSize.width();
+    textureDesc.fHeight = canvasSize.height();
+    textureDesc.fConfig = kSkia8888_GrPixelConfig;
+    textureDesc.fTextureHandle = textureId;
+    SkAutoTUnref<GrTexture> target(
+        grContext->createPlatformTexture(textureDesc));
+    SkAutoTUnref<SkDevice> device(new SkGpuDevice(grContext, target.get()));
+    return adoptPtr(new SkCanvas(device.get()));
+}
+
 }
 
 namespace cc {
 
 static GC3Denum textureToStorageFormat(GC3Denum textureFormat)
 {
     GC3Denum storageFormat = Extensions3D::RGBA8_OES;
     switch (textureFormat) {
     case GraphicsContext3D::RGBA:
         break;
@@ skipping 256 matching lines @@
         SkIRect skSourceRect = SkIRect::MakeXYWH(sourceRect.x(), sourceRect.y(), sourceRect.width(), sourceRect.height());
         skSourceRect.offset(-imageRect.x(), -imageRect.y());
         srcFull.extractSubset(&srcSubset, skSourceRect);
 
         ScopedWriteLockSoftware lock(this, id);
         SkCanvas* dest = lock.skCanvas();
         dest->writePixels(srcSubset, destOffset.width(), destOffset.height());
     }
 }
 
+void CCResourceProvider::acceleratedUpdate(ResourceId id, SkPicture* picture, const IntRect& pictureRect, const IntRect& sourceRect, const IntSize& destOffset)
+{
+    ASSERT(CCProxy::isImplThread());
+    ResourceMap::iterator it = m_resources.find(id);
+    CHECK(it != m_resources.end());
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+    Resource* resource = &it->value;
+#else
+    Resource* resource = &it->second;
+#endif
+    ASSERT(!resource->lockedForWrite);
+    ASSERT(!resource->lockForReadCount);
+    ASSERT(!resource->external);
+
+    if (resource->glId) {
+        WebGraphicsContext3D* paintContext = CCProxy::hasImplThread() ? WebSharedGraphicsContext3D::compositorThreadContext() : WebSharedGraphicsContext3D::mainThreadContext();
+        GrContext* paintGrContext = CCProxy::hasImplThread() ? WebSharedGraphicsContext3D::compositorThreadGrContext() : WebSharedGraphicsContext3D::mainThreadGrContext();
+
+        // 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.
+        flush();
+
+        ScopedWriteLockGL lock(this, id);
+
+        // Make sure ganesh uses the correct GL context.
+        paintContext->makeContextCurrent();
+
+        // Create an accelerated canvas to draw on.
+        OwnPtr<SkCanvas> canvas = createAcceleratedCanvas(paintGrContext, resource->size, resource->glId);
+
+        // 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, resource->size.height());
+        canvas->scale(1.0, -1.0);
+        // Clip to the destination on the texture that must be updated.
+        canvas->clipRect(SkRect::MakeXYWH(destOffset.width(), destOffset.height(), 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.width(),
+            pictureRect.y() - sourceRect.y() + destOffset.height());
+        canvas->drawPicture(*picture);
+
+        // Flush ganesh context so that all the rendered stuff appears on the texture.
+        paintGrContext->flush();
+
+        // Flush the GL context so rendering results from this context are visible in the compositor's context.
+        paintContext->flush();
+    }
+
+    if (resource->pixels) {
+        ScopedWriteLockSoftware lock(this, id);
+        SkCanvas* canvas = lock.skCanvas();
+        canvas->save();
+        // Translate the origin of pictureRect to that of sourceRect.
+        canvas->translate(pictureRect.x() - sourceRect.x(),
+                          pictureRect.y() - sourceRect.y());
+        canvas->drawPicture(*picture);
+        canvas->restore();
+    }
+}
+
 void CCResourceProvider::flush()
 {
     ASSERT(CCProxy::isImplThread());
     WebGraphicsContext3D* context3d = m_context->context3D();
     if (context3d)
         context3d->flush();
 }
 
 bool CCResourceProvider::shallowFlushIfSupported()
 {
@@ skipping 414 matching lines @@
 {
     g_debugZone = zone;
 }
 
 void CCResourceProvider::debugNotifyLeaveZone()
 {
     g_debugZone = 0;
 }
 
 }