Replace IDMap with std::unordered_map in ResourceManager

ui/android/resources/resource_manager_impl.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/android/resources/resource_manager_impl.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 48 matching lines @@
 ResourceManagerImpl::GetJavaObject() {
   return base::android::ScopedJavaLocalRef<jobject>(java_obj_);
 }
 
 ResourceManager::Resource* ResourceManagerImpl::GetResource(
     AndroidResourceType res_type,
     int res_id) {
   DCHECK_GE(res_type, ANDROID_RESOURCE_TYPE_FIRST);
   DCHECK_LE(res_type, ANDROID_RESOURCE_TYPE_LAST);
 
-  Resource* resource = resources_[res_type].Lookup(res_id);
+  Resource* resource = nullptr;
+  if (resources_[res_type].find(res_id) != resources_[res_type].end())
+    resource = resources_[res_type][res_id].get();
 
   if (!resource || res_type == ANDROID_RESOURCE_TYPE_DYNAMIC ||
       res_type == ANDROID_RESOURCE_TYPE_DYNAMIC_BITMAP) {
     RequestResourceFromJava(res_type, res_id);
-    resource = resources_[res_type].Lookup(res_id);
+    resource = resources_[res_type][res_id].get();
   }
 
   return resource;
 }
 
 void ResourceManagerImpl::RemoveUnusedTints(
     const std::unordered_set<int>& used_tints) {
   // Iterate over the currently cached tints and remove ones that were not
   // used as defined in |used_tints|.
   for (auto it = tinted_resources_.cbegin(); it != tinted_resources_.cend();) {
     if (used_tints.find(it->first) == used_tints.end()) {
         it = tinted_resources_.erase(it);
     } else {
         ++it;
     }
   }
 }
 
 ResourceManager::Resource* ResourceManagerImpl::GetStaticResourceWithTint(
     int res_id,
-    int tint_color) {
+    SkColor tint_color) {
   if (tinted_resources_.find(tint_color) == tinted_resources_.end()) {
     tinted_resources_[tint_color] = base::MakeUnique<ResourceMap>();
   }
   ResourceMap* resource_map = tinted_resources_[tint_color].get();
 
-  Resource* tinted_resource = resource_map->Lookup(res_id);
+  // If the resource is already cached, use it.
+  std::unordered_map<int, std::unique_ptr<Resource>>::iterator item =
+      resource_map->find(res_id);
+  if (item != resource_map->end())
+    return item->second.get();
 
-  // If the resource is already cached, use it.
-  if (tinted_resource)
-    return tinted_resource;
-
-  tinted_resource = new Resource();
+  std::unique_ptr<Resource> tinted_resource = base::MakeUnique<Resource>();
 
   ResourceManager::Resource* base_image =
       GetResource(ANDROID_RESOURCE_TYPE_STATIC, res_id);
   DCHECK(base_image);
 
   TRACE_EVENT0("browser", "ResourceManagerImpl::GetStaticResourceWithTint");
   SkBitmap tinted_bitmap;
   tinted_bitmap.allocPixels(SkImageInfo::MakeN32Premul(base_image->size.width(),
       base_image->size.height()));
 
   SkCanvas canvas(tinted_bitmap);
   canvas.clear(SK_ColorTRANSPARENT);
 
   // Build a color filter to use on the base resource. This filter multiplies
   // the RGB components by the components of the new color but retains the
   // alpha of the original image.
   SkPaint color_filter;
   color_filter.setColorFilter(
       SkColorFilter::MakeModeFilter(tint_color, SkXfermode::kModulate_Mode));
 
   // Draw the resource and make it immutable.
   base_image->ui_resource->GetBitmap(base_image->ui_resource->id(), false)
       .DrawToCanvas(&canvas, &color_filter);
   tinted_bitmap.setImmutable();
 
   // Create a UI resource from the new bitmap.
-  tinted_resource = new Resource();
   tinted_resource->size = gfx::Size(base_image->size);
   tinted_resource->padding = gfx::Rect(base_image->padding);
   tinted_resource->aperture = gfx::Rect(base_image->aperture);
   tinted_resource->ui_resource = cc::ScopedUIResource::Create(host_,
       cc::UIResourceBitmap(tinted_bitmap));
 
-  resource_map->AddWithID(tinted_resource, res_id);
+  (*resource_map)[res_id].swap(tinted_resource);
 
-  return tinted_resource;
+  return (*resource_map)[res_id].get();
 }
 
 void ResourceManagerImpl::ClearTintedResourceCache(JNIEnv* env,
     const JavaRef<jobject>& jobj) {
   tinted_resources_.clear();
 }
 
 void ResourceManagerImpl::PreloadResource(AndroidResourceType res_type,
                                           int res_id) {
   DCHECK_GE(res_type, ANDROID_RESOURCE_TYPE_FIRST);
   DCHECK_LE(res_type, ANDROID_RESOURCE_TYPE_LAST);
 
   // Don't send out a query if the resource is already loaded.
-  if (resources_[res_type].Lookup(res_id))
+  if (resources_[res_type].find(res_id) != resources_[res_type].end())
     return;
 
   PreloadResourceFromJava(res_type, res_id);
 }
 
 void ResourceManagerImpl::OnResourceReady(JNIEnv* env,
                                           const JavaRef<jobject>& jobj,
                                           jint res_type,
                                           jint res_id,
                                           const JavaRef<jobject>& bitmap,
                                           jint padding_left,
                                           jint padding_top,
                                           jint padding_right,
                                           jint padding_bottom,
                                           jint aperture_left,
                                           jint aperture_top,
                                           jint aperture_right,
                                           jint aperture_bottom) {
   DCHECK_GE(res_type, ANDROID_RESOURCE_TYPE_FIRST);
   DCHECK_LE(res_type, ANDROID_RESOURCE_TYPE_LAST);
   TRACE_EVENT2("ui", "ResourceManagerImpl::OnResourceReady",
                "resource_type", res_type,
                "resource_id", res_id);
 
-  Resource* resource = resources_[res_type].Lookup(res_id);
-  if (!resource) {
-    resource = new Resource();
-    resources_[res_type].AddWithID(resource, res_id);
+  std::unordered_map<int, std::unique_ptr<Resource>>::iterator item =
+      resources_[res_type].find(res_id);
+  if (item == resources_[res_type].end()) {
+    resources_[res_type][res_id] = base::MakeUnique<Resource>();

[mdjones, 2016/09/12 16:55:09]

I think you wanted my to use "item" here to reset the value stored at that
location (and update it further down), right? I was having a lot of trouble with
the ownership semantics here.

   }
 
+  Resource* resource = resources_[res_type][res_id].get();
+
   gfx::JavaBitmap jbitmap(bitmap.obj());
   resource->size = jbitmap.size();
   resource->padding.SetRect(padding_left, padding_top,
                             padding_right - padding_left,
                             padding_bottom - padding_top);
   resource->aperture.SetRect(aperture_left, aperture_top,
                              aperture_right - aperture_left,
                              aperture_bottom - aperture_top);
 
   SkBitmap skbitmap = gfx::CreateSkBitmapFromJavaBitmap(jbitmap);
   skbitmap.setImmutable();
   resource->ui_resource =
       cc::ScopedUIResource::Create(host_, cc::UIResourceBitmap(skbitmap));
 }
 
 CrushedSpriteResource* ResourceManagerImpl::GetCrushedSpriteResource(
     int bitmap_res_id, int metadata_res_id) {
-  CrushedSpriteResource* resource =
-      crushed_sprite_resources_.Lookup(bitmap_res_id);
+
+  CrushedSpriteResource* resource = nullptr;
+  if (crushed_sprite_resources_.find(bitmap_res_id)
+      != crushed_sprite_resources_.end()) {
+    resource = crushed_sprite_resources_[bitmap_res_id].get();
+  }
+
   if (!resource) {
     RequestCrushedSpriteResourceFromJava(bitmap_res_id, metadata_res_id, false);
-    resource = crushed_sprite_resources_.Lookup(bitmap_res_id);
+    resource = crushed_sprite_resources_[bitmap_res_id].get();
   } else if (resource->BitmapHasBeenEvictedFromMemory()) {
     RequestCrushedSpriteResourceFromJava(bitmap_res_id, metadata_res_id, true);
   }
 
   return resource;
 }
 
 void ResourceManagerImpl::OnCrushedSpriteResourceReady(
     JNIEnv* env,
     const JavaRef<jobject>& jobj,
     jint bitmap_res_id,
     const JavaRef<jobject>& bitmap,
     const JavaRef<jobjectArray>& frame_rects,
     jint unscaled_sprite_width,
     jint unscaled_sprite_height,
     jfloat scaled_sprite_width,
     jfloat scaled_sprite_height) {
   // Construct source and destination rectangles for each frame from
   // |frame_rects|.
   std::vector<std::vector<int>> all_frame_rects_vector;
   JavaArrayOfIntArrayToIntVector(env, frame_rects.obj(),
                                  &all_frame_rects_vector);
   CrushedSpriteResource::SrcDstRects src_dst_rects =
       ProcessCrushedSpriteFrameRects(all_frame_rects_vector);
 
   SkBitmap skbitmap =
       gfx::CreateSkBitmapFromJavaBitmap(gfx::JavaBitmap(bitmap.obj()));
 
-  CrushedSpriteResource* resource = new CrushedSpriteResource(
-      skbitmap,
-      src_dst_rects,
-      gfx::Size(unscaled_sprite_width, unscaled_sprite_height),
-      gfx::Size(scaled_sprite_width, scaled_sprite_height));
+  std::unique_ptr<CrushedSpriteResource> resource =
+      base::MakeUnique<CrushedSpriteResource>(
+          skbitmap,
+          src_dst_rects,
+          gfx::Size(unscaled_sprite_width, unscaled_sprite_height),
+          gfx::Size(scaled_sprite_width, scaled_sprite_height));
 
-  if (crushed_sprite_resources_.Lookup(bitmap_res_id)) {
-    crushed_sprite_resources_.Replace(bitmap_res_id, resource);
-  } else {
-    crushed_sprite_resources_.AddWithID(resource, bitmap_res_id);
-  }
+  crushed_sprite_resources_[bitmap_res_id].swap(resource);
 }
 
 CrushedSpriteResource::SrcDstRects
 ResourceManagerImpl::ProcessCrushedSpriteFrameRects(
     std::vector<std::vector<int>> frame_rects_vector) {
   CrushedSpriteResource::SrcDstRects src_dst_rects;
   for (size_t i = 0; i < frame_rects_vector.size(); ++i) {
     std::vector<int> frame_ints = frame_rects_vector[i];
     CrushedSpriteResource::FrameSrcDstRects frame_src_dst_rects;
 
@@ skipping 16 matching lines @@
     src_dst_rects.push_back(frame_src_dst_rects);
   }
   return src_dst_rects;
 }
 
 void ResourceManagerImpl::OnCrushedSpriteResourceReloaded(
     JNIEnv* env,
     const JavaRef<jobject>& jobj,
     jint bitmap_res_id,
     const JavaRef<jobject>& bitmap) {
-  CrushedSpriteResource* resource =
-      crushed_sprite_resources_.Lookup(bitmap_res_id);
-  if (!resource) {
+  std::unordered_map<int, std::unique_ptr<CrushedSpriteResource>>::iterator
+      item = crushed_sprite_resources_.find(bitmap_res_id);
+  if (item == crushed_sprite_resources_.end()) {
     // Cannot reload a resource that has not been previously loaded.
     return;
   }
   SkBitmap skbitmap =
       gfx::CreateSkBitmapFromJavaBitmap(gfx::JavaBitmap(bitmap.obj()));
-  resource->SetBitmap(skbitmap);
+  item->second->SetBitmap(skbitmap);
 }
 
 // static
 bool ResourceManagerImpl::RegisterResourceManager(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 void ResourceManagerImpl::PreloadResourceFromJava(AndroidResourceType res_type,
                                                   int res_id) {
   TRACE_EVENT2("ui", "ResourceManagerImpl::PreloadResourceFromJava",
@@ skipping 17 matching lines @@
   TRACE_EVENT2("ui",
                "ResourceManagerImpl::RequestCrushedSpriteResourceFromJava",
                "bitmap_res_id", bitmap_res_id,
                "metadata_res_id", metadata_res_id);
   Java_ResourceManager_crushedSpriteResourceRequested(
       base::android::AttachCurrentThread(), java_obj_, bitmap_res_id,
       metadata_res_id, reloading);
 }
 
 }  // namespace ui