Have a common implementation of cc::OutputSurface

cc/resource_provider.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_provider.h"
 
 #include <limits.h>
 
 #include "base/debug/alias.h"
 #include "base/hash_tables.h"
@@ skipping 130 matching lines @@
 scoped_ptr<ResourceProvider> ResourceProvider::create(OutputSurface* context)
 {
     scoped_ptr<ResourceProvider> resourceProvider(new ResourceProvider(context));
     if (!resourceProvider->initialize())
         return scoped_ptr<ResourceProvider>();
     return resourceProvider.Pass();
 }
 
 ResourceProvider::~ResourceProvider()
 {
-    WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+    WebGraphicsContext3D* context3d = m_outputSurface->context3d();
     if (!context3d || !context3d->makeContextCurrent())
         return;
     m_textureUploader.reset();
     m_textureCopier.reset();
 }
 
 WebGraphicsContext3D* ResourceProvider::graphicsContext3D()
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
-    return m_outputSurface->Context3D();
+    return m_outputSurface->context3d();
 }
 
 bool ResourceProvider::inUseByConsumer(ResourceId id)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     return !!resource->lockForReadCount || resource->exported;
 }
@@ skipping 25 matching lines @@
     LOG(FATAL) << "Invalid default resource type.";
     return 0;
 }
 
 ResourceProvider::ResourceId ResourceProvider::createGLTexture(const gfx::Size& size, GLenum format, GLenum texturePool, TextureUsageHint hint)
 {
     DCHECK_LE(size.width(), m_maxTextureSize);
     DCHECK_LE(size.height(), m_maxTextureSize);
 
     DCHECK(m_threadChecker.CalledOnValidThread());
-    WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+    WebGraphicsContext3D* context3d = m_outputSurface->context3d();
     DCHECK(context3d);
 
     // Create and set texture properties. Allocation is delayed until needed.
     unsigned textureId = createTextureId(context3d);
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_POOL_CHROMIUM, texturePool));
     if (m_useTextureUsageHint && hint == TextureUsageFramebuffer)
         GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_USAGE_ANGLE, GL_FRAMEBUFFER_ATTACHMENT_ANGLE));
 
     ResourceId id = m_nextId++;
     Resource resource(textureId, size, format, GL_LINEAR);
@@ skipping 12 matching lines @@
     Resource resource(pixels, size, GL_RGBA, GL_LINEAR);
     resource.allocated = true;
     m_resources[id] = resource;
     return id;
 }
 
 ResourceProvider::ResourceId ResourceProvider::createResourceFromExternalTexture(unsigned textureId)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
 
-    WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+    WebGraphicsContext3D* context3d = m_outputSurface->context3d();
     DCHECK(context3d);
     GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, textureId));
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
 
     ResourceId id = m_nextId++;
     Resource resource(textureId, gfx::Size(), 0, GL_LINEAR);
     resource.external = true;
@@ skipping 30 matching lines @@
         resource->markedForDeletion = true;
         return;
     } else
         deleteResourceInternal(it);
 }
 
 void ResourceProvider::deleteResourceInternal(ResourceMap::iterator it)
 {
     Resource* resource = &it->second;
     if (resource->glId && !resource->external) {
-        WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+        WebGraphicsContext3D* context3d = m_outputSurface->context3d();
         DCHECK(context3d);
         GLC(context3d, context3d->deleteTexture(resource->glId));
     }
     if (resource->glUploadQueryId) {
-        WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+        WebGraphicsContext3D* context3d = m_outputSurface->context3d();
         DCHECK(context3d);
         GLC(context3d, context3d->deleteQueryEXT(resource->glUploadQueryId));
     }
     if (resource->glPixelBufferId) {
-        WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+        WebGraphicsContext3D* context3d = m_outputSurface->context3d();
         DCHECK(context3d);
         GLC(context3d, context3d->deleteBuffer(resource->glPixelBufferId));
     }
     if (!resource->mailbox.IsEmpty() && resource->external) {
-        WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+        WebGraphicsContext3D* context3d = m_outputSurface->context3d();
         DCHECK(context3d);
         unsigned syncPoint = resource->mailbox.sync_point();
         if (resource->glId) {
             GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->glId));
             GLC(context3d, context3d->produceTextureCHROMIUM(GL_TEXTURE_2D, resource->mailbox.data()));
             GLC(context3d, context3d->deleteTexture(resource->glId));
             syncPoint = context3d->insertSyncPoint();
         }
         resource->mailbox.RunReleaseCallback(syncPoint);
     }
