Very basic Android browser-side compositing support.

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"
 #include "content/browser/android/content_view_core_impl.h"
-#include "content/browser/android/draw_delegate_impl.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
+#include "content/browser/renderer_host/compositor_impl_android.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/android/device_info.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/view_messages.h"
+#include "content/public/browser/render_view_host.h"
 
 namespace content {
 
 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) {
+      content_view_core_(content_view_core),
+      texture_layer_(WebKit::WebExternalTextureLayer::create()) {
   host_->SetView(this);
   // RenderWidgetHost is initialized as visible. If is_hidden_ is true, tell
   // RenderWidgetHost to hide.
   if (is_hidden_)
     host_->WasHidden();
+  texture_layer_.setDrawsContent(!is_hidden_);
+  RenderViewHost* view_host = RenderViewHost::From(host_);
+  view_host->GetDelegate()->AttachLayer(texture_layer_);
 }
 
 RenderWidgetHostViewAndroid::~RenderWidgetHostViewAndroid() {
 }
 
 void RenderWidgetHostViewAndroid::InitAsChild(gfx::NativeView parent_view) {
   NOTIMPLEMENTED();
 }
 
 void RenderWidgetHostViewAndroid::InitAsPopup(
@@ skipping 33 matching lines @@
   host_->WasHidden();
 }
 
 void RenderWidgetHostViewAndroid::SetSize(const gfx::Size& size) {
   // Update the size of the RWH.
   if (requested_size_.width() != size.width() ||
       requested_size_.height() != size.height()) {
     requested_size_ = gfx::Size(size.width(), size.height());
     host_->WasResized();
   }
+  texture_layer_.setBounds(size);
 }
 
 void RenderWidgetHostViewAndroid::SetBounds(const gfx::Rect& rect) {
   if (rect.origin().x() || rect.origin().y()) {
     VLOG(0) << "SetBounds not implemented for (x,y)!=(0,0)";
   }
   SetSize(rect.size());
 }
 
 gfx::NativeView RenderWidgetHostViewAndroid::GetNativeView() const {
@@ skipping 36 matching lines @@
 
   return content_view_core_->HasFocus();
 }
 
 bool RenderWidgetHostViewAndroid::IsSurfaceAvailableForCopy() const {
   NOTIMPLEMENTED();
   return false;
 }
 
 void RenderWidgetHostViewAndroid::Show() {
-  // nothing to do
+  texture_layer_.setDrawsContent(true);
 }
 
 void RenderWidgetHostViewAndroid::Hide() {
-  // nothing to do
+  texture_layer_.setDrawsContent(false);
 }
 
 bool RenderWidgetHostViewAndroid::IsShowing() {
   return !is_hidden_;
 }
 
 gfx::Rect RenderWidgetHostViewAndroid::GetViewBounds() const {
-  gfx::Size bounds = DrawDelegateImpl::GetInstance()->GetBounds();
+  gfx::Size bounds = CompositorImpl::GetInstance()->GetWindowBounds();
   if (!bounds.IsEmpty())
     return gfx::Rect(bounds);
 
   if (content_view_core_) {
     return content_view_core_->GetBounds();
   } else {
     // The ContentViewCore has not been created yet. This only happens when
     // renderer asks for creating new window, for example,
     // javascript window.open().
     return gfx::Rect(0, 0, 0, 0);
@@ skipping 27 matching lines @@
     const std::vector<gfx::Rect>& copy_rects) {
   NOTIMPLEMENTED();
 }
 
 void RenderWidgetHostViewAndroid::RenderViewGone(
     base::TerminationStatus status, int error_code) {
   Destroy();
 }
 
 void RenderWidgetHostViewAndroid::Destroy() {
+  RenderViewHost* view_host = RenderViewHost::From(host_);
+  view_host->GetDelegate()->RemoveLayer(texture_layer_);
+
   content_view_core_ = NULL;
 
   // The RenderWidgetHost's destruction led here, so don't call it.
   host_ = NULL;
 
   delete this;
 }
 
 void RenderWidgetHostViewAndroid::SetTooltipText(
     const string16& tooltip_text) {
@@ skipping 40 matching lines @@
   NOTIMPLEMENTED();
   callback.Run(false);
 }
 
 void RenderWidgetHostViewAndroid::OnAcceleratedCompositingStateChange() {
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params,
     int gpu_host_id) {
-  DrawDelegateImpl::GetInstance()->OnSurfaceUpdated(
-      params.surface_handle,
-      this,
+  texture_layer_.setTextureId(params.surface_handle);
+  texture_layer_.invalidate();
+  // TODO(sievers): The view and layer should get sized proactively.
+  if (((gfx::Size)texture_layer_.bounds()).IsEmpty())
+    texture_layer_.setBounds(CompositorImpl::GetInstance()->GetWindowBounds());
+  CompositorImpl::GetInstance()->SurfaceUpdated(
       base::Bind(&RenderWidgetHostImpl::AcknowledgeBufferPresent,
                  params.route_id, gpu_host_id));
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
   NOTREACHED();
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfaceSuspend() {
   NOTREACHED();
 }
 
 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);
 }
 
 gfx::GLSurfaceHandle RenderWidgetHostViewAndroid::GetCompositingSurface() {
   gfx::GLSurfaceHandle handle =

[klobag.chromium, 2012/08/22 07:01:19]

We don't care about the return any more as it is same for every instance, right?
Should we just return gfx::kNullPluginWindow or gfx::kDummyPluginWindow?

[no sievers, 2012/08/22 21:17:40]

This is actually not the browser-side compositor, but render-side compositor
surface (double-buffered FBO), which is still one per view.

-      DrawDelegateImpl::GetInstance()->GetDrawSurface();
+      CompositorImpl::GetInstance()->GetCompositorSurface();
   if (!handle.is_null())
     return handle;
 
   // On Android, we cannot generate a window handle that can be passed to the
   // GPU process through the native side. Instead, we send the surface handle
   // through Binder after the compositing context has been created.
   return gfx::GLSurfaceHandle(gfx::kNullPluginWindow, true);
 }
 
 void RenderWidgetHostViewAndroid::GetScreenInfo(WebKit::WebScreenInfo* result) {
@@ skipping 84 matching lines @@
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView*
 RenderWidgetHostView::CreateViewForWidget(RenderWidgetHost* widget) {
   RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(widget);
   return new RenderWidgetHostViewAndroid(rwhi, NULL);
 }
 
 } // namespace content