Lines Matching refs:resource
108 DCHECK(false) << "Unsupported resource format.";
218 ResourceProvider::Resource::Resource()
253 ResourceProvider::Resource::~Resource() {}
255 ResourceProvider::Resource::Resource(GLuint texture_id,
301 ResourceProvider::Resource::Resource(uint8_t* pixels,
346 ResourceProvider::Resource::Resource(const SharedBitmapId& bitmap_id,
389 const Resource* resource,
391 : resource_(resource),
424 const Resource* resource,
427 : RasterBuffer(resource, resource_provider),
449 switch (resource()->type) {
451 DCHECK(resource()->gl_id);
456 desc.fWidth = resource()->size.width();
457 desc.fHeight = resource()->size.height();
458 desc.fConfig = ToGrPixelConfig(resource()->format);
460 desc.fTextureHandle = resource()->gl_id;
472 DCHECK(resource()->pixels);
473 DCHECK_EQ(RGBA_8888, resource()->format);
475 resource()->size.width(), resource()->size.height());
477 image_info, resource()->pixels, image_info.minRowBytes()));
487 const Resource* resource,
489 : RasterBuffer(resource, resource_provider),
504 switch (resource()->format) {
508 raster_bitmap_.allocN32Pixels(resource()->size.width(),
509 resource()->size.height());
513 SkImageInfo info = SkImageInfo::MakeN32Premul(resource()->size.width(),
514 resource()->size.height());
542 resource()->format);
554 const Resource* resource,
556 : BitmapRasterBuffer(resource, resource_provider) {}
561 return resource_provider()->MapImage(resource(), stride);
565 resource_provider()->UnmapImage(resource());
569 const Resource* resource,
571 : BitmapRasterBuffer(resource, resource_provider) {}
576 return resource_provider()->MapPixelBuffer(resource(), stride);
580 resource_provider()->UnmapPixelBuffer(resource());
621 Resource* resource = GetResource(id);
622 return resource->lock_for_read_count > 0 || resource->exported_count > 0 ||
623 resource->lost;
627 Resource* resource = GetResource(id);
628 return resource->lost;
632 Resource* resource = GetResource(id);
633 return resource->allow_overlay;
657 LOG(FATAL) << "Invalid default resource type.";
683 LOG(FATAL) << "Invalid default resource type.";
699 Resource resource(0,
701 Resource::Internal,
708 resource.allocated = false;
709 resources_[id] = resource;
731 Resource resource(
732 pixels, bitmap.release(), size, Resource::Internal, GL_LINEAR, wrap_mode);
733 resource.allocated = true;
734 resources_[id] = resource;
744 Resource resource(0,
746 Resource::Internal,
753 LazyCreate(&resource);
756 gl->BindTexture(GL_TEXTURE_RECTANGLE_ARB, resource.gl_id);
759 resource.allocated = true;
760 resources_[id] = resource;
771 Resource& resource = resources_[id];
773 resource = Resource(0,
775 Resource::External,
793 resource = Resource(pixels,
796 Resource::External,
800 resource.allocated = true;
801 resource.mailbox = mailbox;
802 resource.release_callback =
805 resource.allow_overlay = mailbox.allow_overlay();
813 Resource* resource = &it->second;
814 DCHECK(!resource->marked_for_deletion);
815 DCHECK_EQ(resource->imported_count, 0);
816 DCHECK(resource->pending_set_pixels || !resource->locked_for_write);
818 if (resource->exported_count > 0 || resource->lock_for_read_count > 0) {
819 resource->marked_for_deletion = true;
829 Resource* resource = &it->second;
830 bool lost_resource = resource->lost;
832 DCHECK(resource->exported_count == 0 || style != Normal);
833 if (style == ForShutdown && resource->exported_count > 0)
836 resource->direct_raster_buffer.reset();
837 resource->image_raster_buffer.reset();
838 resource->pixel_raster_buffer.reset();
840 if (resource->image_id) {
841 DCHECK(resource->origin == Resource::Internal);
844 GLC(gl, gl->DestroyImageCHROMIUM(resource->image_id));
846 if (resource->gl_upload_query_id) {
847 DCHECK(resource->origin == Resource::Internal);
850 GLC(gl, gl->DeleteQueriesEXT(1, &resource->gl_upload_query_id));
852 if (resource->gl_read_lock_query_id) {
853 DCHECK(resource->origin == Resource::Internal);
856 GLC(gl, gl->DeleteQueriesEXT(1, &resource->gl_read_lock_query_id));
858 if (resource->gl_pixel_buffer_id) {
859 DCHECK(resource->origin == Resource::Internal);
862 GLC(gl, gl->DeleteBuffers(1, &resource->gl_pixel_buffer_id));
864 if (resource->origin == Resource::External) {
865 DCHECK(resource->mailbox.IsValid());
866 GLuint sync_point = resource->mailbox.sync_point();
867 if (resource->type == GLTexture) {
868 DCHECK(resource->mailbox.IsTexture());
872 if (resource->gl_id) {
873 GLC(gl, gl->DeleteTextures(1, &resource->gl_id));
874 resource->gl_id = 0;
879 DCHECK(resource->mailbox.IsSharedMemory());
880 base::SharedMemory* shared_memory = resource->mailbox.shared_memory();
881 if (resource->pixels && shared_memory) {
882 DCHECK(shared_memory->memory() == resource->pixels);
883 resource->pixels = NULL;
884 delete resource->shared_bitmap;
885 resource->shared_bitmap = NULL;
888 resource->release_callback.Run(sync_point, lost_resource);
890 if (resource->gl_id) {
893 GLC(gl, gl->DeleteTextures(1, &resource->gl_id));
894 resource->gl_id = 0;
896 if (resource->shared_bitmap) {
897 DCHECK(resource->origin != Resource::External);
898 DCHECK_EQ(Bitmap, resource->type);
899 delete resource->shared_bitmap;
900 resource->pixels = NULL;
902 if (resource->pixels) {
903 DCHECK(resource->origin == Resource::Internal);
904 delete[] resource->pixels;
919 Resource* resource = GetResource(id);
920 DCHECK(!resource->locked_for_write);
921 DCHECK(!resource->lock_for_read_count);
922 DCHECK(resource->origin == Resource::Internal);
923 DCHECK_EQ(resource->exported_count, 0);
924 DCHECK(ReadLockFenceHasPassed(resource));
925 LazyAllocate(resource);
927 if (resource->type == GLTexture) {
928 DCHECK(resource->gl_id);
929 DCHECK(!resource->pending_set_pixels);
930 DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D));
934 gl->BindTexture(GL_TEXTURE_2D, resource->gl_id);
939 resource->format,
940 resource->size);
942 DCHECK_EQ(Bitmap, resource->type);
943 DCHECK(resource->allocated);
944 DCHECK_EQ(RGBA_8888, resource->format);
1005 // Software resource uploads happen on impl thread, so don't bother batching
1045 ResourceProvider::Resource* ResourceProvider::GetResource(ResourceId id) {
1052 Resource* ResourceProvider::LockForRead(ResourceId id) {
1053 Resource* resource = GetResource(id);
1054 DCHECK(!resource->locked_for_write ||
1055 resource->set_pixels_completion_forced) <<
1056 "locked for write: " << resource->locked_for_write <<
1057 " pixels completion forced: " << resource->set_pixels_completion_forced;
1058 DCHECK_EQ(resource->exported_count, 0);
1060 DCHECK(resource->allocated);
1062 LazyCreate(resource);
1064 if (resource->type == GLTexture && !resource->gl_id) {
1065 DCHECK(resource->origin != Resource::Internal);
1066 DCHECK(resource->mailbox.IsTexture());
1069 if (resource->mailbox.sync_point()) {
1070 GLC(gl, gl->WaitSyncPointCHROMIUM(resource->mailbox.sync_point()));
1071 resource->mailbox.set_sync_point(0);
1073 resource->gl_id = texture_id_allocator_->NextId();
1074 GLC(gl, gl->BindTexture(resource->target, resource->gl_id));
1076 gl->ConsumeTextureCHROMIUM(resource->mailbox.target(),
1077 resource->mailbox.name()));
1080 if (!resource->pixels && resource->has_shared_bitmap_id &&
1084 resource->size, resource->shared_bitmap_id);
1086 resource->shared_bitmap = bitmap.release();
1087 resource->pixels = resource->shared_bitmap->pixels();
1091 resource->lock_for_read_count++;
1092 if (resource->enable_read_lock_fences)
1093 resource->read_lock_fence = current_read_lock_fence_;
1095 return resource;
1103 Resource* resource = &it->second;
1104 DCHECK_GT(resource->lock_for_read_count, 0);
1105 DCHECK_EQ(resource->exported_count, 0);
1106 resource->lock_for_read_count--;
1107 if (resource->marked_for_deletion && !resource->lock_for_read_count) {
1108 if (!resource->child_id) {
1109 // The resource belongs to this ResourceProvider, so it can be destroyed.
1112 ChildMap::iterator child_it = children_.find(resource->child_id);
1120 const ResourceProvider::Resource* ResourceProvider::LockForWrite(
1122 Resource* resource = GetResource(id);
1123 DCHECK(!resource->locked_for_write);
1124 DCHECK(!resource->lock_for_read_count);
1125 DCHECK_EQ(resource->exported_count, 0);
1126 DCHECK(resource->origin == Resource::Internal);
1127 DCHECK(!resource->lost);
1128 DCHECK(ReadLockFenceHasPassed(resource));
1129 LazyAllocate(resource);
1131 resource->locked_for_write = true;
1132 return resource;
1136 Resource* resource = GetResource(id);
1137 return !resource->locked_for_write && !resource->lock_for_read_count &&
1138 !resource->exported_count && resource->origin == Resource::Internal &&
1139 !resource->lost && ReadLockFenceHasPassed(resource);
1143 Resource* resource = GetResource(id);
1144 DCHECK(resource->locked_for_write);
1145 DCHECK_EQ(resource->exported_count, 0);
1146 DCHECK(resource->origin == Resource::Internal);
1147 resource->locked_for_write = false;
1199 SkBitmap* sk_bitmap, const Resource* resource) {
1200 DCHECK_EQ(RGBA_8888, resource->format);
1201 SkImageInfo info = SkImageInfo::MakeN32Premul(resource->size.width(),
1202 resource->size.height());
1203 sk_bitmap->installPixels(info, resource->pixels, info.minRowBytes());
1211 const Resource* resource = resource_provider->LockForRead(resource_id);
1212 wrap_mode_ = resource->wrap_mode;
1213 ResourceProvider::PopulateSkBitmapWithResource(&sk_bitmap_, resource);
1387 TransferableResource resource;
1388 TransferResource(gl, *it, &resource);
1389 if (!resource.mailbox_holder.sync_point && !resource.is_software)
1392 list->push_back(resource);
1417 Resource& resource = resources_[resource_in_map_it->second];
1418 resource.marked_for_deletion = false;
1419 resource.imported_count++;
1433 Resource& resource = resources_[local_id];
1435 resource = Resource(it->mailbox_holder.mailbox,
1437 Resource::Delegated,
1441 resource = Resource(0,
1443 Resource::Delegated,
1450 resource.mailbox = TextureMailbox(it->mailbox_holder.mailbox,
1454 resource.child_id = child;
1456 resource.allocated = true;
1457 resource.imported_count = 1;
1502 const Resource& a_resource = a_it->second;
1503 const Resource& b_resource = b_it->second;
1524 // Resource was already lost (e.g. it belonged to a child that was
1542 Resource* resource = &map_iterator->second;
1544 CHECK_GE(resource->exported_count, returned.count);
1545 resource->exported_count -= returned.count;
1546 resource->lost |= returned.lost;
1547 if (resource->exported_count)
1551 // recycle this resource.
1552 if (resource->enable_read_lock_fences)
1553 resource->read_lock_fence = current_read_lock_fence_;
1556 DCHECK(!resource->has_shared_bitmap_id);
1557 if (resource->origin == Resource::Internal) {
1558 DCHECK(resource->gl_id);
1561 DCHECK(!resource->gl_id);
1562 resource->mailbox.set_sync_point(returned.sync_point);
1566 if (!resource->marked_for_deletion)
1569 if (!resource->child_id) {
1570 // The resource belongs to this ResourceProvider, so it can be destroyed.
1575 DCHECK(resource->origin == Resource::Delegated);
1576 // Delete the resource and return it to the child it came from one.
1577 if (resource->child_id != child_id) {
1586 child_it = children_.find(resource->child_id);
1588 child_id = resource->child_id;
1603 TransferableResource* resource) {
1604 Resource* source = GetResource(id);
1607 DCHECK(source->origin != Resource::External || source->mailbox.IsValid());
1609 resource->id = id;
1610 resource->format = source->format;
1611 resource->mailbox_holder.texture_target = source->target;
1612 resource->filter = source->filter;
1613 resource->size = source->size;
1614 resource->is_repeated = (source->wrap_mode == GL_REPEAT);
1617 resource->mailbox_holder.mailbox = source->shared_bitmap_id;
1618 resource->is_software = true;
1622 DCHECK(source->origin == Resource::Internal);
1624 gl->BindTexture(resource->mailbox_holder.texture_target,
1630 // This is a resource allocated by the compositor, we need to produce it.
1632 GLC(gl, gl->GenMailboxCHROMIUM(resource->mailbox_holder.mailbox.name));
1634 gl->ProduceTextureCHROMIUM(resource->mailbox_holder.texture_target,
1635 resource->mailbox_holder.mailbox.name));
1636 source->mailbox = TextureMailbox(resource->mailbox_holder);
1641 DCHECK(source->origin == Resource::Internal);
1643 gl->BindTexture(resource->mailbox_holder.texture_target,
1647 // This is either an external resource, or a compositor resource that we
1649 resource->mailbox_holder.mailbox = source->mailbox.mailbox();
1650 resource->mailbox_holder.texture_target = source->mailbox.target();
1651 resource->mailbox_holder.sync_point = source->mailbox.sync_point();
1676 Resource& resource = it->second;
1678 DCHECK(!resource.locked_for_write);
1686 resource.lost || (resource.type == GLTexture && lost_output_surface_);
1687 if (resource.exported_count > 0 || resource.lock_for_read_count > 0) {
1689 // Defer this until we receive the resource back from the parent or
1691 resource.marked_for_deletion = true;
1699 if (gl && resource.filter != resource.original_filter) {
1700 DCHECK(resource.target);
1701 DCHECK(resource.gl_id);
1703 GLC(gl, gl->BindTexture(resource.target, resource.gl_id));
1705 gl->TexParameteri(resource.target,
1707 resource.original_filter));
1709 gl->TexParameteri(resource.target,
1711 resource.original_filter));
1716 returned.sync_point = resource.mailbox.sync_point();
1717 if (!returned.sync_point && resource.type == GLTexture)
1719 returned.count = resource.imported_count;
1725 resource.imported_count = 0;
1748 // Resource needs to be locked for write since DirectRasterBuffer writes
1751 Resource* resource = GetResource(id);
1752 if (!resource->direct_raster_buffer.get()) {
1753 resource->direct_raster_buffer.reset(
1754 new DirectRasterBuffer(resource, this, use_distance_field_text_));
1756 return resource->direct_raster_buffer->LockForWrite();
1760 Resource* resource = GetResource(id);
1761 DCHECK(resource->direct_raster_buffer.get());
1762 resource->direct_raster_buffer->UnlockForWrite();
1767 Resource* resource = GetResource(id);
1768 AcquireImage(resource);
1769 if (!resource->image_raster_buffer.get())
1770 resource->image_raster_buffer.reset(new ImageRasterBuffer(resource, this));
1771 return resource->image_raster_buffer->LockForWrite();
1775 Resource* resource = GetResource(id);
1776 resource->dirty_image = true;
1777 return resource->image_raster_buffer->UnlockForWrite();
1781 Resource* resource = GetResource(id);
1782 AcquirePixelBuffer(resource);
1783 resource->pixel_raster_buffer.reset(new PixelRasterBuffer(resource, this));
1787 Resource* resource = GetResource(id);
1788 resource->pixel_raster_buffer.reset();
1789 ReleasePixelBuffer(resource);
1793 Resource* resource = GetResource(id);
1794 DCHECK(resource->pixel_raster_buffer.get());
1795 return resource->pixel_raster_buffer->LockForWrite();
1799 Resource* resource = GetResource(id);
1800 DCHECK(resource->pixel_raster_buffer.get());
1801 return resource->pixel_raster_buffer->UnlockForWrite();
1804 void ResourceProvider::AcquirePixelBuffer(Resource* resource) {
1808 DCHECK(resource->origin == Resource::Internal);
1809 DCHECK_EQ(resource->exported_count, 0);
1810 DCHECK(!resource->image_id);
1811 DCHECK_NE(ETC1, resource->format);
1813 DCHECK_EQ(GLTexture, resource->type);
1816 if (!resource->gl_pixel_buffer_id)
1817 resource->gl_pixel_buffer_id = buffer_id_allocator_->NextId();
1819 resource->gl_pixel_buffer_id);
1820 unsigned bytes_per_pixel = BitsPerPixel(resource->format) / 8;
1822 resource->size.height() *
1823 RoundUp(bytes_per_pixel * resource->size.width(), 4u),
1829 void ResourceProvider::ReleasePixelBuffer(Resource* resource) {
1833 DCHECK(resource->origin == Resource::Internal);
1834 DCHECK_EQ(resource->exported_count, 0);
1835 DCHECK(!resource->image_id);
1841 // reuse any query id associated with this resource before they complete
1843 if (resource->pending_set_pixels) {
1844 DCHECK(resource->set_pixels_completion_forced);
1845 resource->pending_set_pixels = false;
1846 resource->locked_for_write = false;
1849 DCHECK_EQ(GLTexture, resource->type);
1850 if (!resource->gl_pixel_buffer_id)
1855 resource->gl_pixel_buffer_id);
1861 uint8_t* ResourceProvider::MapPixelBuffer(const Resource* resource,
1866 DCHECK(resource->origin == Resource::Internal);
1867 DCHECK_EQ(resource->exported_count, 0);
1868 DCHECK(!resource->image_id);
1871 DCHECK_EQ(GLTexture, resource->type);
1874 DCHECK(resource->gl_pixel_buffer_id);
1876 resource->gl_pixel_buffer_id);
1885 void ResourceProvider::UnmapPixelBuffer(const Resource* resource) {
1889 DCHECK(resource->origin == Resource::Internal);
1890 DCHECK_EQ(resource->exported_count, 0);
1891 DCHECK(!resource->image_id);
1893 DCHECK_EQ(GLTexture, resource->type);
1896 DCHECK(resource->gl_pixel_buffer_id);
1898 resource->gl_pixel_buffer_id);
1911 Resource* resource = &it->second;
1912 DCHECK(resource->lock_for_read_count);
1913 DCHECK(!resource->locked_for_write || resource->set_pixels_completion_forced);
1916 GLenum target = resource->target;
1917 GLC(gl, gl->BindTexture(target, resource->gl_id));
1918 if (filter != resource->filter) {
1921 resource->filter = filter;
1924 if (resource->image_id && resource->dirty_image)
1925 BindImageForSampling(resource);
1934 Resource* resource = GetResource(id);
1935 DCHECK(!resource->pending_set_pixels);
1937 LazyCreate(resource);
1938 DCHECK(resource->origin == Resource::Internal);
1939 DCHECK(resource->gl_id || resource->allocated);
1940 DCHECK(ReadLockFenceHasPassed(resource));
1941 DCHECK(!resource->image_id);
1943 bool allocate = !resource->allocated;
1944 resource->allocated = true;
1947 DCHECK_EQ(GLTexture, resource->type);
1948 DCHECK(resource->gl_id);
1951 DCHECK(resource->gl_pixel_buffer_id);
1952 DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D));
1953 gl->BindTexture(GL_TEXTURE_2D, resource->gl_id);
1955 resource->gl_pixel_buffer_id);
1956 if (!resource->gl_upload_query_id)
1957 gl->GenQueriesEXT(1, &resource->gl_upload_query_id);
1959 resource->gl_upload_query_id);
1963 resource->format),
1964 resource->size.width(),
1965 resource->size.height(),
1967 GLDataFormat(resource->format),
1968 GLDataType(resource->format),
1975 resource->size.width(),
1976 resource->size.height(),
1977 GLDataFormat(resource->format),
1978 GLDataType(resource->format),
1984 resource->pending_set_pixels = true;
1985 resource->set_pixels_completion_forced = false;
1992 Resource* resource = GetResource(id);
1993 DCHECK(resource->locked_for_write);
1994 DCHECK(resource->pending_set_pixels);
1995 DCHECK(!resource->set_pixels_completion_forced);
1997 if (resource->gl_id) {
1999 GLC(gl, gl->BindTexture(GL_TEXTURE_2D, resource->gl_id));
2004 resource->set_pixels_completion_forced = true;
2011 Resource* resource = GetResource(id);
2012 DCHECK(resource->locked_for_write);
2013 DCHECK(resource->pending_set_pixels);
2015 if (resource->gl_id) {
2018 DCHECK(resource->gl_upload_query_id);
2021 resource->gl_upload_query_id, GL_QUERY_RESULT_AVAILABLE_EXT, &complete);
2026 resource->pending_set_pixels = false;
2037 Resource* resource = GetResource(id);
2038 return resource->target;
2041 void ResourceProvider::LazyCreate(Resource* resource) {
2042 if (resource->type != GLTexture || resource->origin != Resource::Internal)
2045 if (resource->gl_id)
2048 DCHECK(resource->texture_pool);
2049 DCHECK(resource->origin == Resource::Internal);
2050 DCHECK(!resource->mailbox.IsValid());
2051 resource->gl_id = texture_id_allocator_->NextId();
2057 GLC(gl, gl->BindTexture(resource->target, resource->gl_id));
2059 gl->TexParameteri(resource->target, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
2061 gl->TexParameteri(resource->target, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
2064 resource->target, GL_TEXTURE_WRAP_S, resource->wrap_mode));
2067 resource->target, GL_TEXTURE_WRAP_T, resource->wrap_mode));
2070 resource->target, GL_TEXTURE_POOL_CHROMIUM, resource->texture_pool));
2071 if (use_texture_usage_hint_ && resource->hint == TextureUsageFramebuffer) {
2073 gl->TexParameteri(resource->target,
2083 void ResourceProvider::LazyAllocate(Resource* resource) {
2084 DCHECK(resource);
2085 LazyCreate(resource);
2087 DCHECK(resource->gl_id || resource->allocated);
2088 if (resource->allocated || !resource->gl_id)
2090 resource->allocated = true;
2092 gfx::Size& size = resource->size;
2093 DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D));
2094 ResourceFormat format = resource->format;
2095 GLC(gl, gl->BindTexture(GL_TEXTURE_2D, resource->gl_id));
2097 resource->hint != TextureUsageFramebuffer) {
2119 void ResourceProvider::BindImageForSampling(Resource* resource) {
2121 DCHECK(resource->gl_id);
2122 DCHECK(resource->image_id);
2125 if (resource->bound_image_id)
2126 gl->ReleaseTexImage2DCHROMIUM(resource->target, resource->bound_image_id);
2127 gl->BindTexImage2DCHROMIUM(resource->target, resource->image_id);
2128 resource->bound_image_id = resource->image_id;
2129 resource->dirty_image = false;
2134 Resource* resource = GetResource(id);
2135 resource->enable_read_lock_fences = enable;
2138 void ResourceProvider::AcquireImage(Resource* resource) {
2139 DCHECK(resource->origin == Resource::Internal);
2140 DCHECK_EQ(resource->exported_count, 0);
2142 if (resource->type != GLTexture)
2145 if (resource->image_id)
2148 resource->allocated = true;
2151 resource->image_id =
2152 gl->CreateImageCHROMIUM(resource->size.width(),
2153 resource->size.height(),
2154 TextureToStorageFormat(resource->format),
2156 DCHECK(resource->image_id);
2159 void ResourceProvider::ReleaseImage(Resource* resource) {
2160 DCHECK(resource->origin == Resource::Internal);
2161 DCHECK_EQ(resource->exported_count, 0);
2163 if (!resource->image_id)
2168 gl->DestroyImageCHROMIUM(resource->image_id);
2169 resource->image_id = 0;
2170 resource->bound_image_id = 0;
2171 resource->dirty_image = false;
2172 resource->allocated = false;
2175 uint8_t* ResourceProvider::MapImage(const Resource* resource, int* stride) {
2176 DCHECK(ReadLockFenceHasPassed(resource));
2177 DCHECK(resource->origin == Resource::Internal);
2178 DCHECK_EQ(resource->exported_count, 0);
2180 if (resource->type == GLTexture) {
2181 DCHECK(resource->image_id);
2186 static_cast<uint8_t*>(gl->MapImageCHROMIUM(resource->image_id));
2188 resource->image_id, GL_IMAGE_ROWBYTES_CHROMIUM, stride);
2191 DCHECK_EQ(Bitmap, resource->type);
2193 return resource->pixels;
2196 void ResourceProvider::UnmapImage(const Resource* resource) {
2197 DCHECK(resource->origin == Resource::Internal);
2198 DCHECK_EQ(resource->exported_count, 0);
2200 if (resource->image_id) {
2203 gl->UnmapImageCHROMIUM(resource->image_id);
2210 Resource* source_resource = GetResource(source_id);
2212 DCHECK(source_resource->origin == Resource::Internal);
2217 Resource* dest_resource = GetResource(dest_id);
2220 DCHECK(dest_resource->origin == Resource::Internal);
2249 // source resource until CopyTextureCHROMIUM command has completed.