@@ skipping 21 matching lines @@
     Resource* resource = &it->second;
     DCHECK(!resource->lockedForWrite);
     DCHECK(!resource->lockForReadCount);
     DCHECK(!resource->external);
     DCHECK(!resource->exported);
     DCHECK(readLockFenceHasPassed(resource));
     lazyAllocate(resource);
 
     if (resource->glId) {
         DCHECK(!resource->pendingSetPixels);
-        WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+        WebGraphicsContext3D* context3d = m_outputSurface->context3d();
         DCHECK(context3d);
         DCHECK(m_textureUploader.get());
         context3d->bindTexture(GL_TEXTURE_2D, resource->glId);
         m_textureUploader->upload(image,
                                   imageRect,
                                   sourceRect,
                                   destOffset,
                                   resource->format,
                                   resource->size);
     }
@@ skipping 43 matching lines @@
 {
     if (!m_textureUploader)
         return;
 
     m_textureUploader->flush();
 }
 
 void ResourceProvider::flush()
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
-    WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+    WebGraphicsContext3D* context3d = m_outputSurface->context3d();
     if (context3d)
         context3d->flush();
 }
 
 bool ResourceProvider::shallowFlushIfSupported()
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
-    WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+    WebGraphicsContext3D* context3d = m_outputSurface->context3d();
     if (!context3d || !m_useShallowFlush)
         return false;
 
     context3d->shallowFlushCHROMIUM();
     return true;
 }
 
 const ResourceProvider::Resource* ResourceProvider::lockForRead(ResourceId id)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     DCHECK(!resource->lockedForWrite);
     DCHECK(!resource->exported);
     DCHECK(resource->allocated); // Uninitialized! Call setPixels or lockForWrite first.
 
     if (!resource->glId && resource->external && !resource->mailbox.IsEmpty()) {
-        WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+        WebGraphicsContext3D* context3d = m_outputSurface->context3d();
         DCHECK(context3d);
         if (resource->mailbox.sync_point()) {
             GLC(context3d, context3d->waitSyncPoint(resource->mailbox.sync_point()));
             resource->mailbox.ResetSyncPoint();
         }
         resource->glId = context3d->createTexture();
         GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->glId));
         GLC(context3d, context3d->consumeTextureCHROMIUM(GL_TEXTURE_2D, resource->mailbox.data()));
     }
 
@@ skipping 131 matching lines @@
     , m_useTextureUsageHint(false)
     , m_useShallowFlush(false)
     , m_maxTextureSize(0)
     , m_bestTextureFormat(0)
 {
 }
 
 bool ResourceProvider::initialize()
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
-    WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+    WebGraphicsContext3D* context3d = m_outputSurface->context3d();
     if (!context3d) {
         m_maxTextureSize = INT_MAX / 2;
         m_bestTextureFormat = GL_RGBA;
         return true;
     }
     if (!context3d->makeContextCurrent())
         return false;
 
     std::string extensionsString = UTF16ToASCII(context3d->getString(GL_EXTENSIONS));
     std::vector<std::string> extensions;
@@ skipping 50 matching lines @@
     ChildMap::const_iterator it = m_children.find(child);
     DCHECK(it != m_children.end());
     return it->second.childToParentMap;
 }
 
 void ResourceProvider::prepareSendToParent(const ResourceIdArray& resources, TransferableResourceList* list)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     list->sync_point = 0;
     list->resources.clear();
