android: content::UIResourceProvider and content::UIResourceClientAndroid

content/browser/android/ui_resource_provider_impl.cc

+// Copyright 2013 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 "content/browser/android/ui_resource_provider_impl.h"
+
+#include "cc/resources/scoped_ui_resource.h"
+#include "cc/resources/ui_resource_bitmap.h"
+#include "cc/resources/ui_resource_client.h"
+#include "content/public/browser/android/ui_resource_listener.h"
+#include "skia/ext/refptr.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkMallocPixelRef.h"
+
+namespace {
+
+class TransientUIResource : public cc::ScopedUIResource {
+ public:
+  static scoped_ptr<TransientUIResource> Create(
+      cc::LayerTreeHost* host,
+      const cc::UIResourceBitmap& bitmap) {
+    return make_scoped_ptr(new TransientUIResource(host, bitmap));
+  }
+
+  virtual cc::UIResourceBitmap GetBitmap(cc::UIResourceId uid,
+                                         bool resource_lost) OVERRIDE {
+    if (!retrieved_) {

[David Trainor- moved to gerrit, 2014/05/13 20:38:00]

This feels a bit fragile.  So we're returning the right bitmap for the first
call of GetBitmap, then all subsequent calls will return an empty bitmap?  What
if the caller that creates resources needs to call getBitmap more than once?

[powei, 2014/05/13 23:38:03]

GetBitmap is called (again) only when the context is lost and the compositor
needs to recreate the resource.  In that case, maybe we need to add 

ui_resource_provider_->LostUIResources();
ui_resource_provider_->RecreateUIResources();

to CompositorImpl::OnLostResources();

The idea of a transient Ui resource is to not hold onto the raw bitmap once it
has been uploaded as a UI resource.  This is necessary for large bitmaps like
the thumbnail.

[David Trainor- moved to gerrit, 2014/05/16 18:18:35]

I guess I just think that's a scary assumption unless it's explicitly stated
somewhere.  But I don't know this particular bit of code well enough to say
whether or not it's okay.

+      cc::UIResourceBitmap old_bitmap(bitmap_);
+
+      // Return a place holder for all following calls to GetBitmap.
+      SkBitmap tiny_bitmap;
+      SkCanvas canvas(tiny_bitmap);
+      tiny_bitmap.setConfig(
+          SkBitmap::kARGB_8888_Config, 1, 1, 0, kOpaque_SkAlphaType);
+      tiny_bitmap.allocPixels();
+      canvas.drawColor(SK_ColorWHITE);
+      tiny_bitmap.setImmutable();
+
+      // Release our reference of the true bitmap.
+      bitmap_ = cc::UIResourceBitmap(tiny_bitmap);
+
+      retrieved_ = true;
+      return old_bitmap;
+    }
+    return bitmap_;

[David Trainor- moved to gerrit, 2014/05/13 20:38:00]

return ScopedUIResource::GetBitmap(...)?

[powei, 2014/05/13 23:38:03]

Done.

+  }
+
+ protected:
+  TransientUIResource(cc::LayerTreeHost* host,
+                      const cc::UIResourceBitmap& bitmap)
+      : cc::ScopedUIResource(host, bitmap), retrieved_(false) {}
+
+ private:
+  bool retrieved_;

[David Trainor- moved to gerrit, 2014/05/13 20:38:00]

Do we need DISALLOW_COPY_AND_ASSIGN?

[powei, 2014/05/13 23:38:03]

Done.

+};
+
+}  // anonymous namespace
+
+namespace content {
+
+UIResourceProviderImpl::UIResourceProviderImpl() : host_(NULL) {
+}
+
+UIResourceProviderImpl::~UIResourceProviderImpl() {
+  // The lifetime of the UI resource provider should be greater than all of the
+  // listeners.
+  DCHECK_EQ(listeners_.size(), 0u);
+}
+
+void UIResourceProviderImpl::SetLayerTreeHost(cc::LayerTreeHost* host) {
+  if (host_ == host)
+    return;
+
+  ui_resource_map_.clear();
+
+  UIResourcesAreInvalid();
+  host_ = host;
+
+  if (host_)
+    RecreateUIResources();
+}
+
+void UIResourceProviderImpl::AddListener(UIResourceListener* listener) {
+  UIResourceListenerList::iterator iter =
+      std::find(listeners_.begin(), listeners_.end(), listener);
+  if (iter == listeners_.end())
+    listeners_.push_back(listener);
+}
+
+void UIResourceProviderImpl::RemoveListener(UIResourceListener* listener) {
+  UIResourceListenerList::iterator iter =
+      std::find(listeners_.begin(), listeners_.end(), listener);
+  if (iter != listeners_.end())
+    listeners_.erase(iter);
+}
+
+void UIResourceProviderImpl::UIResourcesAreInvalid() {
+  for (UIResourceListenerList::iterator iter = listeners_.begin();
+       iter != listeners_.end();
+       iter++) {
+    (*iter)->OnUIResourcesAreInvalid();
+  }
+}
+
+void UIResourceProviderImpl::RecreateUIResources() {
+  for (UIResourceListenerList::iterator iter = listeners_.begin();
+       iter != listeners_.end();
+       iter++) {
+    (*iter)->OnRecreateUIResources();
+  }
+}
+
+cc::UIResourceId UIResourceProviderImpl::GenerateUIResourceFromUIResourceBitmap(
+    const cc::UIResourceBitmap& bitmap,
+    bool is_transient) {
+  if (!host_)
+    return 0;
+
+  cc::UIResourceId id = 0;
+  scoped_ptr<cc::UIResourceClient> resource;
+  if (is_transient) {
+    scoped_ptr<TransientUIResource> transient_resource =
+        TransientUIResource::Create(host_, bitmap);
+    id = transient_resource->id();
+    resource = transient_resource.Pass();
+  } else {
+    scoped_ptr<cc::ScopedUIResource> scoped_resource =
+        cc::ScopedUIResource::Create(host_, bitmap);
+    id = scoped_resource->id();
+    resource = scoped_resource.Pass();
+  }
+
+  ui_resource_map_.set(id, resource.Pass());
+
+  return id;
+}
+
+cc::UIResourceId UIResourceProviderImpl::GenerateUIResource(
+    const SkBitmap& bitmap,
+    bool is_transient) {
+  return GenerateUIResourceFromUIResourceBitmap(cc::UIResourceBitmap(bitmap),
+                                                is_transient);
+}
+
+cc::UIResourceId UIResourceProviderImpl::GenerateCompressedUIResource(
+    const gfx::Size& size,
+    void* pixels,
+    bool is_transient) {
+  DCHECK_LT(0, size.width());
+  DCHECK_LT(0, size.height());
+  DCHECK_EQ(0, size.width() % 4);
+  DCHECK_EQ(0, size.height() % 4);
+
+  size_t data_size = size.width() * size.height() / 2;
+  SkImageInfo info = {size.width(),
+                      size.height() / 2,
+                      kAlpha_8_SkColorType,
+                      kPremul_SkAlphaType};
+  skia::RefPtr<SkMallocPixelRef> etc1_pixel_ref =
+      skia::AdoptRef(SkMallocPixelRef::NewAllocate(info, 0, 0));
+  memcpy(etc1_pixel_ref->getAddr(), pixels, data_size);
+  etc1_pixel_ref->setImmutable();
+  return GenerateUIResourceFromUIResourceBitmap(
+      cc::UIResourceBitmap(etc1_pixel_ref, size), is_transient);
+}
+
+cc::UIResourceId UIResourceProviderImpl::GenerateCompressedUIResource(
+    const skia::RefPtr<SkPixelRef>& pixel_ref,
+    bool is_transient) {
+  gfx::Size size(pixel_ref->info().width(), pixel_ref->info().height());
+  DCHECK_LT(0, size.width());
+  DCHECK_LT(0, size.height());
+  DCHECK_EQ(0, size.width() % 4);
+  DCHECK_EQ(0, size.height() % 4);
+
+  return GenerateUIResourceFromUIResourceBitmap(
+      cc::UIResourceBitmap(pixel_ref, size), is_transient);
+}
+
+void UIResourceProviderImpl::DeleteUIResource(cc::UIResourceId resource_id) {
+  UIResourceMap::iterator iter = ui_resource_map_.find(resource_id);
+  if (iter != ui_resource_map_.end())
+    ui_resource_map_.erase(iter);
+}
+
+}  // namespace content