blob: 2e001bd9dcec9eea5950e88b33ce186c87d438be [file] [log] [blame]
// 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/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 {
// static
ResourceManagerImpl* ResourceManagerImpl::FromJavaObject(
const JavaRef<jobject>& jobj) {
return reinterpret_cast<ResourceManagerImpl*>(
Java_ResourceManager_getNativePtr(base::android::AttachCurrentThread(),
jobj));
}
ResourceManagerImpl::ResourceManagerImpl(gfx::NativeWindow native_window)
: ui_resource_manager_(nullptr) {
JNIEnv* env = base::android::AttachCurrentThread();
java_obj_.Reset(
env, Java_ResourceManager_create(env, native_window->GetJavaObject(),
reinterpret_cast<intptr_t>(this))
.obj());
DCHECK(!java_obj_.is_null());
base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
this, "android::ResourceManagerImpl",
base::ThreadTaskRunnerHandle::Get());
}
ResourceManagerImpl::~ResourceManagerImpl() {
base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
this);
Java_ResourceManager_destroy(base::android::AttachCurrentThread(), java_obj_);
}
void ResourceManagerImpl::Init(cc::UIResourceManager* ui_resource_manager) {
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) {
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);
// Check if the resource has been added (some dynamic may not have been).
item = resources_[res_type].find(res_id);
if (item == resources_[res_type].end())
return nullptr;
}
return item->second.get();
}
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,
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>();
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, SkBlendMode::kModulate));
// 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->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));
(*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) {
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()) {
resources_[res_type][res_id] = base::MakeUnique<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));
}
void ResourceManagerImpl::RemoveResource(
JNIEnv* env,
const base::android::JavaRef<jobject>& jobj,
jint res_type,
jint res_id) {
resources_[res_type].erase(res_id);
}
CrushedSpriteResource* ResourceManagerImpl::GetCrushedSpriteResource(
int bitmap_res_id, int metadata_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_[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));
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));
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;
// Create source and destination gfx::Rect's for each rectangle in
// |frame_ints|. Each rectangle consists of 6 values:
// i: destination x i+1: destination y i+2: source x i+3: source y
// i+4: width i+5: height
for (size_t j = 0; j < frame_ints.size(); j += 6) {
gfx::Rect sprite_rect_destination(frame_ints[j],
frame_ints[j+1],
frame_ints[j+4],
frame_ints[j+5]);
gfx::Rect sprite_rect_source(frame_ints[j+2],
frame_ints[j+3],
frame_ints[j+4],
frame_ints[j+5]);
frame_src_dst_rects.push_back(std::pair<gfx::Rect, gfx::Rect>(
sprite_rect_source, sprite_rect_destination));
}
src_dst_rects.push_back(frame_src_dst_rects);
}
return src_dst_rects;
}
bool ResourceManagerImpl::OnMemoryDump(
const base::trace_event::MemoryDumpArgs& args,
base::trace_event::ProcessMemoryDump* pmd) {
size_t memory_usage =
base::trace_event::EstimateMemoryUsage(resources_) +
base::trace_event::EstimateMemoryUsage(crushed_sprite_resources_) +
base::trace_event::EstimateMemoryUsage(tinted_resources_);
base::trace_event::MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(
base::StringPrintf("ui/resource_manager_0x%" PRIXPTR,
reinterpret_cast<uintptr_t>(this)));
dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
base::trace_event::MemoryAllocatorDump::kUnitsBytes,
memory_usage);
const char* system_allocator_name =
base::trace_event::MemoryDumpManager::GetInstance()
->system_allocator_pool_name();
if (system_allocator_name) {
pmd->AddSuballocation(dump->guid(), system_allocator_name);
}
return true;
}
void ResourceManagerImpl::OnCrushedSpriteResourceReloaded(
JNIEnv* env,
const JavaRef<jobject>& jobj,
jint bitmap_res_id,
const JavaRef<jobject>& bitmap) {
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));
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",
"resource_type", res_type,
"resource_id", res_id);
Java_ResourceManager_preloadResource(base::android::AttachCurrentThread(),
java_obj_, res_type, res_id);
}
void ResourceManagerImpl::RequestResourceFromJava(AndroidResourceType res_type,
int res_id) {
TRACE_EVENT2("ui", "ResourceManagerImpl::RequestResourceFromJava",
"resource_type", res_type,
"resource_id", res_id);
Java_ResourceManager_resourceRequested(base::android::AttachCurrentThread(),
java_obj_, res_type, res_id);
}
void ResourceManagerImpl::RequestCrushedSpriteResourceFromJava(
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);
}
} // namespace ui