OLD | NEW |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 |
OLD | NEW |