-    WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+    WebGraphicsContext3D* context3d = m_outputSurface->context3d();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
         return;
     }
     for (ResourceIdArray::const_iterator it = resources.begin(); it != resources.end(); ++it) {
         TransferableResource resource;
         if (transferResource(context3d, *it, &resource)) {
             m_resources.find(*it)->second.exported = true;
             list->resources.push_back(resource);
         }
     }
     if (list->resources.size())
         list->sync_point = context3d->insertSyncPoint();
 }
 
 void ResourceProvider::prepareSendToChild(int child, const ResourceIdArray& resources, TransferableResourceList* list)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     list->sync_point = 0;
     list->resources.clear();
-    WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+    WebGraphicsContext3D* context3d = m_outputSurface->context3d();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
         return;
     }
     Child& childInfo = m_children.find(child)->second;
     for (ResourceIdArray::const_iterator it = resources.begin(); it != resources.end(); ++it) {
         TransferableResource resource;
         if (!transferResource(context3d, *it, &resource))
             NOTREACHED();
         DCHECK(childInfo.parentToChildMap.find(*it) != childInfo.parentToChildMap.end());
         resource.id = childInfo.parentToChildMap[*it];
         childInfo.parentToChildMap.erase(*it);
         childInfo.childToParentMap.erase(resource.id);
         list->resources.push_back(resource);
         deleteResource(*it);
     }
     if (list->resources.size())
         list->sync_point = context3d->insertSyncPoint();
 }
 
 void ResourceProvider::receiveFromChild(int child, const TransferableResourceList& resources)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
-    WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+    WebGraphicsContext3D* context3d = m_outputSurface->context3d();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
         return;
     }
     if (resources.sync_point) {
         // NOTE: If the parent is a browser and the child a renderer, the parent
         // is not supposed to have its context wait, because that could induce
         // deadlocks and/or security issues. The caller is responsible for
         // waiting asynchronously, and resetting sync_point before calling this.
         // However if the parent is a renderer (e.g. browser tag), it may be ok
@@ skipping 13 matching lines @@
         resource.allocated = true;
         m_resources[id] = resource;
         childInfo.parentToChildMap[id] = it->id;
         childInfo.childToParentMap[it->id] = id;
     }
 }
 
 void ResourceProvider::receiveFromParent(const TransferableResourceList& resources)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
-    WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+    WebGraphicsContext3D* context3d = m_outputSurface->context3d();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
         return;
     }
     if (resources.sync_point)
         GLC(context3d, context3d->waitSyncPoint(resources.sync_point));
     for (TransferableResourceArray::const_iterator it = resources.resources.begin(); it != resources.resources.end(); ++it) {
         ResourceMap::iterator mapIterator = m_resources.find(it->id);
         DCHECK(mapIterator != m_resources.end());
         Resource* resource = &mapIterator->second;
         DCHECK(resource->exported);
         resource->exported = false;
         DCHECK(resource->mailbox.Equals(it->mailbox));
         GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->glId));
         GLC(context3d, context3d->consumeTextureCHROMIUM(GL_TEXTURE_2D, it->mailbox.name));
         if (resource->markedForDeletion)
             deleteResourceInternal(mapIterator);
     }
 }
 
 bool ResourceProvider::transferResource(WebGraphicsContext3D* context, ResourceId id, TransferableResource* resource)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
-    WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+    WebGraphicsContext3D* context3d = m_outputSurface->context3d();
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* source = &it->second;
     DCHECK(!source->lockedForWrite);
     DCHECK(!source->lockForReadCount);
     DCHECK(!source->external || (source->external && !source->mailbox.IsEmpty()));
     DCHECK(source->allocated);
     if (source->exported)
         return false;
     resource->id = id;
