Switch the android overscroll glow to use UIResources.

content/browser/renderer_host/compositor_impl_android.cc

 // Copyright (c) 2012 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/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 #include <map>
 
@@ skipping 120 matching lines @@
   return jsurface;
 }
 
 CompositorImpl::CompositorImpl(CompositorClient* client,
                                gfx::NativeWindow root_window)
     : root_layer_(cc::Layer::Create()),
       has_transparent_background_(false),
       window_(NULL),
       surface_id_(0),
       client_(client),
-      root_window_(root_window) {
+      root_window_(root_window),
+      overscroll_edge_id_(0),
+      overscroll_glow_id_(0) {
   DCHECK(client);
   DCHECK(root_window);
   ImageTransportFactoryAndroid::AddObserver(this);
+  LoadOverscrollResources();

[no sievers, 2013/11/26 20:10:17]

I feel like all this is some very specific functionality that can maybe live in
a better place than the compositor itself (the functionality in here is generic
otherwise).

Maybe WindowAndroid? wdyt?

And then maybe (now or later), it could also make sense to move the overscroll
related code from RWHV into ViewAndroid. (I had also been wondering if
ViewAndroid would be a better place to hold the tab's layer node rather than
ContentViewCore doing it now.)

[powei, 2013/11/26 22:17:41]

Placing it outside of the compositor sounds good to me, but then WindowAndroid
would have to talk to the compositor (to request the resources), which is not
possible currently (since ui does not depend on content).

Maybe move WindowAndroid and ViewAndroid?

   root_window->AttachCompositor();
 }
 
 CompositorImpl::~CompositorImpl() {
   root_window_->DetachCompositor();
   ImageTransportFactoryAndroid::RemoveObserver(this);
   // Clean-up any surface references.
   SetSurface(NULL);
 }
 
+void CompositorImpl::LoadOverscrollResources() {
+  TRACE_EVENT0("compositor", "CompositorImpl::LoadOverscrollResources");

[jdduke (slow), 2013/11/26 01:39:54]

We did some optimizations to improve overscroll resource load time, but it was
still fairly slow and so we kept it asynchronous.  Is there any way we can keep
the SkBitmap loading asynchronous here? Would that be too complicated?  Even a
PostDelayedTask()/PostTaskAndReply() would be an improvement here, deferring
overscroll resource id creation until such time as the bitmaps have loaded.

[powei, 2013/11/26 22:17:41]

Good idea.  I'll give asynchronous load a try.

+  SkBitmap edge_skbitmap = gfx::CreateSkBitmapFromResource(
+      "android:drawable/overscroll_edge", gfx::Size(128, 12));
+  edge_skbitmap.setImmutable();
+  overscroll_edge_bitmap_.reset(new cc::UIResourceBitmap(edge_skbitmap));
+
+  SkBitmap glow_skbitmap = gfx::CreateSkBitmapFromResource(
+      "android:drawable/overscroll_glow", gfx::Size(128, 64));
+  glow_skbitmap.setImmutable();
+  overscroll_glow_bitmap_.reset(new cc::UIResourceBitmap(glow_skbitmap));
+}
+
 void CompositorImpl::Composite() {
   if (host_)
     host_->Composite(gfx::FrameTime::Now());
 }
 
 void CompositorImpl::SetRootLayer(scoped_refptr<cc::Layer> root_layer) {
   root_layer_->RemoveAllChildren();
   root_layer_->AddChild(root_layer);
 }
 
@@ skipping 44 matching lines @@
       g_surface_map.Get().insert(std::make_pair(surface_id_, j_surface));
     }
   }
 }
 
 void CompositorImpl::SetVisible(bool visible) {
   if (!visible) {
     ui_resource_map_.clear();
     host_.reset();
     client_->UIResourcesAreInvalid();
+    overscroll_edge_id_ = 0;
+    overscroll_glow_id_ = 0;
   } else if (!host_) {
     cc::LayerTreeSettings settings;
     settings.refresh_rate = 60.0;
     settings.impl_side_painting = false;
     settings.allow_antialiasing = false;
     settings.calculate_top_controls_position = false;
     settings.top_controls_height = 0.f;
     settings.use_memory_management = false;
     settings.highp_threshold_min = 2048;
 
     host_ = cc::LayerTreeHost::CreateSingleThreaded(this, this, NULL, settings);
     host_->SetRootLayer(root_layer_);
 
     host_->SetVisible(true);
     host_->SetLayerTreeHostClientReady();
     host_->SetViewportSize(size_);
     host_->set_has_transparent_background(has_transparent_background_);
     // Need to recreate the UI resources because a new LayerTreeHost has been
     // created.
     client_->DidLoseUIResources();
+
+    overscroll_edge_id_ = GenerateUIResource(*overscroll_edge_bitmap_);
+    overscroll_glow_id_ = GenerateUIResource(*overscroll_glow_bitmap_);
   }
 }
 
 void CompositorImpl::setDeviceScaleFactor(float factor) {
   if (host_)
     host_->SetDeviceScaleFactor(factor);
 }
 
 void CompositorImpl::SetWindowBounds(const gfx::Size& size) {
   if (size_ == size)
@@ skipping 22 matching lines @@
   ui_resource_map_.set(id, ui_resource.Pass());
   return id;
 }
 
 void CompositorImpl::DeleteUIResource(cc::UIResourceId resource_id) {
   UIResourceMap::iterator it = ui_resource_map_.find(resource_id);
   if (it != ui_resource_map_.end())
     ui_resource_map_.erase(it);
 }
 
+gfx::Size CompositorImpl::GetUIResourceSize(cc::UIResourceId resource_id)
+    const {
+  DCHECK(resource_id);
+  if (!host_)
+    return gfx::Size();
+  return host_->GetUIResourceSize(resource_id);
+}
+
 blink::WebGLId CompositorImpl::GenerateTexture(gfx::JavaBitmap& bitmap) {
   unsigned int texture_id = BuildBasicTexture();
   blink::WebGraphicsContext3D* context =
       ImageTransportFactoryAndroid::GetInstance()->GetContext3D();
   if (texture_id == 0 || context->isContextLost() ||
       !context->makeContextCurrent())
     return 0;
   blink::WebGLId format = GetGLFormatForBitmap(bitmap);
   blink::WebGLId type = GetGLTypeForBitmap(bitmap);
 
@@ skipping 195 matching lines @@
     case ANDROID_BITMAP_FORMAT_RGBA_8888:
       return GL_UNSIGNED_BYTE;
       break;
     case ANDROID_BITMAP_FORMAT_RGB_565:
     default:
       return GL_UNSIGNED_SHORT_5_6_5;
   }
 }
 
 void CompositorImpl::DidCommit() {
-  root_window_->OnCompositingDidCommit();
+  root_window_->OnCompositingDidCommit(this);
 }
 
 } // namespace content