Add tinted static UI resource cache

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>
 
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/resources/scoped_ui_resource.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/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::JavaRef;
 
 namespace ui {
 
@@ skipping 39 matching lines @@
 
   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);
   }
 
   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 (const auto& a : tinted_resources_) {
+    if (used_tints.find(a.first) == used_tints.end()) {
+        tinted_resources_.erase(a.first);

[aelias_OOO_until_Jul13, 2016/09/07 19:34:44]

I think the for loop implicit iterator would still be pointing at erased item so
I'm not certain it's correct?  The usual pattern for this is to use the return
value of erase() to advance, see the similar thing in
TabListSceneLayer::FinishBuildingFrame.

[mdjones, 2016/09/08 16:34:44]

Done.

+    }
+  }
+}
+
+ResourceManager::Resource* ResourceManagerImpl::GetStaticResourceWithTint(
+    int res_id,
+    int tint_color) {
+  auto item = tinted_resources_.find(tint_color);

[aelias_OOO_until_Jul13, 2016/09/07 19:34:44]

I think the iterator name wouldn't be ridiculously long in this case so I'd
prefer avoiding "auto" for clarity.

[mdjones, 2016/09/08 16:34:44]

Done.

+  ResourceMap* resource_map;
+  if (item == tinted_resources_.end()) {
+    resource_map = new ResourceMap();
+    tinted_resources_.insert({tint_color, resource_map});
+  } else {
+    resource_map = item->second;
+  }
+
+  Resource* tinted_resource = resource_map->Lookup(res_id);
+
+  // If the resource is already cached, use it.
+  if (tinted_resource)
+    return tinted_resource;
+
+  ResourceManager::Resource* base_image =
+      GetResource(ANDROID_RESOURCE_TYPE_STATIC, res_id);
+  if (!base_image)

[aelias_OOO_until_Jul13, 2016/09/07 19:34:44]

What is this scenario, exactly?  Can we DCHECK?

[mdjones, 2016/09/08 16:34:44]

Resource might not be ready. DCHECK should be fine.

+    return nullptr;
+
+  SkBitmap tinted_bitmap;

[aelias_OOO_until_Jul13, 2016/09/07 19:34:44]

Could you add a TRACE_EVENT0(browser,
"ResourceManagerImpl::GetStaticResourceWithTint") above this line?  The tint
texture creation has a risk of introducing small janks, this will make it more
easily visible in traces.

[mdjones, 2016/09/08 16:34:44]

Done.

+  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;
+  SkScalar color_matrix[] = {
+      SkColorGetR(tint_color) / 255.0f, 0, 0, 0, 0,
+      0, SkColorGetG(tint_color) / 255.0f, 0, 0, 0,
+      0, 0, SkColorGetB(tint_color) / 255.0f, 0, 0,
+      0, 0, 0, 1.0f, 0
+  };
+  color_filter.setColorFilter(
+      SkColorFilter::MakeMatrixFilterRowMajor255(color_matrix));

[aelias_OOO_until_Jul13, 2016/09/07 19:34:44]

Could you switch to SkFilter::MakeModeFilter(color, SkXfermode::kModulate_Mode)
like I suggested earlier?  It should be faster.

[mdjones, 2016/09/08 16:34:44]

Done.

+
+  // 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);
+
+  return tinted_resource;
+}
+
+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))
     return;
 
   PreloadResourceFromJava(res_type, res_id);
@@ skipping 160 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