@@ skipping 15 matching lines @@
 void ResourceProvider::acquirePixelBuffer(ResourceId id)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     DCHECK(!resource->external);
     DCHECK(!resource->exported);
 
     if (resource->glId) {
-        WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+        WebGraphicsContext3D* context3d = m_outputSurface->context3d();
         DCHECK(context3d);
         if (!resource->glPixelBufferId)
             resource->glPixelBufferId = context3d->createBuffer();
         context3d->bindBuffer(
             GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
             resource->glPixelBufferId);
         context3d->bufferData(
             GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
             resource->size.width() * resource->size.height() * 4,
             NULL,
@@ skipping 14 matching lines @@
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     DCHECK(!resource->external);
     DCHECK(!resource->exported);
 
     if (resource->glId) {
         DCHECK(resource->glPixelBufferId);
-        WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+        WebGraphicsContext3D* context3d = m_outputSurface->context3d();
         DCHECK(context3d);
         context3d->bindBuffer(
             GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
             resource->glPixelBufferId);
         context3d->bufferData(
             GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
             0,
             NULL,
             GL_DYNAMIC_DRAW);
         context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
@@ skipping 10 matching lines @@
 uint8_t* ResourceProvider::mapPixelBuffer(ResourceId id)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     DCHECK(!resource->external);
     DCHECK(!resource->exported);
 
     if (resource->glId) {
-        WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+        WebGraphicsContext3D* context3d = m_outputSurface->context3d();
         DCHECK(context3d);
         DCHECK(resource->glPixelBufferId);
         context3d->bindBuffer(
             GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
             resource->glPixelBufferId);
         uint8_t* image = static_cast<uint8_t*>(
             context3d->mapBufferCHROMIUM(
                 GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, GL_WRITE_ONLY));
         context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
         DCHECK(image);
         return image;
     }
 
     if (resource->pixels)
       return resource->pixelBuffer;
 
     return NULL;
 }
 
 void ResourceProvider::unmapPixelBuffer(ResourceId id)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     DCHECK(!resource->external);
     DCHECK(!resource->exported);
 
     if (resource->glId) {
-        WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+        WebGraphicsContext3D* context3d = m_outputSurface->context3d();
         DCHECK(context3d);
         DCHECK(resource->glPixelBufferId);
         context3d->bindBuffer(
             GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
             resource->glPixelBufferId);
         context3d->unmapBufferCHROMIUM(
             GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM);
         context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
     }
 }
 
 void ResourceProvider::setPixelsFromBuffer(ResourceId id)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     DCHECK(!resource->lockedForWrite);
     DCHECK(!resource->lockForReadCount);
     DCHECK(!resource->external);
     DCHECK(!resource->exported);
     DCHECK(readLockFenceHasPassed(resource));
     lazyAllocate(resource);
 
     if (resource->glId) {
-        WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+        WebGraphicsContext3D* context3d = m_outputSurface->context3d();
         DCHECK(context3d);
         DCHECK(resource->glPixelBufferId);
         context3d->bindTexture(GL_TEXTURE_2D, resource->glId);
         context3d->bindBuffer(
             GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
             resource->glPixelBufferId);
         context3d->texSubImage2D(GL_TEXTURE_2D,
                                  0, /* level */
                                  0, /* x */
                                  0, /* y */
@@ skipping 16 matching lines @@
 
         ScopedWriteLockSoftware lock(this, id);
         SkCanvas* dest = lock.skCanvas();
         dest->writePixels(src, 0, 0);
     }
 }
 
 void ResourceProvider::bindForSampling(ResourceProvider::ResourceId resourceId, GLenum target, GLenum filter)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
-    WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+    WebGraphicsContext3D* context3d = m_outputSurface->context3d();
     ResourceMap::iterator it = m_resources.find(resourceId);
     DCHECK(it != m_resources.end());
     Resource* resource = &it->second;
     DCHECK(resource->lockForReadCount);
     DCHECK(!resource->lockedForWrite);
 
     GLC(context3d, context3d->bindTexture(target, resource->glId));
     if (filter != resource->filter) {
         GLC(context3d, context3d->texParameteri(target, GL_TEXTURE_MIN_FILTER, filter));
         GLC(context3d, context3d->texParameteri(target, GL_TEXTURE_MAG_FILTER, filter));
         resource->filter = filter;
     }
 }
 
 void ResourceProvider::beginSetPixels(ResourceId id)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     DCHECK(!resource->pendingSetPixels);
     DCHECK(resource->glId || resource->allocated);
     DCHECK(readLockFenceHasPassed(resource));
 
     bool allocate = !resource->allocated;
     resource->allocated = true;
     lockForWrite(id);
 
     if (resource->glId) {
-        WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+        WebGraphicsContext3D* context3d = m_outputSurface->context3d();
         DCHECK(context3d);
         DCHECK(resource->glPixelBufferId);
         context3d->bindTexture(GL_TEXTURE_2D, resource->glId);
         context3d->bindBuffer(
             GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
             resource->glPixelBufferId);
         if (!resource->glUploadQueryId)
             resource->glUploadQueryId = context3d->createQueryEXT();
         context3d->beginQueryEXT(
             GL_ASYNC_PIXEL_TRANSFERS_COMPLETED_CHROMIUM,
@@ skipping 31 matching lines @@
 
 bool ResourceProvider::didSetPixelsComplete(ResourceId id) {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     DCHECK(resource->lockedForWrite);
     DCHECK(resource->pendingSetPixels);
 
     if (resource->glId) {
-        WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+        WebGraphicsContext3D* context3d = m_outputSurface->context3d();
         DCHECK(context3d);
         DCHECK(resource->glUploadQueryId);
         unsigned complete = 1;
         context3d->getQueryObjectuivEXT(
             resource->glUploadQueryId,
             GL_QUERY_RESULT_AVAILABLE_EXT,
             &complete);
         if (!complete)
             return false;
     }
 
     resource->pendingSetPixels = false;
     unlockForWrite(id);
 
     return true;
 }
 
 void ResourceProvider::abortSetPixels(ResourceId id) {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     DCHECK(resource->lockedForWrite);
     DCHECK(resource->pendingSetPixels);
 
     if (resource->glId) {
-        WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+        WebGraphicsContext3D* context3d = m_outputSurface->context3d();
         DCHECK(context3d);
         DCHECK(resource->glUploadQueryId);
         // CHROMIUM_async_pixel_transfers currently doesn't have a way to
         // abort an upload. The best we can do is delete the query and
         // the texture.
         context3d->deleteQueryEXT(resource->glUploadQueryId);
         resource->glUploadQueryId = 0;
         context3d->deleteTexture(resource->glId);
         resource->glId = createTextureId(context3d);
         resource->allocated = false;
@@ skipping 10 matching lines @@
     lazyAllocate(resource);
 }
 
 void ResourceProvider::lazyAllocate(Resource* resource) {
     DCHECK(resource);
     DCHECK(resource->glId || resource->allocated);
 
     if (resource->allocated || !resource->glId)
         return;
     resource->allocated = true;
-    WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
+    WebGraphicsContext3D* context3d = m_outputSurface->context3d();
     gfx::Size& size = resource->size;
     GLenum format = resource->format;
     GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->glId));
     if (m_useTextureStorageExt && isTextureFormatSupportedForStorage(format)) {
         GLenum storageFormat = textureToStorageFormat(format);
         GLC(context3d, context3d->texStorage2DEXT(GL_TEXTURE_2D, 1, storageFormat, size.width(), size.height()));
     } else
         GLC(context3d, context3d->texImage2D(GL_TEXTURE_2D, 0, format, size.width(), size.height(), 0, format, GL_UNSIGNED_BYTE, 0));
 }
 
 void ResourceProvider::enableReadLockFences(ResourceProvider::ResourceId id, bool enable) {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     resource->enableReadLockFences = enable;
 }
 
 }  // namespace cc