android: content::UIResourceProvider and content::UIResourceClientAndroid

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 "base/android/jni_android.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.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 "base/threading/thread_checker.h"
 #include "cc/base/switches.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
-#include "cc/resources/scoped_ui_resource.h"
-#include "cc/resources/ui_resource_bitmap.h"
 #include "cc/trees/layer_tree_host.h"
 #include "content/browser/android/child_process_launcher_android.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/common/gpu/client/command_buffer_proxy_impl.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/gpu/gpu_process_launch_causes.h"
 #include "content/common/host_shared_bitmap_manager.h"
 #include "content/public/browser/android/compositor_client.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkMallocPixelRef.h"
 #include "ui/base/android/window_android.h"
 #include "ui/gfx/android/device_display_info.h"
-#include "ui/gfx/android/java_bitmap.h"
 #include "ui/gfx/frame_time.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/android/surface_texture_tracker.h"
 #include "webkit/common/gpu/context_provider_in_process.h"
 #include "webkit/common/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
 
-namespace gfx {
-class JavaBitmap;
-}
-
 namespace {
 
 const unsigned int kMaxSwapBuffers = 2U;
 
 // Used to override capabilities_.adjust_deadline_for_parent to false
 class OutputSurfaceWithoutParent : public cc::OutputSurface {
  public:
   OutputSurfaceWithoutParent(const scoped_refptr<
       content::ContextProviderCommandBuffer>& context_provider)
       : cc::OutputSurface(context_provider) {
     capabilities_.adjust_deadline_for_parent = false;
   }
 
   virtual void SwapBuffers(cc::CompositorFrame* frame) OVERRIDE {
     content::ContextProviderCommandBuffer* provider_command_buffer =
         static_cast<content::ContextProviderCommandBuffer*>(
             context_provider_.get());
     content::CommandBufferProxyImpl* command_buffer_proxy =
         provider_command_buffer->GetCommandBufferProxy();
     DCHECK(command_buffer_proxy);
     command_buffer_proxy->SetLatencyInfo(frame->metadata.latency_info);
 
     OutputSurface::SwapBuffers(frame);
   }
 };
 
-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_) {
-      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_;
-  }
-
- protected:
-  TransientUIResource(cc::LayerTreeHost* host,
-                      const cc::UIResourceBitmap& bitmap)
-      : cc::ScopedUIResource(host, bitmap), retrieved_(false) {}
-
- private:
-  bool retrieved_;
-};
-
 class SurfaceTextureTrackerImpl : public gfx::SurfaceTextureTracker {
  public:
   SurfaceTextureTrackerImpl() : next_surface_texture_id_(1) {
     thread_checker_.DetachFromThread();
   }
 
   // Overridden from gfx::SurfaceTextureTracker:
   virtual scoped_refptr<gfx::SurfaceTexture> AcquireSurfaceTexture(
       int primary_id,
       int secondary_id) OVERRIDE {
@@ skipping 225 matching lines @@
 
   did_post_swapbuffers_ = false;
   host_->Composite(frame_time);
   if (did_post_swapbuffers_)
     pending_swapbuffers_++;
 
   // Need to track vsync to avoid compositing more than once per frame.
   root_window_->RequestVSyncUpdate();
 }
 
+UIResourceProvider& CompositorImpl::GetUIResourceProvider() {
+  return ui_resource_provider_;
+}
+
 void CompositorImpl::SetRootLayer(scoped_refptr<cc::Layer> root_layer) {
   root_layer_->RemoveAllChildren();
   if (root_layer)
     root_layer_->AddChild(root_layer);
 }
 
 void CompositorImpl::SetWindowSurface(ANativeWindow* window) {
   GpuSurfaceTracker* tracker = GpuSurfaceTracker::Get();
 
   if (window_) {
@@ skipping 37 matching lines @@
     SetWindowSurface(window);
     ANativeWindow_release(window);
     content::RegisterViewSurface(surface_id_, j_surface.obj());
   }
 }
 
 void CompositorImpl::SetVisible(bool visible) {
   if (!visible) {
     if (WillComposite())
       CancelComposite();
-    ui_resource_map_.clear();
+    ui_resource_provider_.SetLayerTreeHost(NULL);
     host_.reset();
-    client_->UIResourcesAreInvalid();
   } else if (!host_) {
     DCHECK(!WillComposite());
     needs_composite_ = false;
     needs_animate_ = false;
     pending_swapbuffers_ = 0;
     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.highp_threshold_min = 2048;
 
     CommandLine* command_line = CommandLine::ForCurrentProcess();
     settings.initial_debug_state.SetRecordRenderingStats(
         command_line->HasSwitch(cc::switches::kEnableGpuBenchmarking));
     settings.initial_debug_state.show_fps_counter =
         command_line->HasSwitch(cc::switches::kUIShowFPSCounter);
 
     host_ = cc::LayerTreeHost::CreateSingleThreaded(
         this, this, HostSharedBitmapManager::current(), settings);
     host_->SetRootLayer(root_layer_);
 
     host_->SetVisible(true);
     host_->SetLayerTreeHostClientReady();
     host_->SetViewportSize(size_);
     host_->set_has_transparent_background(has_transparent_background_);
     host_->SetDeviceScaleFactor(device_scale_factor_);
-    // Need to recreate the UI resources because a new LayerTreeHost has been
-    // created.
-    client_->DidLoseUIResources();
+    ui_resource_provider_.SetLayerTreeHost(host_.get());
   }
 }
 
 void CompositorImpl::setDeviceScaleFactor(float factor) {
   device_scale_factor_ = factor;
   if (host_)
     host_->SetDeviceScaleFactor(factor);
 }
 
 void CompositorImpl::SetWindowBounds(const gfx::Size& size) {
@@ skipping 14 matching lines @@
 
 void CompositorImpl::SetNeedsComposite() {
   if (!host_.get())
     return;
   DCHECK(!needs_composite_ || WillComposite());
 
   needs_composite_ = true;
   PostComposite(COMPOSITE_EVENTUALLY);
 }
 
-cc::UIResourceId CompositorImpl::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_.get(), bitmap);
-    id = transient_resource->id();
-    resource = transient_resource.Pass();
-  } else {
-    scoped_ptr<cc::ScopedUIResource> scoped_resource =
-        cc::ScopedUIResource::Create(host_.get(), bitmap);
-    id = scoped_resource->id();
-    resource = scoped_resource.Pass();
-  }
-
-  ui_resource_map_.set(id, resource.Pass());
-  return id;
-}
-
-cc::UIResourceId CompositorImpl::GenerateUIResource(const SkBitmap& bitmap,
-                                                    bool is_transient) {
-  return GenerateUIResourceFromUIResourceBitmap(cc::UIResourceBitmap(bitmap),
-                                                is_transient);
-}
-
-cc::UIResourceId CompositorImpl::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);
-}
-
-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);
-}
-
 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;
   scoped_refptr<GpuChannelHost> gpu_channel_host(
       factory->EstablishGpuChannelSync(cause));
@@ skipping 48 matching lines @@
     LOG(ERROR) << "Failed to create 3D context for compositor.";
     return scoped_ptr<cc::OutputSurface>();
   }
 
   return scoped_ptr<cc::OutputSurface>(
       new OutputSurfaceWithoutParent(context_provider));
 }
 
 void CompositorImpl::OnLostResources() {
   client_->DidLoseResources();
+  ui_resource_provider_.UIResourcesAreInvalid();
 }
 
 void CompositorImpl::ScheduleComposite() {
   DCHECK(!needs_composite_ || WillComposite());
   if (ignore_schedule_composite_)
     return;
 
   needs_composite_ = true;
   // We currently expect layer tree invalidations at most once per frame
   // during normal operation and therefore try to composite immediately
@@ skipping 70 matching lines @@
 }
 
 void CompositorImpl::SetNeedsAnimate() {
   if (!host_)
     return;
 
   host_->SetNeedsAnimate();
 }
 
 }  // namespace content