cc: return resources via a ReturnedResource struct rather than TransferableResource

cc/resources/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/resources/resource_provider.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
@@ skipping 170 matching lines @@
 
   CleanUpGLIfNeeded();
 }
 
 WebGraphicsContext3D* ResourceProvider::GraphicsContext3D() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return output_surface_->context3d();
 }
 
 bool ResourceProvider::InUseByConsumer(ResourceId id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
+  Resource* resource = GetResource(id);
   return resource->lock_for_read_count > 0 || resource->exported_count > 0;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateResource(
     gfx::Size size, GLenum format, TextureUsageHint hint) {
   DCHECK(!size.IsEmpty());
   switch (default_resource_type_) {
     case GLTexture:
       return CreateGLTexture(
           size, format, GL_TEXTURE_POOL_UNMANAGED_CHROMIUM, hint);
@@ skipping 170 matching lines @@
   if (resource->pixels)
     delete[] resource->pixels;
   if (resource->pixel_buffer)
     delete[] resource->pixel_buffer;
 
   resources_.erase(it);
 }
 
 ResourceProvider::ResourceType ResourceProvider::GetResourceType(
     ResourceId id) {
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
-  return resource->type;
+  return GetResource(id)->type;
 }
 
 void ResourceProvider::SetPixels(ResourceId id,
                                  const uint8_t* image,
                                  gfx::Rect image_rect,
                                  gfx::Rect source_rect,
                                  gfx::Vector2d dest_offset) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
+  Resource* resource = GetResource(id);
   DCHECK(!resource->locked_for_write);
   DCHECK(!resource->lock_for_read_count);
   DCHECK(!resource->external);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(ReadLockFenceHasPassed(resource));
   LazyAllocate(resource);
 
   if (resource->gl_id) {
     DCHECK(!resource->pending_set_pixels);
     WebGraphicsContext3D* context3d = output_surface_->context3d();
@@ skipping 81 matching lines @@
 bool ResourceProvider::ShallowFlushIfSupported() {
   DCHECK(thread_checker_.CalledOnValidThread());
   WebGraphicsContext3D* context3d = output_surface_->context3d();
   if (!context3d || !use_shallow_flush_)
     return false;
 
   context3d->shallowFlushCHROMIUM();
   return true;
 }
 
-const ResourceProvider::Resource* ResourceProvider::LockForRead(ResourceId id) {
+ResourceProvider::Resource* ResourceProvider::GetResource(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
-  Resource* resource = &it->second;
+  return &it->second;
+}
+
+const ResourceProvider::Resource* ResourceProvider::LockForRead(ResourceId id) {
+  Resource* resource = GetResource(id);
   DCHECK(!resource->locked_for_write ||
          resource->set_pixels_completion_forced) <<
       "locked for write: " << resource->locked_for_write <<
       " pixels completion forced: " << resource->set_pixels_completion_forced;
   DCHECK_EQ(resource->exported_count, 0);
   // Uninitialized! Call SetPixels or LockForWrite first.
   DCHECK(resource->allocated);
 
   LazyCreate(resource);
 
@@ skipping 15 matching lines @@
   }
 
   resource->lock_for_read_count++;
   if (resource->enable_read_lock_fences)
     resource->read_lock_fence = current_read_lock_fence_;
 
   return resource;
 }
 
 void ResourceProvider::UnlockForRead(ResourceId id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
+  Resource* resource = GetResource(id);
   DCHECK_GT(resource->lock_for_read_count, 0);
   DCHECK_EQ(resource->exported_count, 0);
   resource->lock_for_read_count--;
 }
 
 const ResourceProvider::Resource* ResourceProvider::LockForWrite(
     ResourceId id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
+  Resource* resource = GetResource(id);
   DCHECK(!resource->locked_for_write);
   DCHECK(!resource->lock_for_read_count);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(!resource->external);
   DCHECK(ReadLockFenceHasPassed(resource));
   LazyAllocate(resource);
 
   resource->locked_for_write = true;
   return resource;
 }
 
 bool ResourceProvider::CanLockForWrite(ResourceId id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
+  Resource* resource = GetResource(id);
   return !resource->locked_for_write &&
       !resource->lock_for_read_count &&
       !resource->exported_count &&
       !resource->external &&
       ReadLockFenceHasPassed(resource);
 }
 
 void ResourceProvider::UnlockForWrite(ResourceId id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
+  Resource* resource = GetResource(id);
   DCHECK(resource->locked_for_write);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(!resource->external);
   resource->locked_for_write = false;
 }
 
 ResourceProvider::ScopedReadLockGL::ScopedReadLockGL(
     ResourceProvider* resource_provider,
     ResourceProvider::ResourceId resource_id)
     : resource_provider_(resource_provider),
@@ skipping 222 matching lines @@
     unsigned int sync_point = context3d->insertSyncPoint();
     for (TransferableResourceArray::iterator it = list->begin();
          it != list->end();
          ++it) {
       if (!it->sync_point)
         it->sync_point = sync_point;
     }
   }
 }
 
 void ResourceProvider::PrepareSendToChild(int child,

[danakj, 2013/08/16 23:33:35]

Maybe we could rename this to PrepareSendReturnsToChild and
ReceiveReturnsFromParent or something like that in the future. I always had to
stop and think about these method names in the past.

[piman, 2013/08/17 01:54:31]

Done.

                                           const ResourceIdArray& resources,
-                                          TransferableResourceArray* list) {
+                                          ReturnedResourceArray* list) {
   DCHECK(thread_checker_.CalledOnValidThread());
   WebGraphicsContext3D* context3d = output_surface_->context3d();
   if (!context3d || !context3d->makeContextCurrent()) {
     // TODO(skaslev): Implement this path for software compositing.
     return;
   }
   Child& child_info = children_.find(child)->second;
   bool need_sync_point = false;
   for (ResourceIdArray::const_iterator it = resources.begin();
-       it != resources.end();
-       ++it) {
-    TransferableResource resource;
-    TransferResource(context3d, *it, &resource);
-    if (!resource.sync_point)
-      need_sync_point = true;
+       it != resources.end(); ++it) {
+    Resource* resource = GetResource(*it);
+    DCHECK(!resource->locked_for_write);
+    DCHECK(!resource->lock_for_read_count);
     DCHECK(child_info.parent_to_child_map.find(*it) !=
            child_info.parent_to_child_map.end());
-    resource.id = child_info.parent_to_child_map[*it];
+
+    ReturnedResource returned;
+    returned.id = child_info.parent_to_child_map[*it];
+    returned.filter = resource->filter;
+    returned.sync_point = resource->mailbox.sync_point();
+    if (!returned.sync_point)
+      need_sync_point = true;
+    returned.count = resource->imported_count;
+    list->push_back(returned);
+
     child_info.parent_to_child_map.erase(*it);
-    child_info.child_to_parent_map.erase(resource.id);
-    for (int i = 0; i < resources_[*it].imported_count; ++i)
-      list->push_back(resource);
+    child_info.child_to_parent_map.erase(returned.id);
     resources_[*it].imported_count = 0;
     DeleteResource(*it);
   }
   if (need_sync_point) {
     unsigned int sync_point = context3d->insertSyncPoint();
-    for (TransferableResourceArray::iterator it = list->begin();
-         it != list->end();
-         ++it) {
+    for (ReturnedResourceArray::iterator it = list->begin();
+         it != list->end(); ++it) {
       if (!it->sync_point)
         it->sync_point = sync_point;
     }
   }
 }
 
 void ResourceProvider::ReceiveFromChild(
     int child, const TransferableResourceArray& resources) {
   DCHECK(thread_checker_.CalledOnValidThread());
   WebGraphicsContext3D* context3d = output_surface_->context3d();
@@ skipping 31 matching lines @@
     // Don't allocate a texture for a child.
     resource.allocated = true;
     resource.imported_count = 1;
     resources_[id] = resource;
     child_info.parent_to_child_map[id] = it->id;
     child_info.child_to_parent_map[it->id] = id;
   }
 }
 
 void ResourceProvider::ReceiveFromParent(
-    const TransferableResourceArray& resources) {
+    const ReturnedResourceArray& resources) {
   DCHECK(thread_checker_.CalledOnValidThread());
   WebGraphicsContext3D* context3d = output_surface_->context3d();
   if (!context3d || !context3d->makeContextCurrent()) {
     // TODO(skaslev): Implement this path for software compositing.
     return;
   }
-  for (TransferableResourceArray::const_iterator it = resources.begin();
+  for (ReturnedResourceArray::const_iterator it = resources.begin();
        it != resources.end();
        ++it) {
     ResourceMap::iterator map_iterator = resources_.find(it->id);
     DCHECK(map_iterator != resources_.end());
     Resource* resource = &map_iterator->second;
-    DCHECK_GT(resource->exported_count, 0);
-    --resource->exported_count;
+    CHECK_GE(resource->exported_count, it->count);
+    resource->exported_count -= it->count;
     if (resource->exported_count)
       continue;
     resource->filter = it->filter;
-    DCHECK(resource->mailbox.ContainsMailbox(it->mailbox));
     if (resource->gl_id) {
       if (it->sync_point)
         GLC(context3d, context3d->waitSyncPoint(it->sync_point));
     } else {
       resource->mailbox = TextureMailbox(resource->mailbox.name(),
                                          resource->mailbox.callback(),
                                          it->sync_point);
     }
     if (resource->marked_for_deletion)
       DeleteResourceInternal(map_iterator, Normal);
   }
 }
 
 void ResourceProvider::TransferResource(WebGraphicsContext3D* context,
                                         ResourceId id,
                                         TransferableResource* resource) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* source = &it->second;
+  Resource* source = GetResource(id);
   DCHECK(!source->locked_for_write);
   DCHECK(!source->lock_for_read_count);
   DCHECK(!source->external || (source->external && source->mailbox.IsValid()));
   DCHECK(source->allocated);
   resource->id = id;
   resource->format = source->format;
   resource->filter = source->filter;
   resource->size = source->size;
 
   // TODO(skaslev) Implement this path for shared memory resources.
@@ skipping 11 matching lines @@
   } else {
     // This is either an external resource, or a compositor resource that we
     // already exported. Make sure to forward the sync point that we were given.
     resource->mailbox = source->mailbox.name();
     resource->sync_point = source->mailbox.sync_point();
     source->mailbox.ResetSyncPoint();
   }
 }
 
 void ResourceProvider::AcquirePixelBuffer(ResourceId id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
+  Resource* resource = GetResource(id);
   DCHECK(!resource->external);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(!resource->image_id);
 
   if (resource->type == GLTexture) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
     if (!resource->gl_pixel_buffer_id)
       resource->gl_pixel_buffer_id = context3d->createBuffer();
     context3d->bindBuffer(
         GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
         resource->gl_pixel_buffer_id);
     context3d->bufferData(
         GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
         4 * resource->size.GetArea(),
         NULL,
         GL_DYNAMIC_DRAW);
     context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
   }
 
   if (resource->pixels) {
     if (resource->pixel_buffer)
       return;
 
     resource->pixel_buffer = new uint8_t[4 * resource->size.GetArea()];
   }
 }
 
 void ResourceProvider::ReleasePixelBuffer(ResourceId id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
+  Resource* resource = GetResource(id);
   DCHECK(!resource->external);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(!resource->image_id);
 
   // The pixel buffer can be released while there is a pending "set pixels"
   // if completion has been forced. Any shared memory associated with this
   // pixel buffer will not be freed until the waitAsyncTexImage2DCHROMIUM
   // command has been processed on the service side. It is also safe to
   // reuse any query id associated with this resource before they complete
   // as each new query has a unique submit count.
@@ skipping 21 matching lines @@
 
   if (resource->pixels) {
     if (!resource->pixel_buffer)
       return;
     delete[] resource->pixel_buffer;
     resource->pixel_buffer = NULL;
   }
 }
 
 uint8_t* ResourceProvider::MapPixelBuffer(ResourceId id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
+  Resource* resource = GetResource(id);
   DCHECK(!resource->external);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(!resource->image_id);
 
   if (resource->type == GLTexture) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
     DCHECK(resource->gl_pixel_buffer_id);
     context3d->bindBuffer(
         GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
         resource->gl_pixel_buffer_id);
     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);
     // Buffer is required to be 4-byte aligned.
     CHECK(!(reinterpret_cast<intptr_t>(image) & 3));
     return image;
   }
 
   if (resource->pixels)
     return resource->pixel_buffer;
 
   return NULL;
 }
 
 void ResourceProvider::UnmapPixelBuffer(ResourceId id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
+  Resource* resource = GetResource(id);
   DCHECK(!resource->external);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(!resource->image_id);
 
   if (resource->type == GLTexture) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
     DCHECK(resource->gl_pixel_buffer_id);
     context3d->bindBuffer(
         GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
@@ skipping 51 matching lines @@
   DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(context3d));
   if (unit != GL_TEXTURE0)
     GLC(context3d, context3d->activeTexture(unit));
   context3d->releaseTexImage2DCHROMIUM(target, resource->image_id);
   // Active unit being GL_TEXTURE0 is effectively the ground state.
   if (unit != GL_TEXTURE0)
     GLC(context3d, context3d->activeTexture(GL_TEXTURE0));
 }
 
 void ResourceProvider::BeginSetPixels(ResourceId id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
+  Resource* resource = GetResource(id);
   DCHECK(!resource->pending_set_pixels);
 
   LazyCreate(resource);
   DCHECK(resource->gl_id || resource->allocated);
   DCHECK(ReadLockFenceHasPassed(resource));
   DCHECK(!resource->image_id);
 
   bool allocate = !resource->allocated;
   resource->allocated = true;
   LockForWrite(id);
@@ skipping 44 matching lines @@
     std::swap(resource->pixels, resource->pixel_buffer);
     delete[] resource->pixel_buffer;
     resource->pixel_buffer = NULL;
   }
 
   resource->pending_set_pixels = true;
   resource->set_pixels_completion_forced = false;
 }
 
 void ResourceProvider::ForceSetPixelsToComplete(ResourceId id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
+  Resource* resource = GetResource(id);
   DCHECK(resource->locked_for_write);
   DCHECK(resource->pending_set_pixels);
   DCHECK(!resource->set_pixels_completion_forced);
 
   if (resource->gl_id) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->gl_id));
     GLC(context3d, context3d->waitAsyncTexImage2DCHROMIUM(GL_TEXTURE_2D));
     GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, 0));
   }
 
   resource->set_pixels_completion_forced = true;
 }
 
 bool ResourceProvider::DidSetPixelsComplete(ResourceId id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
+  Resource* resource = GetResource(id);
   DCHECK(resource->locked_for_write);
   DCHECK(resource->pending_set_pixels);
 
   if (resource->gl_id) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
     DCHECK(resource->gl_upload_query_id);
     unsigned complete = 1;
     context3d->getQueryObjectuivEXT(
         resource->gl_upload_query_id,
         GL_QUERY_RESULT_AVAILABLE_EXT,
         &complete);
     if (!complete)
       return false;
   }
 
   resource->pending_set_pixels = false;
   UnlockForWrite(id);
 
   return true;
 }
 
 void ResourceProvider::CreateForTesting(ResourceId id) {
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
-  LazyCreate(resource);
+  LazyCreate(GetResource(id));
 }
 
 void ResourceProvider::LazyCreate(Resource* resource) {
   if (resource->type != GLTexture || resource->gl_id != 0)
     return;
 
   // Early out for resources that don't require texture creation.
   if (resource->texture_pool == 0)
     return;
 
   WebGraphicsContext3D* context3d = output_surface_->context3d();
   DCHECK(context3d);
   // Create and set texture properties. Allocation is delayed until needed.
   resource->gl_id = CreateTextureId(context3d);
   GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D,
                                           GL_TEXTURE_POOL_CHROMIUM,
                                           resource->texture_pool));
   if (use_texture_usage_hint_ && resource->hint == TextureUsageFramebuffer) {
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D,
                                             GL_TEXTURE_USAGE_ANGLE,
                                             GL_FRAMEBUFFER_ATTACHMENT_ANGLE));
   }
 }
 
 void ResourceProvider::AllocateForTesting(ResourceId id) {
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
-  LazyAllocate(resource);
+  LazyAllocate(GetResource(id));
 }
 
 void ResourceProvider::LazyAllocate(Resource* resource) {
   DCHECK(resource);
   LazyCreate(resource);
 
   DCHECK(resource->gl_id || resource->allocated);
   if (resource->allocated || !resource->gl_id)
     return;
   resource->allocated = true;
@@ skipping 16 matching lines @@
                                          size.height(),
                                          0,
                                          format,
                                          GL_UNSIGNED_BYTE,
                                          NULL));
   }
 }
 
 void ResourceProvider::EnableReadLockFences(ResourceProvider::ResourceId id,
                                             bool enable) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
