ui/android: Fix Resource meta-data sharing with 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 <inttypes.h>
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
 
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/memory_usage_estimator.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/resources/scoped_ui_resource.h"
 #include "cc/resources/ui_resource_manager.h"
 #include "jni/ResourceManager_jni.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
+#include "ui/android/resources/nine_patch_resource.h"
 #include "ui/android/resources/ui_resource_provider.h"
 #include "ui/android/window_android.h"
 #include "ui/gfx/android/java_bitmap.h"
 #include "ui/gfx/geometry/rect.h"
 
 using base::android::JavaArrayOfIntArrayToIntVector;
+using base::android::JavaParamRef;
 using base::android::JavaRef;
 
 namespace ui {
 
 // static
 ResourceManagerImpl* ResourceManagerImpl::FromJavaObject(
     const JavaRef<jobject>& jobj) {
   return reinterpret_cast<ResourceManagerImpl*>(
       Java_ResourceManager_getNativePtr(base::android::AttachCurrentThread(),
                                         jobj));
@@ skipping 22 matching lines @@
   DCHECK(!ui_resource_manager_);
   DCHECK(ui_resource_manager);
   ui_resource_manager_ = ui_resource_manager;
 }
 
 base::android::ScopedJavaLocalRef<jobject>
 ResourceManagerImpl::GetJavaObject() {
   return base::android::ScopedJavaLocalRef<jobject>(java_obj_);
 }
 
-ResourceManager::Resource* ResourceManagerImpl::GetResource(
-    AndroidResourceType res_type,
-    int res_id) {
+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);
 
   std::unordered_map<int, std::unique_ptr<Resource>>::iterator item =
       resources_[res_type].find(res_id);
 
   if (item == resources_[res_type].end() ||
       res_type == ANDROID_RESOURCE_TYPE_DYNAMIC ||
       res_type == ANDROID_RESOURCE_TYPE_DYNAMIC_BITMAP) {
     RequestResourceFromJava(res_type, res_id);
@@ skipping 13 matching lines @@
   // 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,
-    SkColor tint_color) {
+Resource* ResourceManagerImpl::GetStaticResourceWithTint(int res_id,
+                                                         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();
 
   // 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();
 
-  std::unique_ptr<Resource> tinted_resource = base::MakeUnique<Resource>();
+  Resource* base_image = GetResource(ANDROID_RESOURCE_TYPE_STATIC, res_id);
+  DCHECK(base_image);
 
-  ResourceManager::Resource* base_image =
-      GetResource(ANDROID_RESOURCE_TYPE_STATIC, res_id);
-  DCHECK(base_image);
+  std::unique_ptr<Resource> tinted_resource = base_image->CreateForCopy();
 
   TRACE_EVENT0("browser", "ResourceManagerImpl::GetStaticResourceWithTint");
   SkBitmap tinted_bitmap;
-  tinted_bitmap.allocPixels(SkImageInfo::MakeN32Premul(base_image->size.width(),
-      base_image->size.height()));
+  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, SkBlendMode::kModulate));
 
   // Draw the resource and make it immutable.
-  base_image->ui_resource->GetBitmap(base_image->ui_resource->id(), false)
+  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->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(
-      ui_resource_manager_, cc::UIResourceBitmap(tinted_bitmap));
+  tinted_resource->SetUIResource(
+      cc::ScopedUIResource::Create(ui_resource_manager_,
+                                   cc::UIResourceBitmap(tinted_bitmap)),
+      base_image->size());
 
   (*resource_map)[res_id].swap(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].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) {
+                                          jlong native_resource) {
   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);
 
-  std::unordered_map<int, std::unique_ptr<Resource>>::iterator item =
-      resources_[res_type].find(res_id);
-  if (item == resources_[res_type].end()) {

[Khushal, 2017/03/09 23:05:37]

I was worried about making repeated dynamic allocations here now. But I am
assuming this was only avoiding it for the case where a dynamic resource is
updated, which should be rare?

[mdjones, 2017/03/10 18:12:00]

Dynamic resources use the same id when they are updated which is pretty often.
Tab titles are a good example. However, the bulk of the allocation happens in
the bitmap creation logic below which happens regardless of this.

[Khushal, 2017/03/10 19:19:24]

True, and I assumed these updates are quite rare. Like the toolbar will be
invalidated and updated only when the text changes, right?

[mdjones, 2017/03/13 16:47:06]

Right, we shouldn't have to worry about this.

-    resources_[res_type][res_id] = base::MakeUnique<Resource>();
-  }
-
+  resources_[res_type][res_id] =
+      base::WrapUnique(reinterpret_cast<Resource*>(native_resource));
   Resource* resource = resources_[res_type][res_id].get();
 
   gfx::JavaBitmap jbitmap(bitmap);
-  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(
-      ui_resource_manager_, cc::UIResourceBitmap(skbitmap));
+  resource->SetUIResource(
+      cc::ScopedUIResource::Create(ui_resource_manager_,
+                                   cc::UIResourceBitmap(skbitmap)),
+      jbitmap.size());
 }
 
 void ResourceManagerImpl::RemoveResource(
     JNIEnv* env,
     const base::android::JavaRef<jobject>& jobj,
     jint res_type,
     jint res_id) {
   resources_[res_type].erase(res_id);
 }
 
@@ skipping 144 matching lines @@
     int bitmap_res_id, int metadata_res_id, bool reloading) {
   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);
 }
 
+jlong CreateBitmapResource(JNIEnv* env, const JavaParamRef<jclass>& clazz) {
+  return reinterpret_cast<intptr_t>(new Resource());
+}
+
+jlong CreateNinePatchBitmapResource(JNIEnv* env,
+                                    const JavaParamRef<jclass>& clazz,
+                                    jint padding_left,
+                                    jint padding_top,
+                                    jint padding_right,
+                                    jint padding_bottom,
+                                    jint aperture_left,
+                                    jint aperture_top,
+                                    jint aperture_right,
+                                    jint aperture_bottom) {
+  gfx::Rect padding(padding_left, padding_top, padding_right - padding_left,
+                    padding_bottom - padding_top);
+  gfx::Rect aperture(aperture_left, aperture_top,
+                     aperture_right - aperture_left,
+                     aperture_bottom - aperture_top);
+  return reinterpret_cast<intptr_t>(new NinePatchResource(padding, aperture));
+}
+
 }  // namespace ui