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

Side by Side Diff: ui/android/resources/resource_manager_impl.cc

Issue 2325623003: Replace IDMap with std::unordered_map in ResourceManager (Closed)
Patch Set: Created 4 years, 3 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
OLDNEW
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
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
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
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
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
OLDNEW
« ui/android/resources/resource_manager_impl.h ('K') | « ui/android/resources/resource_manager_impl.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698