+  Resource* resource = GetResource(id);
   resource->enable_read_lock_fences = enable;
 }
 
 void ResourceProvider::AcquireImage(ResourceId id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
-
+  Resource* resource = GetResource(id);
   DCHECK(!resource->external);
   DCHECK_EQ(resource->exported_count, 0);
 
   if (resource->type != GLTexture)
     return;
 
   if (resource->image_id)
     return;
 
   resource->allocated = true;
   WebGraphicsContext3D* context3d = output_surface_->context3d();
   DCHECK(context3d);
   resource->image_id = context3d->createImageCHROMIUM(
       resource->size.width(), resource->size.height(), GL_RGBA8_OES);
   DCHECK(resource->image_id);
 }
 
 void ResourceProvider::ReleaseImage(ResourceId id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
-
+  Resource* resource = GetResource(id);
   DCHECK(!resource->external);
   DCHECK_EQ(resource->exported_count, 0);
 
   if (!resource->image_id)
     return;
 
   WebGraphicsContext3D* context3d = output_surface_->context3d();
   DCHECK(context3d);
   context3d->destroyImageCHROMIUM(resource->image_id);
   resource->image_id = 0;
   resource->allocated = false;
 }
 
 uint8_t* ResourceProvider::MapImage(ResourceId id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
-
+  Resource* resource = GetResource(id);
   DCHECK(ReadLockFenceHasPassed(resource));
   DCHECK(!resource->external);
   DCHECK_EQ(resource->exported_count, 0);
 
   if (resource->image_id) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
     return static_cast<uint8_t*>(
         context3d->mapImageCHROMIUM(resource->image_id, GL_READ_WRITE));
   }
 
   if (resource->pixels)
     return resource->pixels;
 
   return NULL;
 }
 
 void ResourceProvider::UnmapImage(ResourceId id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
-
+  Resource* resource = GetResource(id);
   DCHECK(!resource->external);
   DCHECK_EQ(resource->exported_count, 0);
 
   if (resource->image_id) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
     context3d->unmapImageCHROMIUM(resource->image_id);
   }
 }
 
 int ResourceProvider::GetImageStride(ResourceId id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  ResourceMap::iterator it = resources_.find(id);
-  CHECK(it != resources_.end());
-  Resource* resource = &it->second;
-
+  Resource* resource = GetResource(id);
   DCHECK(!resource->external);
   DCHECK_EQ(resource->exported_count, 0);
 
   int stride = 0;
 
   if (resource->image_id) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
     context3d->getImageParameterivCHROMIUM(
         resource->image_id, GL_IMAGE_ROWBYTES_CHROMIUM, &stride);
   }
 
   return stride;
 }
 
 GLint ResourceProvider::GetActiveTextureUnit(WebGraphicsContext3D* context) {
   GLint active_unit = 0;
   context->getIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
   return active_unit;
 }
 
 }  // namespace cc