Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(159)

Side by Side Diff: cc/resources/resource_provider.cc

Issue 2046033002: Revert of cc: Add mailbox support to ResourceProvider write locks. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@worker_context_stream
Patch Set: Created 4 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « cc/resources/resource_provider.h ('k') | cc/resources/resource_provider_unittest.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2012 The Chromium Authors. All rights reserved. 1 // Copyright 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "cc/resources/resource_provider.h" 5 #include "cc/resources/resource_provider.h"
6 6
7 #include <stddef.h> 7 #include <stddef.h>
8 #include <stdint.h> 8 #include <stdint.h>
9 9
10 #include <algorithm> 10 #include <algorithm>
(...skipping 798 matching lines...) Expand 10 before | Expand all | Expand 10 after
809 DCHECK(resource->allocated); 809 DCHECK(resource->allocated);
810 DCHECK_EQ(RGBA_8888, resource->format); 810 DCHECK_EQ(RGBA_8888, resource->format);
811 SkImageInfo source_info = 811 SkImageInfo source_info =
812 SkImageInfo::MakeN32Premul(image_size.width(), image_size.height()); 812 SkImageInfo::MakeN32Premul(image_size.width(), image_size.height());
813 size_t image_stride = image_size.width() * 4; 813 size_t image_stride = image_size.width() * 4;
814 814
815 ScopedWriteLockSoftware lock(this, id); 815 ScopedWriteLockSoftware lock(this, id);
816 SkCanvas dest(lock.sk_bitmap()); 816 SkCanvas dest(lock.sk_bitmap());
817 dest.writePixels(source_info, image, image_stride, 0, 0); 817 dest.writePixels(source_info, image, image_stride, 0, 0);
818 } else { 818 } else {
819 ScopedWriteLockGL lock(this, id, false); 819 ScopedWriteLockGL lock(this, id);
820 unsigned resource_texture_id = lock.texture_id(); 820 DCHECK(lock.texture_id());
821 DCHECK(resource_texture_id);
822 GLES2Interface* gl = ContextGL(); 821 GLES2Interface* gl = ContextGL();
823 DCHECK(gl); 822 DCHECK(gl);
824 gl->BindTexture(resource->target, resource_texture_id); 823 gl->BindTexture(resource->target, lock.texture_id());
825 if (resource->format == ETC1) { 824 if (resource->format == ETC1) {
826 DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D)); 825 DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D));
827 int image_bytes = ResourceUtil::CheckedSizeInBytes<int>(image_size, ETC1); 826 int image_bytes = ResourceUtil::CheckedSizeInBytes<int>(image_size, ETC1);
828 gl->CompressedTexImage2D(resource->target, 0, GLInternalFormat(ETC1), 827 gl->CompressedTexImage2D(resource->target, 0, GLInternalFormat(ETC1),
829 image_size.width(), image_size.height(), 0, 828 image_size.width(), image_size.height(), 0,
830 image_bytes, image); 829 image_bytes, image);
831 } else { 830 } else {
832 gl->TexSubImage2D(resource->target, 0, 0, 0, image_size.width(), 831 gl->TexSubImage2D(resource->target, 0, 0, 0, image_size.width(),
833 image_size.height(), GLDataFormat(resource->format), 832 image_size.height(), GLDataFormat(resource->format),
834 GLDataType(resource->format), image); 833 GLDataType(resource->format), image);
835 } 834 }
836 const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM(); 835 const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
837 gl->OrderingBarrierCHROMIUM(); 836 gl->OrderingBarrierCHROMIUM();
838 gpu::SyncToken sync_token; 837 gpu::SyncToken sync_token;
839 gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData()); 838 gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
840 lock.set_sync_token(sync_token); 839 lock.UpdateResourceSyncToken(sync_token);
841 } 840 }
842 } 841 }
843 842
844 void ResourceProvider::GenerateSyncTokenForResource(ResourceId resource_id) { 843 void ResourceProvider::GenerateSyncTokenForResource(ResourceId resource_id) {
845 Resource* resource = GetResource(resource_id); 844 Resource* resource = GetResource(resource_id);
846 if (!resource->needs_sync_token()) 845 if (!resource->needs_sync_token())
847 return; 846 return;
848 847
849 gpu::SyncToken sync_token; 848 gpu::SyncToken sync_token;
850 GLES2Interface* gl = ContextGL(); 849 GLES2Interface* gl = ContextGL();
(...skipping 143 matching lines...) Expand 10 before | Expand all | Expand 10 after
994 return !resource->locked_for_write && !resource->lock_for_read_count && 993 return !resource->locked_for_write && !resource->lock_for_read_count &&
995 !resource->exported_count && resource->origin == Resource::INTERNAL && 994 !resource->exported_count && resource->origin == Resource::INTERNAL &&
996 !resource->lost && ReadLockFenceHasPassed(resource); 995 !resource->lost && ReadLockFenceHasPassed(resource);
997 } 996 }
998 997
999 bool ResourceProvider::IsOverlayCandidate(ResourceId id) { 998 bool ResourceProvider::IsOverlayCandidate(ResourceId id) {
1000 Resource* resource = GetResource(id); 999 Resource* resource = GetResource(id);
1001 return resource->is_overlay_candidate; 1000 return resource->is_overlay_candidate;
1002 } 1001 }
1003 1002
1004 void ResourceProvider::UnlockForWrite(Resource* resource) { 1003 void ResourceProvider::UnlockForWrite(ResourceProvider::Resource* resource) {
1005 DCHECK(resource->locked_for_write); 1004 DCHECK(resource->locked_for_write);
1006 DCHECK_EQ(resource->exported_count, 0); 1005 DCHECK_EQ(resource->exported_count, 0);
1007 DCHECK(resource->origin == Resource::INTERNAL); 1006 DCHECK(resource->origin == Resource::INTERNAL);
1008 resource->locked_for_write = false; 1007 resource->locked_for_write = false;
1009 resource->SetSynchronized(); 1008 resource->SetSynchronized();
1010 } 1009 }
1011 1010
1012 void ResourceProvider::EnableReadLockFencesForTesting(ResourceId id) { 1011 void ResourceProvider::EnableReadLockFencesForTesting(ResourceId id) {
1013 Resource* resource = GetResource(id); 1012 Resource* resource = GetResource(id);
1014 DCHECK(resource); 1013 DCHECK(resource);
1015 resource->read_lock_fences_enabled = true; 1014 resource->read_lock_fences_enabled = true;
1016 } 1015 }
1017 1016
1018 ResourceProvider::ScopedReadLockGL::ScopedReadLockGL( 1017 ResourceProvider::ScopedReadLockGL::ScopedReadLockGL(
1019 ResourceProvider* resource_provider, 1018 ResourceProvider* resource_provider,
1020 ResourceId resource_id) 1019 ResourceId resource_id)
1021 : resource_provider_(resource_provider), resource_id_(resource_id) { 1020 : resource_provider_(resource_provider),
1022 const Resource* resource = resource_provider->LockForRead(resource_id, false); 1021 resource_id_(resource_id),
1023 texture_id_ = resource->gl_id; 1022 resource_(resource_provider->LockForRead(resource_id, false)) {
1024 target_ = resource->target; 1023 DCHECK(resource_);
1025 size_ = resource->size;
1026 } 1024 }
1027 1025
1028 ResourceProvider::ScopedReadLockGL::~ScopedReadLockGL() { 1026 ResourceProvider::ScopedReadLockGL::~ScopedReadLockGL() {
1029 resource_provider_->UnlockForRead(resource_id_); 1027 resource_provider_->UnlockForRead(resource_id_);
1030 } 1028 }
1031 1029
1032 ResourceProvider::ScopedSamplerGL::ScopedSamplerGL( 1030 ResourceProvider::ScopedSamplerGL::ScopedSamplerGL(
1033 ResourceProvider* resource_provider, 1031 ResourceProvider* resource_provider,
1034 ResourceId resource_id, 1032 ResourceId resource_id,
1035 GLenum filter) 1033 GLenum filter)
1036 : resource_lock_(resource_provider, resource_id), 1034 : ScopedReadLockGL(resource_provider, resource_id),
1037 unit_(GL_TEXTURE0), 1035 unit_(GL_TEXTURE0),
1038 target_(resource_provider->BindForSampling(resource_id, unit_, filter)) {} 1036 target_(resource_provider->BindForSampling(resource_id, unit_, filter)) {
1037 }
1039 1038
1040 ResourceProvider::ScopedSamplerGL::ScopedSamplerGL( 1039 ResourceProvider::ScopedSamplerGL::ScopedSamplerGL(
1041 ResourceProvider* resource_provider, 1040 ResourceProvider* resource_provider,
1042 ResourceId resource_id, 1041 ResourceId resource_id,
1043 GLenum unit, 1042 GLenum unit,
1044 GLenum filter) 1043 GLenum filter)
1045 : resource_lock_(resource_provider, resource_id), 1044 : ScopedReadLockGL(resource_provider, resource_id),
1046 unit_(unit), 1045 unit_(unit),
1047 target_(resource_provider->BindForSampling(resource_id, unit_, filter)) {} 1046 target_(resource_provider->BindForSampling(resource_id, unit_, filter)) {
1047 }
1048 1048
1049 ResourceProvider::ScopedSamplerGL::~ScopedSamplerGL() { 1049 ResourceProvider::ScopedSamplerGL::~ScopedSamplerGL() {
1050 } 1050 }
1051 1051
1052 ResourceProvider::ScopedWriteLockGL::ScopedWriteLockGL( 1052 ResourceProvider::ScopedWriteLockGL::ScopedWriteLockGL(
1053 ResourceProvider* resource_provider, 1053 ResourceProvider* resource_provider,
1054 ResourceId resource_id, 1054 ResourceId resource_id)
1055 bool create_mailbox) 1055 : resource_provider_(resource_provider),
1056 : resource_provider_(resource_provider), resource_id_(resource_id) { 1056 resource_(resource_provider->LockForWrite(resource_id)),
1057 DCHECK(thread_checker_.CalledOnValidThread()); 1057 texture_id_(0),
1058 Resource* resource = resource_provider->LockForWrite(resource_id); 1058 set_sync_token_(false) {
1059 resource_provider_->LazyAllocate(resource); 1059 resource_provider_->LazyAllocate(resource_);
1060 if (resource->image_id && resource->dirty_image) 1060 texture_id_ = resource_->gl_id;
1061 resource_provider_->BindImageForSampling(resource); 1061 DCHECK(texture_id_);
1062 if (create_mailbox) { 1062 if (resource_->image_id && resource_->dirty_image)
1063 resource_provider_->CreateMailboxAndBindResource( 1063 resource_provider_->BindImageForSampling(resource_);
1064 resource_provider_->ContextGL(), resource);
1065 }
1066 texture_id_ = resource->gl_id;
1067 target_ = resource->target;
1068 format_ = resource->format;
1069 size_ = resource->size;
1070 mailbox_ = resource->mailbox();
1071 } 1064 }
1072 1065
1073 ResourceProvider::ScopedWriteLockGL::~ScopedWriteLockGL() { 1066 ResourceProvider::ScopedWriteLockGL::~ScopedWriteLockGL() {
1074 DCHECK(thread_checker_.CalledOnValidThread()); 1067 if (set_sync_token_)
1075 Resource* resource = resource_provider_->GetResource(resource_id_); 1068 resource_->UpdateSyncToken(sync_token_);
1076 DCHECK(resource->locked_for_write); 1069 resource_provider_->UnlockForWrite(resource_);
1077 if (sync_token_.HasData())
1078 resource->UpdateSyncToken(sync_token_);
1079 resource_provider_->UnlockForWrite(resource);
1080 } 1070 }
1081 1071
1082 ResourceProvider::ScopedTextureProvider::ScopedTextureProvider( 1072 void ResourceProvider::PopulateSkBitmapWithResource(
1083 gpu::gles2::GLES2Interface* gl, 1073 SkBitmap* sk_bitmap, const Resource* resource) {
1084 ScopedWriteLockGL* resource_lock, 1074 DCHECK_EQ(RGBA_8888, resource->format);
1085 bool use_mailbox) 1075 SkImageInfo info = SkImageInfo::MakeN32Premul(resource->size.width(),
1086 : gl_(gl), use_mailbox_(use_mailbox) { 1076 resource->size.height());
1087 if (use_mailbox_) { 1077 sk_bitmap->installPixels(info, resource->pixels, info.minRowBytes());
1088 texture_id_ = gl_->CreateAndConsumeTextureCHROMIUM(
1089 resource_lock->target(), resource_lock->mailbox().name());
1090 } else {
1091 texture_id_ = resource_lock->texture_id();
1092 }
1093 DCHECK(texture_id_);
1094 } 1078 }
1095 1079
1096 ResourceProvider::ScopedTextureProvider::~ScopedTextureProvider() { 1080 ResourceProvider::ScopedReadLockSoftware::ScopedReadLockSoftware(
1097 if (use_mailbox_) 1081 ResourceProvider* resource_provider,
1098 gl_->DeleteTextures(1, &texture_id_); 1082 ResourceId resource_id)
1083 : resource_provider_(resource_provider), resource_id_(resource_id) {
1084 const Resource* resource = resource_provider->LockForRead(resource_id, false);
1085 ResourceProvider::PopulateSkBitmapWithResource(&sk_bitmap_, resource);
1099 } 1086 }
1100 1087
1101 ResourceProvider::ScopedSkSurfaceProvider::ScopedSkSurfaceProvider( 1088 ResourceProvider::ScopedReadLockSoftware::~ScopedReadLockSoftware() {
1102 ContextProvider* context_provider, 1089 resource_provider_->UnlockForRead(resource_id_);
1103 ScopedWriteLockGL* resource_lock, 1090 }
1104 bool use_mailbox, 1091
1092 ResourceProvider::ScopedWriteLockSoftware::ScopedWriteLockSoftware(
1093 ResourceProvider* resource_provider,
1094 ResourceId resource_id)
1095 : resource_provider_(resource_provider),
1096 resource_(resource_provider->LockForWrite(resource_id)) {
1097 ResourceProvider::PopulateSkBitmapWithResource(&sk_bitmap_, resource_);
1098 DCHECK(valid());
1099 }
1100
1101 ResourceProvider::ScopedWriteLockSoftware::~ScopedWriteLockSoftware() {
1102 DCHECK(thread_checker_.CalledOnValidThread());
1103 resource_provider_->UnlockForWrite(resource_);
1104 }
1105
1106 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::
1107 ScopedWriteLockGpuMemoryBuffer(ResourceProvider* resource_provider,
1108 ResourceId resource_id)
1109 : resource_provider_(resource_provider),
1110 resource_(resource_provider->LockForWrite(resource_id)) {
1111 DCHECK(IsGpuResourceType(resource_->type));
1112 gpu_memory_buffer_ = std::move(resource_->gpu_memory_buffer);
1113 resource_->gpu_memory_buffer = nullptr;
1114 }
1115
1116 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::
1117 ~ScopedWriteLockGpuMemoryBuffer() {
1118 DCHECK(thread_checker_.CalledOnValidThread());
1119 resource_provider_->UnlockForWrite(resource_);
1120 if (!gpu_memory_buffer_)
1121 return;
1122
1123 DCHECK(!resource_->gpu_memory_buffer);
1124 resource_provider_->LazyCreate(resource_);
1125 resource_->gpu_memory_buffer = std::move(gpu_memory_buffer_);
1126 if (resource_->gpu_memory_buffer)
1127 resource_->gpu_memory_buffer_id = resource_->gpu_memory_buffer->GetId();
1128 resource_->allocated = true;
1129 resource_provider_->LazyCreateImage(resource_);
1130 resource_->dirty_image = true;
1131 resource_->is_overlay_candidate = true;
1132 resource_->SetSynchronized();
1133
1134 // GpuMemoryBuffer provides direct access to the memory used by the GPU.
1135 // Read lock fences are required to ensure that we're not trying to map a
1136 // buffer that is currently in-use by the GPU.
1137 resource_->read_lock_fences_enabled = true;
1138 }
1139
1140 gfx::GpuMemoryBuffer*
1141 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::GetGpuMemoryBuffer() {
1142 if (!gpu_memory_buffer_) {
1143 gpu_memory_buffer_ =
1144 resource_provider_->gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
1145 resource_->size, BufferFormat(resource_->format),
1146 gfx::BufferUsage::GPU_READ_CPU_READ_WRITE, gpu::kNullSurfaceHandle);
1147 }
1148 return gpu_memory_buffer_.get();
1149 }
1150
1151 ResourceProvider::ScopedReadLockGpuMemoryBuffer::ScopedReadLockGpuMemoryBuffer(
1152 ResourceProvider* resource_provider,
1153 ResourceId resource_id)
1154 : resource_provider_(resource_provider),
1155 resource_id_(resource_id),
1156 resource_(resource_provider->LockForRead(resource_id, true)) {}
1157
1158 ResourceProvider::ScopedReadLockGpuMemoryBuffer::
1159 ~ScopedReadLockGpuMemoryBuffer() {
1160 DCHECK(thread_checker_.CalledOnValidThread());
1161 resource_provider_->UnlockForRead(resource_id_);
1162 }
1163
1164 gfx::GpuMemoryBuffer*
1165 ResourceProvider::ScopedReadLockGpuMemoryBuffer::GetGpuMemoryBuffer() const {
1166 return resource_->gpu_memory_buffer.get();
1167 }
1168
1169 unsigned ResourceProvider::ScopedReadLockGpuMemoryBuffer::GetTextureId() const {
1170 return resource_->gl_id;
1171 }
1172
1173 ResourceId ResourceProvider::ScopedReadLockGpuMemoryBuffer::GetResourceId()
1174 const {
1175 return resource_id_;
1176 }
1177
1178 ResourceProvider::ScopedWriteLockGr::ScopedWriteLockGr(
1179 ResourceProvider* resource_provider,
1180 ResourceId resource_id)
1181 : resource_provider_(resource_provider),
1182 resource_(resource_provider->LockForWrite(resource_id)),
1183 set_sync_token_(false) {
1184 DCHECK(thread_checker_.CalledOnValidThread());
1185 resource_provider_->LazyAllocate(resource_);
1186 if (resource_->image_id && resource_->dirty_image)
1187 resource_provider_->BindImageForSampling(resource_);
1188 }
1189
1190 ResourceProvider::ScopedWriteLockGr::~ScopedWriteLockGr() {
1191 DCHECK(thread_checker_.CalledOnValidThread());
1192 DCHECK(resource_->locked_for_write);
1193 if (set_sync_token_)
1194 resource_->UpdateSyncToken(sync_token_);
1195
1196 resource_provider_->UnlockForWrite(resource_);
1197 }
1198
1199 void ResourceProvider::ScopedWriteLockGr::InitSkSurface(
1200 GrContext* gr_context,
1105 bool use_distance_field_text, 1201 bool use_distance_field_text,
1106 bool can_use_lcd_text, 1202 bool can_use_lcd_text,
1107 int msaa_sample_count) 1203 int msaa_sample_count) {
1108 : texture_provider_(context_provider->ContextGL(), 1204 DCHECK(resource_->locked_for_write);
1109 resource_lock, 1205
1110 use_mailbox) {
1111 GrGLTextureInfo texture_info; 1206 GrGLTextureInfo texture_info;
1112 texture_info.fID = texture_provider_.texture_id(); 1207 texture_info.fID = resource_->gl_id;
1113 texture_info.fTarget = resource_lock->target(); 1208 texture_info.fTarget = resource_->target;
1114 GrBackendTextureDesc desc; 1209 GrBackendTextureDesc desc;
1115 desc.fFlags = kRenderTarget_GrBackendTextureFlag; 1210 desc.fFlags = kRenderTarget_GrBackendTextureFlag;
1116 desc.fWidth = resource_lock->size().width(); 1211 desc.fWidth = resource_->size.width();
1117 desc.fHeight = resource_lock->size().height(); 1212 desc.fHeight = resource_->size.height();
1118 desc.fConfig = ToGrPixelConfig(resource_lock->format()); 1213 desc.fConfig = ToGrPixelConfig(resource_->format);
1119 desc.fOrigin = kTopLeft_GrSurfaceOrigin; 1214 desc.fOrigin = kTopLeft_GrSurfaceOrigin;
1120 desc.fTextureHandle = skia::GrGLTextureInfoToGrBackendObject(texture_info); 1215 desc.fTextureHandle = skia::GrGLTextureInfoToGrBackendObject(texture_info);
1121 desc.fSampleCnt = msaa_sample_count; 1216 desc.fSampleCnt = msaa_sample_count;
1122 1217
1123 uint32_t flags = 1218 uint32_t flags =
1124 use_distance_field_text ? SkSurfaceProps::kUseDistanceFieldFonts_Flag : 0; 1219 use_distance_field_text ? SkSurfaceProps::kUseDistanceFieldFonts_Flag : 0;
1125 // Use unknown pixel geometry to disable LCD text. 1220 // Use unknown pixel geometry to disable LCD text.
1126 SkSurfaceProps surface_props(flags, kUnknown_SkPixelGeometry); 1221 SkSurfaceProps surface_props(flags, kUnknown_SkPixelGeometry);
1127 if (can_use_lcd_text) { 1222 if (can_use_lcd_text) {
1128 // LegacyFontHost will get LCD text and skia figures out what type to use. 1223 // LegacyFontHost will get LCD text and skia figures out what type to use.
1129 surface_props = 1224 surface_props =
1130 SkSurfaceProps(flags, SkSurfaceProps::kLegacyFontHost_InitType); 1225 SkSurfaceProps(flags, SkSurfaceProps::kLegacyFontHost_InitType);
1131 } 1226 }
1132 sk_surface_ = SkSurface::MakeFromBackendTextureAsRenderTarget( 1227 sk_surface_ = SkSurface::MakeFromBackendTextureAsRenderTarget(
1133 context_provider->GrContext(), desc, &surface_props); 1228 gr_context, desc, &surface_props);
1134 } 1229 }
1135 1230
1136 ResourceProvider::ScopedSkSurfaceProvider::~ScopedSkSurfaceProvider() { 1231 void ResourceProvider::ScopedWriteLockGr::ReleaseSkSurface() {
1137 if (sk_surface_.get()) { 1232 DCHECK(sk_surface_);
1138 sk_surface_->prepareForExternalIO(); 1233 sk_surface_->prepareForExternalIO();
1139 sk_surface_.reset(); 1234 sk_surface_.reset();
1140 }
1141 }
1142
1143 void ResourceProvider::PopulateSkBitmapWithResource(
1144 SkBitmap* sk_bitmap, const Resource* resource) {
1145 DCHECK_EQ(RGBA_8888, resource->format);
1146 SkImageInfo info = SkImageInfo::MakeN32Premul(resource->size.width(),
1147 resource->size.height());
1148 sk_bitmap->installPixels(info, resource->pixels, info.minRowBytes());
1149 }
1150
1151 ResourceProvider::ScopedReadLockSoftware::ScopedReadLockSoftware(
1152 ResourceProvider* resource_provider,
1153 ResourceId resource_id)
1154 : resource_provider_(resource_provider), resource_id_(resource_id) {
1155 const Resource* resource = resource_provider->LockForRead(resource_id, false);
1156 ResourceProvider::PopulateSkBitmapWithResource(&sk_bitmap_, resource);
1157 }
1158
1159 ResourceProvider::ScopedReadLockSoftware::~ScopedReadLockSoftware() {
1160 resource_provider_->UnlockForRead(resource_id_);
1161 }
1162
1163 ResourceProvider::ScopedWriteLockSoftware::ScopedWriteLockSoftware(
1164 ResourceProvider* resource_provider,
1165 ResourceId resource_id)
1166 : resource_provider_(resource_provider), resource_id_(resource_id) {
1167 ResourceProvider::PopulateSkBitmapWithResource(
1168 &sk_bitmap_, resource_provider->LockForWrite(resource_id));
1169 DCHECK(valid());
1170 }
1171
1172 ResourceProvider::ScopedWriteLockSoftware::~ScopedWriteLockSoftware() {
1173 DCHECK(thread_checker_.CalledOnValidThread());
1174 resource_provider_->UnlockForWrite(
1175 resource_provider_->GetResource(resource_id_));
1176 }
1177
1178 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::
1179 ScopedWriteLockGpuMemoryBuffer(ResourceProvider* resource_provider,
1180 ResourceId resource_id)
1181 : resource_provider_(resource_provider), resource_id_(resource_id) {
1182 Resource* resource = resource_provider->LockForWrite(resource_id);
1183 DCHECK(IsGpuResourceType(resource->type));
1184 format_ = resource->format;
1185 size_ = resource->size;
1186 gpu_memory_buffer_ = std::move(resource->gpu_memory_buffer);
1187 resource->gpu_memory_buffer = nullptr;
1188 }
1189
1190 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::
1191 ~ScopedWriteLockGpuMemoryBuffer() {
1192 DCHECK(thread_checker_.CalledOnValidThread());
1193 Resource* resource = resource_provider_->GetResource(resource_id_);
1194 if (gpu_memory_buffer_) {
1195 DCHECK(!resource->gpu_memory_buffer);
1196 resource_provider_->LazyCreate(resource);
1197 resource->gpu_memory_buffer = std::move(gpu_memory_buffer_);
1198 if (resource->gpu_memory_buffer)
1199 resource->gpu_memory_buffer_id = resource->gpu_memory_buffer->GetId();
1200 resource->allocated = true;
1201 resource_provider_->LazyCreateImage(resource);
1202 resource->dirty_image = true;
1203 resource->is_overlay_candidate = true;
1204 // GpuMemoryBuffer provides direct access to the memory used by the GPU.
1205 // Read lock fences are required to ensure that we're not trying to map a
1206 // buffer that is currently in-use by the GPU.
1207 resource->read_lock_fences_enabled = true;
1208 }
1209 resource_provider_->UnlockForWrite(resource);
1210 }
1211
1212 gfx::GpuMemoryBuffer*
1213 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::GetGpuMemoryBuffer() {
1214 if (!gpu_memory_buffer_) {
1215 gpu_memory_buffer_ =
1216 resource_provider_->gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
1217 size_, BufferFormat(format_),
1218 gfx::BufferUsage::GPU_READ_CPU_READ_WRITE, gpu::kNullSurfaceHandle);
1219 }
1220 return gpu_memory_buffer_.get();
1221 }
1222
1223 ResourceProvider::ScopedReadLockGpuMemoryBuffer::ScopedReadLockGpuMemoryBuffer(
1224 ResourceProvider* resource_provider,
1225 ResourceId resource_id)
1226 : resource_provider_(resource_provider), resource_id_(resource_id) {
1227 const Resource* resource = resource_provider->LockForRead(resource_id, true);
1228 gpu_memory_buffer_ = resource->gpu_memory_buffer.get();
1229 texture_id_ = resource->gl_id;
1230 }
1231
1232 ResourceProvider::ScopedReadLockGpuMemoryBuffer::
1233 ~ScopedReadLockGpuMemoryBuffer() {
1234 DCHECK(thread_checker_.CalledOnValidThread());
1235 resource_provider_->UnlockForRead(resource_id_);
1236 } 1235 }
1237 1236
1238 ResourceProvider::SynchronousFence::SynchronousFence( 1237 ResourceProvider::SynchronousFence::SynchronousFence(
1239 gpu::gles2::GLES2Interface* gl) 1238 gpu::gles2::GLES2Interface* gl)
1240 : gl_(gl), has_synchronized_(true) { 1239 : gl_(gl), has_synchronized_(true) {
1241 } 1240 }
1242 1241
1243 ResourceProvider::SynchronousFence::~SynchronousFence() { 1242 ResourceProvider::SynchronousFence::~SynchronousFence() {
1244 } 1243 }
1245 1244
(...skipping 538 matching lines...) Expand 10 before | Expand all | Expand 10 after
1784 if (resource->type == RESOURCE_TYPE_GPU_MEMORY_BUFFER) { 1783 if (resource->type == RESOURCE_TYPE_GPU_MEMORY_BUFFER) {
1785 resource->gpu_memory_buffer = 1784 resource->gpu_memory_buffer =
1786 gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer( 1785 gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
1787 size, BufferFormat(format), 1786 size, BufferFormat(format),
1788 gfx::BufferUsage::GPU_READ_CPU_READ_WRITE, gpu::kNullSurfaceHandle); 1787 gfx::BufferUsage::GPU_READ_CPU_READ_WRITE, gpu::kNullSurfaceHandle);
1789 if (resource->gpu_memory_buffer) 1788 if (resource->gpu_memory_buffer)
1790 resource->gpu_memory_buffer_id = resource->gpu_memory_buffer->GetId(); 1789 resource->gpu_memory_buffer_id = resource->gpu_memory_buffer->GetId();
1791 LazyCreateImage(resource); 1790 LazyCreateImage(resource);
1792 resource->dirty_image = true; 1791 resource->dirty_image = true;
1793 resource->is_overlay_candidate = true; 1792 resource->is_overlay_candidate = true;
1794 // GpuMemoryBuffer provides direct access to the memory used by the GPU.
1795 // Read lock fences are required to ensure that we're not trying to map a
1796 // buffer that is currently in-use by the GPU.
1797 resource->read_lock_fences_enabled = true;
1798 } else if (use_texture_storage_ext_ && 1793 } else if (use_texture_storage_ext_ &&
1799 IsFormatSupportedForStorage(format, use_texture_format_bgra_) && 1794 IsFormatSupportedForStorage(format, use_texture_format_bgra_) &&
1800 (resource->hint & TEXTURE_HINT_IMMUTABLE)) { 1795 (resource->hint & TEXTURE_HINT_IMMUTABLE)) {
1801 GLenum storage_format = TextureToStorageFormat(format); 1796 GLenum storage_format = TextureToStorageFormat(format);
1802 gl->TexStorage2DEXT(resource->target, 1, storage_format, size.width(), 1797 gl->TexStorage2DEXT(resource->target, 1, storage_format, size.width(),
1803 size.height()); 1798 size.height());
1804 } else { 1799 } else {
1805 // ETC1 does not support preallocation. 1800 // ETC1 does not support preallocation.
1806 if (format != ETC1) { 1801 if (format != ETC1) {
1807 gl->TexImage2D(resource->target, 0, GLInternalFormat(format), 1802 gl->TexImage2D(resource->target, 0, GLInternalFormat(format),
(...skipping 156 matching lines...) Expand 10 before | Expand all | Expand 10 after
1964 1959
1965 const int kImportance = 2; 1960 const int kImportance = 2;
1966 pmd->CreateSharedGlobalAllocatorDump(guid); 1961 pmd->CreateSharedGlobalAllocatorDump(guid);
1967 pmd->AddOwnershipEdge(dump->guid(), guid, kImportance); 1962 pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
1968 } 1963 }
1969 1964
1970 return true; 1965 return true;
1971 } 1966 }
1972 1967
1973 } // namespace cc 1968 } // namespace cc
OLDNEW
« no previous file with comments | « cc/resources/resource_provider.h ('k') | cc/resources/resource_provider_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698