Implement TextureImageTransportSurface using texture mailbox

content/browser/renderer_host/render_widget_host_view_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/render_widget_host_view_android.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
@@ skipping 31 matching lines @@
 RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
     RenderWidgetHostImpl* widget_host,
     ContentViewCoreImpl* content_view_core)
     : host_(widget_host),
       // ContentViewCoreImpl represents the native side of the Java
       // ContentViewCore.  It being NULL means that it is not attached to the
       // View system yet, so we treat it as hidden.
       is_hidden_(!content_view_core),
       content_view_core_(content_view_core),
       ime_adapter_android_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
-      texture_layer_(WebKit::WebExternalTextureLayer::create()) {
+      texture_layer_(WebKit::WebExternalTextureLayer::create()),
+      current_buffer_id_(0) {
   host_->SetView(this);
   // RenderWidgetHost is initialized as visible. If is_hidden_ is true, tell
   // RenderWidgetHost to hide.
   if (is_hidden_)
     host_->WasHidden();
   texture_layer_->layer()->setDrawsContent(!is_hidden_);
   host_->AttachLayer(texture_layer_->layer());
 }
 
 RenderWidgetHostViewAndroid::~RenderWidgetHostViewAndroid() {
@@ skipping 239 matching lines @@
   NOTIMPLEMENTED();
   callback.Run(false);
 }
 
 void RenderWidgetHostViewAndroid::OnAcceleratedCompositingStateChange() {
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params,
     int gpu_host_id) {
-  texture_layer_->setTextureId(params.surface_handle);
+  DCHECK(id_to_texture_map_.find(params.surface_handle) !=
+         id_to_texture_map_.end());
+  // TODO(sievers): The compositor should do this on the impl thread.
+  // And the release should happen after the next commit.
+
+  if (current_buffer_id_) {
+    TextureMap::const_iterator it = id_to_texture_map_.find(
+        current_buffer_id_);
+    DCHECK(it != id_to_texture_map_.end());
+    ImageTransportFactoryAndroid::GetInstance()->ReleaseTexture(
+        it->second->id, it->second->mailbox_name.get());
+  }
+
+  TextureMap::const_iterator it =
+      id_to_texture_map_.find(params.surface_handle);
+  DCHECK(it != id_to_texture_map_.end());
+  const TextureInfo* texture = it->second;
+  current_buffer_id_ = params.surface_handle;
+  ImageTransportFactoryAndroid::GetInstance()->AcquireTexture(
+      texture->id, texture->mailbox_name.get());
+  texture_layer_->setTextureId(texture->id);
   texture_layer_->layer()->invalidate();
+
   // TODO(sievers): The view and layer should get sized proactively.
   if (((gfx::Size)texture_layer_->layer()->bounds()).IsEmpty())
     texture_layer_->layer()->setBounds(
         DrawDelegateImpl::GetInstance()->GetBounds());
 
   // TODO(sievers): When running the impl thread in the browser we
   // need to delay the ACK until after commit.
   DCHECK(!WebKit::Platform::current()->compositorSupport()->
          isThreadingEnabled());
   uint32 sync_point =
       ImageTransportFactoryAndroid::GetInstance()->InsertSyncPoint();
   RenderWidgetHostImpl::AcknowledgeBufferPresent(
       params.route_id, gpu_host_id, sync_point);
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
   NOTREACHED();
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfaceSuspend() {
   NOTREACHED();
 }
 
+void RenderWidgetHostViewAndroid::AcceleratedSurfaceNew(
+    int32 width_in_pixel, int32 height_in_pixel, uint64 surface_id,
+    const std::string& mailbox_name) {
+  LOG(INFO) << "RenderWidgetHostViewAndroid::AcceleratedSurfaceNew " <<
+            surface_id;
+  DCHECK(surface_id);
+  if (id_to_texture_map_.find(surface_id) != id_to_texture_map_.end()) {
+    // TODO: Should this really happen? (It does during Resize and such)
+    TextureInfo* texture = id_to_texture_map_[surface_id];
+    memcpy(texture->mailbox_name.get(),
+           mailbox_name.c_str(),
+           mailbox_name.length());
+  } else {
+    scoped_ptr<TextureInfo> texture(new TextureInfo);
+    texture->id = ImageTransportFactoryAndroid::GetInstance()->CreateTexture();
+    texture->mailbox_name.reset(new signed char[mailbox_name.length()]);
+    memcpy(texture->mailbox_name.get(),
+           mailbox_name.c_str(),
+           mailbox_name.length());
+    id_to_texture_map_[surface_id] = texture.release();
+  }
+
+  // There should only ever be a front- and backbuffer.
+  DCHECK(id_to_texture_map_.size() <= 2);
+}
+
+void RenderWidgetHostViewAndroid::AcceleratedSurfaceRelease(uint64 surface_id) {
+  LOG(INFO) << "RenderWidgetHostViewAndroid::AcceleratedSurfaceRelease " <<
+            surface_id;
+  DCHECK(surface_id);
+  TextureMap::iterator it = id_to_texture_map_.find(surface_id);
+  DCHECK(it != id_to_texture_map_.end());
+  ImageTransportFactoryAndroid::GetInstance()->DeleteTexture(it->second->id);
+  delete it->second;
+  id_to_texture_map_.erase(it);
+}
+
 bool RenderWidgetHostViewAndroid::HasAcceleratedSurface(
     const gfx::Size& desired_size) {
   NOTREACHED();
   return false;
 }
 
 void RenderWidgetHostViewAndroid::StartContentIntent(
     const GURL& content_url) {
   if (content_view_core_)
     content_view_core_->StartContentIntent(content_url);
@@ skipping 158 matching lines @@
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView*
 RenderWidgetHostView::CreateViewForWidget(RenderWidgetHost* widget) {
   RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(widget);
   return new RenderWidgetHostViewAndroid(rwhi, NULL);
 }
 
 } // namespace content