OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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 "ui/android/resources/resource_manager_impl.h" | 5 #include "ui/android/resources/resource_manager_impl.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <utility> | 9 #include <utility> |
10 #include <vector> | 10 #include <vector> |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
60 ResourceManagerImpl::GetJavaObject() { | 60 ResourceManagerImpl::GetJavaObject() { |
61 return base::android::ScopedJavaLocalRef<jobject>(java_obj_); | 61 return base::android::ScopedJavaLocalRef<jobject>(java_obj_); |
62 } | 62 } |
63 | 63 |
64 ResourceManager::Resource* ResourceManagerImpl::GetResource( | 64 ResourceManager::Resource* ResourceManagerImpl::GetResource( |
65 AndroidResourceType res_type, | 65 AndroidResourceType res_type, |
66 int res_id) { | 66 int res_id) { |
67 DCHECK_GE(res_type, ANDROID_RESOURCE_TYPE_FIRST); | 67 DCHECK_GE(res_type, ANDROID_RESOURCE_TYPE_FIRST); |
68 DCHECK_LE(res_type, ANDROID_RESOURCE_TYPE_LAST); | 68 DCHECK_LE(res_type, ANDROID_RESOURCE_TYPE_LAST); |
69 | 69 |
70 Resource* resource = resources_[res_type].Lookup(res_id); | 70 Resource* resource = nullptr; |
aelias_OOO_until_Jul13
2016/09/14 20:14:37
Could you delete this variable and just do:
std
mdjones
2016/09/14 22:23:02
Done.
| |
71 | 71 |
72 if (!resource || res_type == ANDROID_RESOURCE_TYPE_DYNAMIC || | 72 std::unordered_map<int, std::unique_ptr<Resource>>::iterator item = |
73 resources_[res_type].find(res_id); | |
74 | |
75 if (item == resources_[res_type].end() || | |
76 res_type == ANDROID_RESOURCE_TYPE_DYNAMIC || | |
73 res_type == ANDROID_RESOURCE_TYPE_DYNAMIC_BITMAP) { | 77 res_type == ANDROID_RESOURCE_TYPE_DYNAMIC_BITMAP) { |
74 RequestResourceFromJava(res_type, res_id); | 78 RequestResourceFromJava(res_type, res_id); |
75 resource = resources_[res_type].Lookup(res_id); | 79 |
80 // Check if the resource has been added (some dynamic may not have been). | |
81 item = resources_[res_type].find(res_id); | |
82 if (item != resources_[res_type].end()) | |
83 resource = item->second.get(); | |
84 } else { | |
85 resource = item->second.get(); | |
76 } | 86 } |
77 | 87 |
78 return resource; | 88 return resource; |
79 } | 89 } |
80 | 90 |
81 void ResourceManagerImpl::RemoveUnusedTints( | 91 void ResourceManagerImpl::RemoveUnusedTints( |
82 const std::unordered_set<int>& used_tints) { | 92 const std::unordered_set<int>& used_tints) { |
83 // Iterate over the currently cached tints and remove ones that were not | 93 // Iterate over the currently cached tints and remove ones that were not |
84 // used as defined in |used_tints|. | 94 // used as defined in |used_tints|. |
85 for (auto it = tinted_resources_.cbegin(); it != tinted_resources_.cend();) { | 95 for (auto it = tinted_resources_.cbegin(); it != tinted_resources_.cend();) { |
86 if (used_tints.find(it->first) == used_tints.end()) { | 96 if (used_tints.find(it->first) == used_tints.end()) { |
87 it = tinted_resources_.erase(it); | 97 it = tinted_resources_.erase(it); |
88 } else { | 98 } else { |
89 ++it; | 99 ++it; |
90 } | 100 } |
91 } | 101 } |
92 } | 102 } |
93 | 103 |
94 ResourceManager::Resource* ResourceManagerImpl::GetStaticResourceWithTint( | 104 ResourceManager::Resource* ResourceManagerImpl::GetStaticResourceWithTint( |
95 int res_id, | 105 int res_id, |
96 int tint_color) { | 106 SkColor tint_color) { |
97 if (tinted_resources_.find(tint_color) == tinted_resources_.end()) { | 107 if (tinted_resources_.find(tint_color) == tinted_resources_.end()) { |
98 tinted_resources_[tint_color] = base::MakeUnique<ResourceMap>(); | 108 tinted_resources_[tint_color] = base::MakeUnique<ResourceMap>(); |
99 } | 109 } |
100 ResourceMap* resource_map = tinted_resources_[tint_color].get(); | 110 ResourceMap* resource_map = tinted_resources_[tint_color].get(); |
101 | 111 |
102 Resource* tinted_resource = resource_map->Lookup(res_id); | 112 // If the resource is already cached, use it. |
113 std::unordered_map<int, std::unique_ptr<Resource>>::iterator item = | |
114 resource_map->find(res_id); | |
115 if (item != resource_map->end()) | |
116 return item->second.get(); | |
103 | 117 |
104 // If the resource is already cached, use it. | 118 std::unique_ptr<Resource> tinted_resource = base::MakeUnique<Resource>(); |
105 if (tinted_resource) | |
106 return tinted_resource; | |
107 | |
108 tinted_resource = new Resource(); | |
109 | 119 |
110 ResourceManager::Resource* base_image = | 120 ResourceManager::Resource* base_image = |
111 GetResource(ANDROID_RESOURCE_TYPE_STATIC, res_id); | 121 GetResource(ANDROID_RESOURCE_TYPE_STATIC, res_id); |
112 DCHECK(base_image); | 122 DCHECK(base_image); |
113 | 123 |
114 TRACE_EVENT0("browser", "ResourceManagerImpl::GetStaticResourceWithTint"); | 124 TRACE_EVENT0("browser", "ResourceManagerImpl::GetStaticResourceWithTint"); |
115 SkBitmap tinted_bitmap; | 125 SkBitmap tinted_bitmap; |
116 tinted_bitmap.allocPixels(SkImageInfo::MakeN32Premul(base_image->size.width(), | 126 tinted_bitmap.allocPixels(SkImageInfo::MakeN32Premul(base_image->size.width(), |
117 base_image->size.height())); | 127 base_image->size.height())); |
118 | 128 |
119 SkCanvas canvas(tinted_bitmap); | 129 SkCanvas canvas(tinted_bitmap); |
120 canvas.clear(SK_ColorTRANSPARENT); | 130 canvas.clear(SK_ColorTRANSPARENT); |
121 | 131 |
122 // Build a color filter to use on the base resource. This filter multiplies | 132 // Build a color filter to use on the base resource. This filter multiplies |
123 // the RGB components by the components of the new color but retains the | 133 // the RGB components by the components of the new color but retains the |
124 // alpha of the original image. | 134 // alpha of the original image. |
125 SkPaint color_filter; | 135 SkPaint color_filter; |
126 color_filter.setColorFilter( | 136 color_filter.setColorFilter( |
127 SkColorFilter::MakeModeFilter(tint_color, SkXfermode::kModulate_Mode)); | 137 SkColorFilter::MakeModeFilter(tint_color, SkXfermode::kModulate_Mode)); |
128 | 138 |
129 // Draw the resource and make it immutable. | 139 // Draw the resource and make it immutable. |
130 base_image->ui_resource->GetBitmap(base_image->ui_resource->id(), false) | 140 base_image->ui_resource->GetBitmap(base_image->ui_resource->id(), false) |
131 .DrawToCanvas(&canvas, &color_filter); | 141 .DrawToCanvas(&canvas, &color_filter); |
132 tinted_bitmap.setImmutable(); | 142 tinted_bitmap.setImmutable(); |
133 | 143 |
134 // Create a UI resource from the new bitmap. | 144 // Create a UI resource from the new bitmap. |
135 tinted_resource = new Resource(); | |
136 tinted_resource->size = gfx::Size(base_image->size); | 145 tinted_resource->size = gfx::Size(base_image->size); |
137 tinted_resource->padding = gfx::Rect(base_image->padding); | 146 tinted_resource->padding = gfx::Rect(base_image->padding); |
138 tinted_resource->aperture = gfx::Rect(base_image->aperture); | 147 tinted_resource->aperture = gfx::Rect(base_image->aperture); |
139 tinted_resource->ui_resource = cc::ScopedUIResource::Create( | 148 tinted_resource->ui_resource = cc::ScopedUIResource::Create( |
140 ui_resource_manager_, cc::UIResourceBitmap(tinted_bitmap)); | 149 ui_resource_manager_, cc::UIResourceBitmap(tinted_bitmap)); |
141 | 150 |
142 resource_map->AddWithID(tinted_resource, res_id); | 151 (*resource_map)[res_id].swap(tinted_resource); |
143 | 152 |
144 return tinted_resource; | 153 return (*resource_map)[res_id].get(); |
145 } | 154 } |
146 | 155 |
147 void ResourceManagerImpl::ClearTintedResourceCache(JNIEnv* env, | 156 void ResourceManagerImpl::ClearTintedResourceCache(JNIEnv* env, |
148 const JavaRef<jobject>& jobj) { | 157 const JavaRef<jobject>& jobj) { |
149 tinted_resources_.clear(); | 158 tinted_resources_.clear(); |
150 } | 159 } |
151 | 160 |
152 void ResourceManagerImpl::PreloadResource(AndroidResourceType res_type, | 161 void ResourceManagerImpl::PreloadResource(AndroidResourceType res_type, |
153 int res_id) { | 162 int res_id) { |
154 DCHECK_GE(res_type, ANDROID_RESOURCE_TYPE_FIRST); | 163 DCHECK_GE(res_type, ANDROID_RESOURCE_TYPE_FIRST); |
155 DCHECK_LE(res_type, ANDROID_RESOURCE_TYPE_LAST); | 164 DCHECK_LE(res_type, ANDROID_RESOURCE_TYPE_LAST); |
156 | 165 |
157 // Don't send out a query if the resource is already loaded. | 166 // Don't send out a query if the resource is already loaded. |
158 if (resources_[res_type].Lookup(res_id)) | 167 if (resources_[res_type].find(res_id) != resources_[res_type].end()) |
159 return; | 168 return; |
160 | 169 |
161 PreloadResourceFromJava(res_type, res_id); | 170 PreloadResourceFromJava(res_type, res_id); |
162 } | 171 } |
163 | 172 |
164 void ResourceManagerImpl::OnResourceReady(JNIEnv* env, | 173 void ResourceManagerImpl::OnResourceReady(JNIEnv* env, |
165 const JavaRef<jobject>& jobj, | 174 const JavaRef<jobject>& jobj, |
166 jint res_type, | 175 jint res_type, |
167 jint res_id, | 176 jint res_id, |
168 const JavaRef<jobject>& bitmap, | 177 const JavaRef<jobject>& bitmap, |
169 jint padding_left, | 178 jint padding_left, |
170 jint padding_top, | 179 jint padding_top, |
171 jint padding_right, | 180 jint padding_right, |
172 jint padding_bottom, | 181 jint padding_bottom, |
173 jint aperture_left, | 182 jint aperture_left, |
174 jint aperture_top, | 183 jint aperture_top, |
175 jint aperture_right, | 184 jint aperture_right, |
176 jint aperture_bottom) { | 185 jint aperture_bottom) { |
177 DCHECK_GE(res_type, ANDROID_RESOURCE_TYPE_FIRST); | 186 DCHECK_GE(res_type, ANDROID_RESOURCE_TYPE_FIRST); |
178 DCHECK_LE(res_type, ANDROID_RESOURCE_TYPE_LAST); | 187 DCHECK_LE(res_type, ANDROID_RESOURCE_TYPE_LAST); |
179 TRACE_EVENT2("ui", "ResourceManagerImpl::OnResourceReady", | 188 TRACE_EVENT2("ui", "ResourceManagerImpl::OnResourceReady", |
180 "resource_type", res_type, | 189 "resource_type", res_type, |
181 "resource_id", res_id); | 190 "resource_id", res_id); |
182 | 191 |
183 Resource* resource = resources_[res_type].Lookup(res_id); | 192 std::unordered_map<int, std::unique_ptr<Resource>>::iterator item = |
184 if (!resource) { | 193 resources_[res_type].find(res_id); |
185 resource = new Resource(); | 194 if (item == resources_[res_type].end()) { |
186 resources_[res_type].AddWithID(resource, res_id); | 195 resources_[res_type][res_id] = base::MakeUnique<Resource>(); |
187 } | 196 } |
188 | 197 |
198 Resource* resource = resources_[res_type][res_id].get(); | |
199 | |
189 gfx::JavaBitmap jbitmap(bitmap.obj()); | 200 gfx::JavaBitmap jbitmap(bitmap.obj()); |
190 resource->size = jbitmap.size(); | 201 resource->size = jbitmap.size(); |
191 resource->padding.SetRect(padding_left, padding_top, | 202 resource->padding.SetRect(padding_left, padding_top, |
192 padding_right - padding_left, | 203 padding_right - padding_left, |
193 padding_bottom - padding_top); | 204 padding_bottom - padding_top); |
194 resource->aperture.SetRect(aperture_left, aperture_top, | 205 resource->aperture.SetRect(aperture_left, aperture_top, |
195 aperture_right - aperture_left, | 206 aperture_right - aperture_left, |
196 aperture_bottom - aperture_top); | 207 aperture_bottom - aperture_top); |
197 | 208 |
198 SkBitmap skbitmap = gfx::CreateSkBitmapFromJavaBitmap(jbitmap); | 209 SkBitmap skbitmap = gfx::CreateSkBitmapFromJavaBitmap(jbitmap); |
199 skbitmap.setImmutable(); | 210 skbitmap.setImmutable(); |
200 resource->ui_resource = cc::ScopedUIResource::Create( | 211 resource->ui_resource = cc::ScopedUIResource::Create( |
201 ui_resource_manager_, cc::UIResourceBitmap(skbitmap)); | 212 ui_resource_manager_, cc::UIResourceBitmap(skbitmap)); |
202 } | 213 } |
203 | 214 |
204 CrushedSpriteResource* ResourceManagerImpl::GetCrushedSpriteResource( | 215 CrushedSpriteResource* ResourceManagerImpl::GetCrushedSpriteResource( |
205 int bitmap_res_id, int metadata_res_id) { | 216 int bitmap_res_id, int metadata_res_id) { |
206 CrushedSpriteResource* resource = | 217 |
207 crushed_sprite_resources_.Lookup(bitmap_res_id); | 218 CrushedSpriteResource* resource = nullptr; |
219 if (crushed_sprite_resources_.find(bitmap_res_id) | |
220 != crushed_sprite_resources_.end()) { | |
221 resource = crushed_sprite_resources_[bitmap_res_id].get(); | |
222 } | |
223 | |
208 if (!resource) { | 224 if (!resource) { |
209 RequestCrushedSpriteResourceFromJava(bitmap_res_id, metadata_res_id, false); | 225 RequestCrushedSpriteResourceFromJava(bitmap_res_id, metadata_res_id, false); |
210 resource = crushed_sprite_resources_.Lookup(bitmap_res_id); | 226 resource = crushed_sprite_resources_[bitmap_res_id].get(); |
211 } else if (resource->BitmapHasBeenEvictedFromMemory()) { | 227 } else if (resource->BitmapHasBeenEvictedFromMemory()) { |
212 RequestCrushedSpriteResourceFromJava(bitmap_res_id, metadata_res_id, true); | 228 RequestCrushedSpriteResourceFromJava(bitmap_res_id, metadata_res_id, true); |
213 } | 229 } |
214 | 230 |
215 return resource; | 231 return resource; |
216 } | 232 } |
217 | 233 |
218 void ResourceManagerImpl::OnCrushedSpriteResourceReady( | 234 void ResourceManagerImpl::OnCrushedSpriteResourceReady( |
219 JNIEnv* env, | 235 JNIEnv* env, |
220 const JavaRef<jobject>& jobj, | 236 const JavaRef<jobject>& jobj, |
221 jint bitmap_res_id, | 237 jint bitmap_res_id, |
222 const JavaRef<jobject>& bitmap, | 238 const JavaRef<jobject>& bitmap, |
223 const JavaRef<jobjectArray>& frame_rects, | 239 const JavaRef<jobjectArray>& frame_rects, |
224 jint unscaled_sprite_width, | 240 jint unscaled_sprite_width, |
225 jint unscaled_sprite_height, | 241 jint unscaled_sprite_height, |
226 jfloat scaled_sprite_width, | 242 jfloat scaled_sprite_width, |
227 jfloat scaled_sprite_height) { | 243 jfloat scaled_sprite_height) { |
228 // Construct source and destination rectangles for each frame from | 244 // Construct source and destination rectangles for each frame from |
229 // |frame_rects|. | 245 // |frame_rects|. |
230 std::vector<std::vector<int>> all_frame_rects_vector; | 246 std::vector<std::vector<int>> all_frame_rects_vector; |
231 JavaArrayOfIntArrayToIntVector(env, frame_rects.obj(), | 247 JavaArrayOfIntArrayToIntVector(env, frame_rects.obj(), |
232 &all_frame_rects_vector); | 248 &all_frame_rects_vector); |
233 CrushedSpriteResource::SrcDstRects src_dst_rects = | 249 CrushedSpriteResource::SrcDstRects src_dst_rects = |
234 ProcessCrushedSpriteFrameRects(all_frame_rects_vector); | 250 ProcessCrushedSpriteFrameRects(all_frame_rects_vector); |
235 | 251 |
236 SkBitmap skbitmap = | 252 SkBitmap skbitmap = |
237 gfx::CreateSkBitmapFromJavaBitmap(gfx::JavaBitmap(bitmap.obj())); | 253 gfx::CreateSkBitmapFromJavaBitmap(gfx::JavaBitmap(bitmap.obj())); |
238 | 254 |
239 CrushedSpriteResource* resource = new CrushedSpriteResource( | 255 std::unique_ptr<CrushedSpriteResource> resource = |
240 skbitmap, | 256 base::MakeUnique<CrushedSpriteResource>( |
241 src_dst_rects, | 257 skbitmap, |
242 gfx::Size(unscaled_sprite_width, unscaled_sprite_height), | 258 src_dst_rects, |
243 gfx::Size(scaled_sprite_width, scaled_sprite_height)); | 259 gfx::Size(unscaled_sprite_width, unscaled_sprite_height), |
260 gfx::Size(scaled_sprite_width, scaled_sprite_height)); | |
244 | 261 |
245 if (crushed_sprite_resources_.Lookup(bitmap_res_id)) { | 262 crushed_sprite_resources_[bitmap_res_id].swap(resource); |
246 crushed_sprite_resources_.Replace(bitmap_res_id, resource); | |
247 } else { | |
248 crushed_sprite_resources_.AddWithID(resource, bitmap_res_id); | |
249 } | |
250 } | 263 } |
251 | 264 |
252 CrushedSpriteResource::SrcDstRects | 265 CrushedSpriteResource::SrcDstRects |
253 ResourceManagerImpl::ProcessCrushedSpriteFrameRects( | 266 ResourceManagerImpl::ProcessCrushedSpriteFrameRects( |
254 std::vector<std::vector<int>> frame_rects_vector) { | 267 std::vector<std::vector<int>> frame_rects_vector) { |
255 CrushedSpriteResource::SrcDstRects src_dst_rects; | 268 CrushedSpriteResource::SrcDstRects src_dst_rects; |
256 for (size_t i = 0; i < frame_rects_vector.size(); ++i) { | 269 for (size_t i = 0; i < frame_rects_vector.size(); ++i) { |
257 std::vector<int> frame_ints = frame_rects_vector[i]; | 270 std::vector<int> frame_ints = frame_rects_vector[i]; |
258 CrushedSpriteResource::FrameSrcDstRects frame_src_dst_rects; | 271 CrushedSpriteResource::FrameSrcDstRects frame_src_dst_rects; |
259 | 272 |
(...skipping 16 matching lines...) Expand all Loading... | |
276 src_dst_rects.push_back(frame_src_dst_rects); | 289 src_dst_rects.push_back(frame_src_dst_rects); |
277 } | 290 } |
278 return src_dst_rects; | 291 return src_dst_rects; |
279 } | 292 } |
280 | 293 |
281 void ResourceManagerImpl::OnCrushedSpriteResourceReloaded( | 294 void ResourceManagerImpl::OnCrushedSpriteResourceReloaded( |
282 JNIEnv* env, | 295 JNIEnv* env, |
283 const JavaRef<jobject>& jobj, | 296 const JavaRef<jobject>& jobj, |
284 jint bitmap_res_id, | 297 jint bitmap_res_id, |
285 const JavaRef<jobject>& bitmap) { | 298 const JavaRef<jobject>& bitmap) { |
286 CrushedSpriteResource* resource = | 299 std::unordered_map<int, std::unique_ptr<CrushedSpriteResource>>::iterator |
287 crushed_sprite_resources_.Lookup(bitmap_res_id); | 300 item = crushed_sprite_resources_.find(bitmap_res_id); |
288 if (!resource) { | 301 if (item == crushed_sprite_resources_.end()) { |
289 // Cannot reload a resource that has not been previously loaded. | 302 // Cannot reload a resource that has not been previously loaded. |
290 return; | 303 return; |
291 } | 304 } |
292 SkBitmap skbitmap = | 305 SkBitmap skbitmap = |
293 gfx::CreateSkBitmapFromJavaBitmap(gfx::JavaBitmap(bitmap.obj())); | 306 gfx::CreateSkBitmapFromJavaBitmap(gfx::JavaBitmap(bitmap.obj())); |
294 resource->SetBitmap(skbitmap); | 307 item->second->SetBitmap(skbitmap); |
295 } | 308 } |
296 | 309 |
297 // static | 310 // static |
298 bool ResourceManagerImpl::RegisterResourceManager(JNIEnv* env) { | 311 bool ResourceManagerImpl::RegisterResourceManager(JNIEnv* env) { |
299 return RegisterNativesImpl(env); | 312 return RegisterNativesImpl(env); |
300 } | 313 } |
301 | 314 |
302 void ResourceManagerImpl::PreloadResourceFromJava(AndroidResourceType res_type, | 315 void ResourceManagerImpl::PreloadResourceFromJava(AndroidResourceType res_type, |
303 int res_id) { | 316 int res_id) { |
304 TRACE_EVENT2("ui", "ResourceManagerImpl::PreloadResourceFromJava", | 317 TRACE_EVENT2("ui", "ResourceManagerImpl::PreloadResourceFromJava", |
(...skipping 17 matching lines...) Expand all Loading... | |
322 TRACE_EVENT2("ui", | 335 TRACE_EVENT2("ui", |
323 "ResourceManagerImpl::RequestCrushedSpriteResourceFromJava", | 336 "ResourceManagerImpl::RequestCrushedSpriteResourceFromJava", |
324 "bitmap_res_id", bitmap_res_id, | 337 "bitmap_res_id", bitmap_res_id, |
325 "metadata_res_id", metadata_res_id); | 338 "metadata_res_id", metadata_res_id); |
326 Java_ResourceManager_crushedSpriteResourceRequested( | 339 Java_ResourceManager_crushedSpriteResourceRequested( |
327 base::android::AttachCurrentThread(), java_obj_, bitmap_res_id, | 340 base::android::AttachCurrentThread(), java_obj_, bitmap_res_id, |
328 metadata_res_id, reloading); | 341 metadata_res_id, reloading); |
329 } | 342 } |
330 | 343 |
331 } // namespace ui | 344 } // namespace ui |
OLD | NEW |