android: Migrate old content readback to use async readback (and delegated renderer)

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>
 
 #include "base/android/jni_android.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/bind.h"
+#include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
@@ skipping 181 matching lines @@
     ANativeWindow_release(window);
     {
       base::AutoLock lock(g_surface_map_lock.Get());
       g_surface_map.Get().insert(std::make_pair(surface_id_, j_surface));
     }
   }
 }
 
 void CompositorImpl::SetVisible(bool visible) {
   if (!visible) {
-    ui_resource_map_.clear();
+    scoped_ui_resource_map_.clear();
     host_.reset();
     client_->UIResourcesAreInvalid();
   } 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;
@@ skipping 37 matching lines @@
   if (host_)
     return host_->CompositeAndReadback(pixels, rect);
   else
     return false;
 }
 
 cc::UIResourceId CompositorImpl::GenerateUIResource(
     const cc::UIResourceBitmap& bitmap) {
   if (!host_)
     return 0;
-  scoped_ptr<cc::ScopedUIResource> ui_resource =
-      cc::ScopedUIResource::Create(host_.get(), bitmap);
-  cc::UIResourceId id = ui_resource->id();
-  ui_resource_map_.set(id, ui_resource.Pass());
+
+  cc::UIResourceId id = 0;
+  if (bitmap.GetFormat() == cc::UIResourceBitmap::RGBA8) {
+    scoped_ptr<cc::ScopedUIResource> resource =
+        cc::ScopedUIResource::Create(host_.get(), bitmap);
+    id = resource->id();
+    scoped_ui_resource_map_.set(id, resource.Pass());
+  } else if (bitmap.GetFormat() == cc::UIResourceBitmap::ETC1) {
+    transient_ui_bitmap_ = make_scoped_ptr(new cc::UIResourceBitmap(bitmap));

[no sievers, 2014/01/29 21:13:48]

as discussed: an alternate
'GenerateUIResource(base::Callback<cc::UIResourceBitmap(void)>
get_bitmap_callback)' instead of implying based on format here would be great
for use cases where the bitmap is not to be kept around.

[powei, 2014/01/30 00:54:12]

So I opted for the boolean flag for now since aelias@ also wanted the Skia
allocation of ETC1 pixels to be upstream, so I added a
GenerateCompressedUIResource.   

Also, UIResourceClient was intended to be the callback interface, but I'm not
quite sure if passing a raw UIResourceClient pointer from the android side is a
good idea right now; it ties the lifetime of the compositor |host_| with the
thumbnail objects.  

Just to keep things simple for this patch, I added TransientUIResource as a
private class here.

+    id = host_->CreateUIResource(this);
+  }
+
   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);
+  if (!host_)
+    return;
+
+  ScopedUIResourceMap::iterator it = scoped_ui_resource_map_.find(resource_id);
+  if (it != scoped_ui_resource_map_.end()) {
+    scoped_ui_resource_map_.erase(it);
+  } else {
+    host_->DeleteUIResource(resource_id);
+  }
 }
 
