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 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
59 ResourceManagerImpl::GetJavaObject() { | 59 ResourceManagerImpl::GetJavaObject() { |
60 return base::android::ScopedJavaLocalRef<jobject>(java_obj_); | 60 return base::android::ScopedJavaLocalRef<jobject>(java_obj_); |
61 } | 61 } |
62 | 62 |
63 ResourceManager::Resource* ResourceManagerImpl::GetResource( | 63 ResourceManager::Resource* ResourceManagerImpl::GetResource( |
64 AndroidResourceType res_type, | 64 AndroidResourceType res_type, |
65 int res_id) { | 65 int res_id) { |
66 DCHECK_GE(res_type, ANDROID_RESOURCE_TYPE_FIRST); | 66 DCHECK_GE(res_type, ANDROID_RESOURCE_TYPE_FIRST); |
67 DCHECK_LE(res_type, ANDROID_RESOURCE_TYPE_LAST); | 67 DCHECK_LE(res_type, ANDROID_RESOURCE_TYPE_LAST); |
68 | 68 |
69 Resource* resource = resources_[res_type].Lookup(res_id); | 69 Resource* resource = nullptr; |
70 if (resources_[res_type].find(res_id) != resources_[res_type].end()) { | |
71 resource = resources_[res_type][res_id].get(); | |
72 } | |
70 | 73 |
71 if (!resource || res_type == ANDROID_RESOURCE_TYPE_DYNAMIC || | 74 if (!resource || res_type == ANDROID_RESOURCE_TYPE_DYNAMIC || |
72 res_type == ANDROID_RESOURCE_TYPE_DYNAMIC_BITMAP) { | 75 res_type == ANDROID_RESOURCE_TYPE_DYNAMIC_BITMAP) { |
73 RequestResourceFromJava(res_type, res_id); | 76 RequestResourceFromJava(res_type, res_id); |
74 resource = resources_[res_type].Lookup(res_id); | 77 resource = resources_[res_type][res_id].get(); |
75 } | 78 } |
76 | 79 |
77 return resource; | 80 return resource; |
78 } | 81 } |
79 | 82 |
80 void ResourceManagerImpl::RemoveUnusedTints( | 83 void ResourceManagerImpl::RemoveUnusedTints( |
81 const std::unordered_set<int>& used_tints) { | 84 const std::unordered_set<int>& used_tints) { |
82 // Iterate over the currently cached tints and remove ones that were not | 85 // Iterate over the currently cached tints and remove ones that were not |
83 // used as defined in |used_tints|. | 86 // used as defined in |used_tints|. |
84 for (auto it = tinted_resources_.cbegin(); it != tinted_resources_.cend();) { | 87 for (auto it = tinted_resources_.cbegin(); it != tinted_resources_.cend();) { |
85 if (used_tints.find(it->first) == used_tints.end()) { | 88 if (used_tints.find(it->first) == used_tints.end()) { |
86 it = tinted_resources_.erase(it); | 89 it = tinted_resources_.erase(it); |
87 } else { | 90 } else { |
88 ++it; | 91 ++it; |
89 } | 92 } |
90 } | 93 } |
91 } | 94 } |
92 | 95 |
93 ResourceManager::Resource* ResourceManagerImpl::GetStaticResourceWithTint( | 96 ResourceManager::Resource* ResourceManagerImpl::GetStaticResourceWithTint( |
94 int res_id, | 97 int res_id, |
95 int tint_color) { | 98 int tint_color) { |
96 if (tinted_resources_.find(tint_color) == tinted_resources_.end()) { | 99 if (tinted_resources_.find(tint_color) == tinted_resources_.end()) { |
97 tinted_resources_[tint_color] = base::MakeUnique<ResourceMap>(); | 100 tinted_resources_[tint_color] = base::MakeUnique<ResourceMap>(); |
98 } | 101 } |
99 ResourceMap* resource_map = tinted_resources_[tint_color].get(); | 102 ResourceMap* resource_map = tinted_resources_[tint_color].get(); |
100 | 103 |
101 Resource* tinted_resource = resource_map->Lookup(res_id); | 104 // If the resource is already cached, use it. |
105 if (resource_map->find(res_id) != resource_map->end()) | |
106 return (*resource_map)[res_id].get(); | |
102 | 107 |
103 // If the resource is already cached, use it. | 108 Resource* tinted_resource = new Resource(); |
aelias_OOO_until_Jul13
2016/09/08 22:05:01
Can you switch this local variable to a unique_ptr
mdjones
2016/09/09 16:47:23
Done.
| |
104 if (tinted_resource) | |
105 return tinted_resource; | |
106 | 109 |
107 tinted_resource = new Resource(); | 110 tinted_resource = new Resource(); |
108 | 111 |
109 ResourceManager::Resource* base_image = | 112 ResourceManager::Resource* base_image = |
110 GetResource(ANDROID_RESOURCE_TYPE_STATIC, res_id); | 113 GetResource(ANDROID_RESOURCE_TYPE_STATIC, res_id); |
111 DCHECK(base_image); | 114 DCHECK(base_image); |
112 | 115 |
113 TRACE_EVENT0("browser", "ResourceManagerImpl::GetStaticResourceWithTint"); | 116 TRACE_EVENT0("browser", "ResourceManagerImpl::GetStaticResourceWithTint"); |
114 SkBitmap tinted_bitmap; | 117 SkBitmap tinted_bitmap; |
115 tinted_bitmap.allocPixels(SkImageInfo::MakeN32Premul(base_image->size.width(), | 118 tinted_bitmap.allocPixels(SkImageInfo::MakeN32Premul(base_image->size.width(), |
(...skipping 15 matching lines...) Expand all Loading... | |
131 tinted_bitmap.setImmutable(); | 134 tinted_bitmap.setImmutable(); |
132 | 135 |
133 // Create a UI resource from the new bitmap. | 136 // Create a UI resource from the new bitmap. |
134 tinted_resource = new Resource(); | 137 tinted_resource = new Resource(); |
135 tinted_resource->size = gfx::Size(base_image->size); | 138 tinted_resource->size = gfx::Size(base_image->size); |
136 tinted_resource->padding = gfx::Rect(base_image->padding); | 139 tinted_resource->padding = gfx::Rect(base_image->padding); |
137 tinted_resource->aperture = gfx::Rect(base_image->aperture); | 140 tinted_resource->aperture = gfx::Rect(base_image->aperture); |
138 tinted_resource->ui_resource = cc::ScopedUIResource::Create(host_, | 141 tinted_resource->ui_resource = cc::ScopedUIResource::Create(host_, |
139 cc::UIResourceBitmap(tinted_bitmap)); | 142 cc::UIResourceBitmap(tinted_bitmap)); |
140 | 143 |
141 resource_map->AddWithID(tinted_resource, res_id); | 144 (*resource_map)[res_id] = base::WrapUnique<Resource>(tinted_resource); |
142 | 145 |
143 return tinted_resource; | 146 return tinted_resource; |
144 } | 147 } |
145 | 148 |
146 void ResourceManagerImpl::ClearTintedResourceCache(JNIEnv* env, | 149 void ResourceManagerImpl::ClearTintedResourceCache(JNIEnv* env, |
147 const JavaRef<jobject>& jobj) { | 150 const JavaRef<jobject>& jobj) { |
148 tinted_resources_.clear(); | 151 tinted_resources_.clear(); |
149 } | 152 } |
150 | 153 |
151 void ResourceManagerImpl::PreloadResource(AndroidResourceType res_type, | 154 void ResourceManagerImpl::PreloadResource(AndroidResourceType res_type, |
152 int res_id) { | 155 int res_id) { |
153 DCHECK_GE(res_type, ANDROID_RESOURCE_TYPE_FIRST); | 156 DCHECK_GE(res_type, ANDROID_RESOURCE_TYPE_FIRST); |
154 DCHECK_LE(res_type, ANDROID_RESOURCE_TYPE_LAST); | 157 DCHECK_LE(res_type, ANDROID_RESOURCE_TYPE_LAST); |
155 | 158 |
156 // Don't send out a query if the resource is already loaded. | 159 // Don't send out a query if the resource is already loaded. |
157 if (resources_[res_type].Lookup(res_id)) | 160 if (resources_[res_type].find(res_id) != resources_[res_type].end()) |
158 return; | 161 return; |
159 | 162 |
160 PreloadResourceFromJava(res_type, res_id); | 163 PreloadResourceFromJava(res_type, res_id); |
161 } | 164 } |
162 | 165 |
163 void ResourceManagerImpl::OnResourceReady(JNIEnv* env, | 166 void ResourceManagerImpl::OnResourceReady(JNIEnv* env, |
164 const JavaRef<jobject>& jobj, | 167 const JavaRef<jobject>& jobj, |
165 jint res_type, | 168 jint res_type, |
166 jint res_id, | 169 jint res_id, |
167 const JavaRef<jobject>& bitmap, | 170 const JavaRef<jobject>& bitmap, |
168 jint padding_left, | 171 jint padding_left, |
169 jint padding_top, | 172 jint padding_top, |
170 jint padding_right, | 173 jint padding_right, |
171 jint padding_bottom, | 174 jint padding_bottom, |
172 jint aperture_left, | 175 jint aperture_left, |
173 jint aperture_top, | 176 jint aperture_top, |
174 jint aperture_right, | 177 jint aperture_right, |
175 jint aperture_bottom) { | 178 jint aperture_bottom) { |
176 DCHECK_GE(res_type, ANDROID_RESOURCE_TYPE_FIRST); | 179 DCHECK_GE(res_type, ANDROID_RESOURCE_TYPE_FIRST); |
177 DCHECK_LE(res_type, ANDROID_RESOURCE_TYPE_LAST); | 180 DCHECK_LE(res_type, ANDROID_RESOURCE_TYPE_LAST); |
178 TRACE_EVENT2("ui", "ResourceManagerImpl::OnResourceReady", | 181 TRACE_EVENT2("ui", "ResourceManagerImpl::OnResourceReady", |
179 "resource_type", res_type, | 182 "resource_type", res_type, |
180 "resource_id", res_id); | 183 "resource_id", res_id); |
181 | 184 |
182 | 185 Resource* resource = nullptr; |
183 Resource* resource = resources_[res_type].Lookup(res_id); | 186 if (resources_[res_type].find(res_id) == resources_[res_type].end()) { |
184 if (!resource) { | |
185 resource = new Resource(); | 187 resource = new Resource(); |
186 resources_[res_type].AddWithID(resource, res_id); | 188 resources_[res_type][res_id] = base::WrapUnique<Resource>(resource); |
189 } else { | |
190 resource = resources_[res_type][res_id].get(); | |
187 } | 191 } |
188 | 192 |
189 gfx::JavaBitmap jbitmap(bitmap.obj()); | 193 gfx::JavaBitmap jbitmap(bitmap.obj()); |
190 resource->size = jbitmap.size(); | 194 resource->size = jbitmap.size(); |
191 resource->padding.SetRect(padding_left, padding_top, | 195 resource->padding.SetRect(padding_left, padding_top, |
192 padding_right - padding_left, | 196 padding_right - padding_left, |
193 padding_bottom - padding_top); | 197 padding_bottom - padding_top); |
194 resource->aperture.SetRect(aperture_left, aperture_top, | 198 resource->aperture.SetRect(aperture_left, aperture_top, |
195 aperture_right - aperture_left, | 199 aperture_right - aperture_left, |
196 aperture_bottom - aperture_top); | 200 aperture_bottom - aperture_top); |
197 | 201 |
198 SkBitmap skbitmap = gfx::CreateSkBitmapFromJavaBitmap(jbitmap); | 202 SkBitmap skbitmap = gfx::CreateSkBitmapFromJavaBitmap(jbitmap); |
199 skbitmap.setImmutable(); | 203 skbitmap.setImmutable(); |
200 resource->ui_resource = | 204 resource->ui_resource = |
201 cc::ScopedUIResource::Create(host_, cc::UIResourceBitmap(skbitmap)); | 205 cc::ScopedUIResource::Create(host_, cc::UIResourceBitmap(skbitmap)); |
202 } | 206 } |
203 | 207 |
204 CrushedSpriteResource* ResourceManagerImpl::GetCrushedSpriteResource( | 208 CrushedSpriteResource* ResourceManagerImpl::GetCrushedSpriteResource( |
205 int bitmap_res_id, int metadata_res_id) { | 209 int bitmap_res_id, int metadata_res_id) { |
206 CrushedSpriteResource* resource = | 210 |
207 crushed_sprite_resources_.Lookup(bitmap_res_id); | 211 CrushedSpriteResource* resource = nullptr; |
212 if (crushed_sprite_resources_.find(bitmap_res_id) | |
213 != crushed_sprite_resources_.end()) { | |
214 resource = crushed_sprite_resources_[bitmap_res_id].get(); | |
215 } | |
216 | |
208 if (!resource) { | 217 if (!resource) { |
209 RequestCrushedSpriteResourceFromJava(bitmap_res_id, metadata_res_id, false); | 218 RequestCrushedSpriteResourceFromJava(bitmap_res_id, metadata_res_id, false); |
210 resource = crushed_sprite_resources_.Lookup(bitmap_res_id); | 219 resource = crushed_sprite_resources_[bitmap_res_id].get(); |
211 } else if (resource->BitmapHasBeenEvictedFromMemory()) { | 220 } else if (resource->BitmapHasBeenEvictedFromMemory()) { |
212 RequestCrushedSpriteResourceFromJava(bitmap_res_id, metadata_res_id, true); | 221 RequestCrushedSpriteResourceFromJava(bitmap_res_id, metadata_res_id, true); |
213 } | 222 } |
214 | 223 |
215 return resource; | 224 return resource; |
216 } | 225 } |
217 | 226 |
218 void ResourceManagerImpl::OnCrushedSpriteResourceReady( | 227 void ResourceManagerImpl::OnCrushedSpriteResourceReady( |
219 JNIEnv* env, | 228 JNIEnv* env, |
220 const JavaRef<jobject>& jobj, | 229 const JavaRef<jobject>& jobj, |
221 jint bitmap_res_id, | 230 jint bitmap_res_id, |
222 const JavaRef<jobject>& bitmap, | 231 const JavaRef<jobject>& bitmap, |
223 const JavaRef<jobjectArray>& frame_rects, | 232 const JavaRef<jobjectArray>& frame_rects, |
224 jint unscaled_sprite_width, | 233 jint unscaled_sprite_width, |
225 jint unscaled_sprite_height, | 234 jint unscaled_sprite_height, |
226 jfloat scaled_sprite_width, | 235 jfloat scaled_sprite_width, |
227 jfloat scaled_sprite_height) { | 236 jfloat scaled_sprite_height) { |
228 // Construct source and destination rectangles for each frame from | 237 // Construct source and destination rectangles for each frame from |
229 // |frame_rects|. | 238 // |frame_rects|. |
230 std::vector<std::vector<int>> all_frame_rects_vector; | 239 std::vector<std::vector<int>> all_frame_rects_vector; |
231 JavaArrayOfIntArrayToIntVector(env, frame_rects.obj(), | 240 JavaArrayOfIntArrayToIntVector(env, frame_rects.obj(), |
232 &all_frame_rects_vector); | 241 &all_frame_rects_vector); |
233 CrushedSpriteResource::SrcDstRects src_dst_rects = | 242 CrushedSpriteResource::SrcDstRects src_dst_rects = |
234 ProcessCrushedSpriteFrameRects(all_frame_rects_vector); | 243 ProcessCrushedSpriteFrameRects(all_frame_rects_vector); |
235 | 244 |
236 SkBitmap skbitmap = | 245 SkBitmap skbitmap = |
237 gfx::CreateSkBitmapFromJavaBitmap(gfx::JavaBitmap(bitmap.obj())); | 246 gfx::CreateSkBitmapFromJavaBitmap(gfx::JavaBitmap(bitmap.obj())); |
238 | 247 |
239 CrushedSpriteResource* resource = new CrushedSpriteResource( | 248 CrushedSpriteResource* resource = new CrushedSpriteResource( |
David Trainor- moved to gerrit
2016/09/09 06:11:32
+1 to what Alex said. Just use MakeUnique<>(...)
mdjones
2016/09/09 16:47:23
Done.
| |
240 skbitmap, | 249 skbitmap, |
241 src_dst_rects, | 250 src_dst_rects, |
242 gfx::Size(unscaled_sprite_width, unscaled_sprite_height), | 251 gfx::Size(unscaled_sprite_width, unscaled_sprite_height), |
243 gfx::Size(scaled_sprite_width, scaled_sprite_height)); | 252 gfx::Size(scaled_sprite_width, scaled_sprite_height)); |
244 | 253 |
245 if (crushed_sprite_resources_.Lookup(bitmap_res_id)) { | 254 crushed_sprite_resources_[bitmap_res_id] = |
David Trainor- moved to gerrit
2016/09/09 06:11:32
Indenting looks off
mdjones
2016/09/09 16:47:23
Done.
| |
246 crushed_sprite_resources_.Replace(bitmap_res_id, resource); | 255 base::WrapUnique<CrushedSpriteResource>(resource); |
247 } else { | |
248 crushed_sprite_resources_.AddWithID(resource, bitmap_res_id); | |
249 } | |
250 } | 256 } |
251 | 257 |
252 CrushedSpriteResource::SrcDstRects | 258 CrushedSpriteResource::SrcDstRects |
253 ResourceManagerImpl::ProcessCrushedSpriteFrameRects( | 259 ResourceManagerImpl::ProcessCrushedSpriteFrameRects( |
254 std::vector<std::vector<int>> frame_rects_vector) { | 260 std::vector<std::vector<int>> frame_rects_vector) { |
255 CrushedSpriteResource::SrcDstRects src_dst_rects; | 261 CrushedSpriteResource::SrcDstRects src_dst_rects; |
256 for (size_t i = 0; i < frame_rects_vector.size(); ++i) { | 262 for (size_t i = 0; i < frame_rects_vector.size(); ++i) { |
257 std::vector<int> frame_ints = frame_rects_vector[i]; | 263 std::vector<int> frame_ints = frame_rects_vector[i]; |
258 CrushedSpriteResource::FrameSrcDstRects frame_src_dst_rects; | 264 CrushedSpriteResource::FrameSrcDstRects frame_src_dst_rects; |
259 | 265 |
(...skipping 16 matching lines...) Expand all Loading... | |
276 src_dst_rects.push_back(frame_src_dst_rects); | 282 src_dst_rects.push_back(frame_src_dst_rects); |
277 } | 283 } |
278 return src_dst_rects; | 284 return src_dst_rects; |
279 } | 285 } |
280 | 286 |
281 void ResourceManagerImpl::OnCrushedSpriteResourceReloaded( | 287 void ResourceManagerImpl::OnCrushedSpriteResourceReloaded( |
282 JNIEnv* env, | 288 JNIEnv* env, |
283 const JavaRef<jobject>& jobj, | 289 const JavaRef<jobject>& jobj, |
284 jint bitmap_res_id, | 290 jint bitmap_res_id, |
285 const JavaRef<jobject>& bitmap) { | 291 const JavaRef<jobject>& bitmap) { |
286 CrushedSpriteResource* resource = | 292 if (crushed_sprite_resources_.find(bitmap_res_id) |
287 crushed_sprite_resources_.Lookup(bitmap_res_id); | 293 == crushed_sprite_resources_.end()) { |
288 if (!resource) { | |
289 // Cannot reload a resource that has not been previously loaded. | 294 // Cannot reload a resource that has not been previously loaded. |
290 return; | 295 return; |
291 } | 296 } |
297 CrushedSpriteResource* resource = | |
298 crushed_sprite_resources_[bitmap_res_id].get(); | |
292 SkBitmap skbitmap = | 299 SkBitmap skbitmap = |
293 gfx::CreateSkBitmapFromJavaBitmap(gfx::JavaBitmap(bitmap.obj())); | 300 gfx::CreateSkBitmapFromJavaBitmap(gfx::JavaBitmap(bitmap.obj())); |
294 resource->SetBitmap(skbitmap); | 301 resource->SetBitmap(skbitmap); |
295 } | 302 } |
296 | 303 |
297 // static | 304 // static |
298 bool ResourceManagerImpl::RegisterResourceManager(JNIEnv* env) { | 305 bool ResourceManagerImpl::RegisterResourceManager(JNIEnv* env) { |
299 return RegisterNativesImpl(env); | 306 return RegisterNativesImpl(env); |
300 } | 307 } |
301 | 308 |
(...skipping 20 matching lines...) Expand all Loading... | |
322 TRACE_EVENT2("ui", | 329 TRACE_EVENT2("ui", |
323 "ResourceManagerImpl::RequestCrushedSpriteResourceFromJava", | 330 "ResourceManagerImpl::RequestCrushedSpriteResourceFromJava", |
324 "bitmap_res_id", bitmap_res_id, | 331 "bitmap_res_id", bitmap_res_id, |
325 "metadata_res_id", metadata_res_id); | 332 "metadata_res_id", metadata_res_id); |
326 Java_ResourceManager_crushedSpriteResourceRequested( | 333 Java_ResourceManager_crushedSpriteResourceRequested( |
327 base::android::AttachCurrentThread(), java_obj_, bitmap_res_id, | 334 base::android::AttachCurrentThread(), java_obj_, bitmap_res_id, |
328 metadata_res_id, reloading); | 335 metadata_res_id, reloading); |
329 } | 336 } |
330 | 337 |
331 } // namespace ui | 338 } // namespace ui |
OLD | NEW |