-GLuint CompositorImpl::GenerateTexture(gfx::JavaBitmap& bitmap) {
-  unsigned int texture_id = BuildBasicTexture();
-  gpu::gles2::GLES2Interface* gl =
-      ImageTransportFactoryAndroid::GetInstance()->GetContextGL();
-  if (texture_id == 0u)
-    return 0u;
-  GLenum format = GetGLFormatForBitmap(bitmap);
-  GLenum type = GetGLTypeForBitmap(bitmap);
+cc::UIResourceBitmap CompositorImpl::GetBitmap(cc::UIResourceId resource_id,
+                                               bool resource_lost) {
+  if (transient_ui_bitmap_)
+    return cc::UIResourceBitmap(*transient_ui_bitmap_.release());
 
-  gl->TexImage2D(GL_TEXTURE_2D,
-                 0,
-                 format,
-                 bitmap.size().width(),
-                 bitmap.size().height(),
-                 0,
-                 format,
-                 type,
-                 bitmap.pixels());
-  gl->ShallowFlushCHROMIUM();
-  return texture_id;
-}
+  // When resource has been lost.
+  DCHECK(resource_lost);
+  SkBitmap tiny_bitmap;
+  tiny_bitmap.setConfig(SkBitmap::kARGB_8888_Config, 1, 1);
+  tiny_bitmap.allocPixels();
+  tiny_bitmap.setImmutable();
 
-GLuint CompositorImpl::GenerateCompressedTexture(gfx::Size& size,
-                                                 int data_size,
-                                                 void* data) {
-  unsigned int texture_id = BuildBasicTexture();
-  gpu::gles2::GLES2Interface* gl =
-      ImageTransportFactoryAndroid::GetInstance()->GetContextGL();
-  if (texture_id == 0u)
-    return 0u;
-  gl->CompressedTexImage2D(GL_TEXTURE_2D,
-                           0,
-                           GL_ETC1_RGB8_OES,
-                           size.width(),
-                           size.height(),
-                           0,
-                           data_size,
-                           data);
-  gl->ShallowFlushCHROMIUM();
-  return texture_id;
-}
-
-void CompositorImpl::DeleteTexture(GLuint texture_id) {
-  gpu::gles2::GLES2Interface* gl =
-      ImageTransportFactoryAndroid::GetInstance()->GetContextGL();
-  gl->DeleteTextures(1, &texture_id);
-  gl->ShallowFlushCHROMIUM();
-}
-
-bool CompositorImpl::CopyTextureToBitmap(GLuint texture_id,
-                                         gfx::JavaBitmap& bitmap) {
-  return CopyTextureToBitmap(texture_id, gfx::Rect(bitmap.size()), bitmap);
-}
-
-bool CompositorImpl::CopyTextureToBitmap(GLuint texture_id,
-                                         const gfx::Rect& sub_rect,
-                                         gfx::JavaBitmap& bitmap) {
-  // The sub_rect should match the bitmap size.
-  DCHECK(bitmap.size() == sub_rect.size());
-  if (bitmap.size() != sub_rect.size() || texture_id == 0) return false;
-
-  GLHelper* helper = ImageTransportFactoryAndroid::GetInstance()->GetGLHelper();
-  helper->ReadbackTextureSync(texture_id,
-                              sub_rect,
-                              static_cast<unsigned char*> (bitmap.pixels()),
-                              SkBitmap::kARGB_8888_Config);
-  return true;
+  return cc::UIResourceBitmap(tiny_bitmap);
 }
 
 static scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
 CreateGpuProcessViewContext(
     const blink::WebGraphicsContext3D::Attributes attributes,
     int surface_id) {
   BrowserGpuChannelHostFactory* factory =
       BrowserGpuChannelHostFactory::instance();
   CauseForGpuLaunch cause =
       CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
@@ skipping 73 matching lines @@
 void CompositorImpl::DidPostSwapBuffers() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidPostSwapBuffers");
   client_->OnSwapBuffersPosted();
 }
 
 void CompositorImpl::DidAbortSwapBuffers() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidAbortSwapBuffers");
   client_->OnSwapBuffersCompleted();
 }
 
-GLuint CompositorImpl::BuildBasicTexture() {
-  gpu::gles2::GLES2Interface* gl =
-      ImageTransportFactoryAndroid::GetInstance()->GetContextGL();
-  GLuint texture_id = 0u;
-  gl->GenTextures(1, &texture_id);
-  gl->BindTexture(GL_TEXTURE_2D, texture_id);
-  gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-  gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-  gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-  return texture_id;
-}
-
-GLenum CompositorImpl::GetGLFormatForBitmap(gfx::JavaBitmap& bitmap) {
-  switch (bitmap.format()) {
-    case ANDROID_BITMAP_FORMAT_A_8:
-      return GL_ALPHA;
-      break;
-    case ANDROID_BITMAP_FORMAT_RGBA_4444:
-      return GL_RGBA;
-      break;
-    case ANDROID_BITMAP_FORMAT_RGBA_8888:
-      return GL_RGBA;
-      break;
-    case ANDROID_BITMAP_FORMAT_RGB_565:
-    default:
-      return GL_RGB;
-  }
-}
-
-GLenum CompositorImpl::GetGLTypeForBitmap(gfx::JavaBitmap& bitmap) {
-  switch (bitmap.format()) {
-    case ANDROID_BITMAP_FORMAT_A_8:
-      return GL_UNSIGNED_BYTE;
-      break;
-    case ANDROID_BITMAP_FORMAT_RGBA_4444:
-      return GL_UNSIGNED_SHORT_4_4_4_4;
-      break;
-    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();
 }
 
 } // namespace content