Adding compositor callbacks to RenderWidgetHostViewAndroid

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 <android/bitmap.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 28 matching lines @@
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/config/gpu_driver_bug_workaround_type.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
+#include "ui/base/android/window_android.h"
+#include "ui/base/android/window_android_observer.h"

[no sievers, 2013/11/15 20:15:20]

nit: already included in the header, since RWHV implements this

[powei, 2013/11/15 22:41:28]

Done.

 #include "ui/gfx/android/device_display_info.h"
 #include "ui/gfx/android/java_bitmap.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace content {
 
 namespace {
 
@@ skipping 50 matching lines @@
       content_view_core_(NULL),
       ime_adapter_android_(this),
       cached_background_color_(SK_ColorWHITE),
       texture_id_in_layer_(0),
       last_output_surface_id_(kUndefinedOutputSurfaceId),
       weak_ptr_factory_(this),
       overscroll_effect_enabled_(true),
       flush_input_requested_(false),
       accelerated_surface_route_id_(0) {
   if (!UsingDelegatedRenderer()) {
-    texture_layer_ = cc::TextureLayer::Create(this);
+    texture_layer_ = cc::TextureLayer::Create(NULL);
     layer_ = texture_layer_;
   }
 
   overscroll_effect_enabled_ = !CommandLine::ForCurrentProcess()->
       HasSwitch(switches::kDisableOverscrollEdgeEffect);
   // Don't block the main thread with effect resource loading.
   // Actual effect creation is deferred until an overscroll event is received.
   if (overscroll_effect_enabled_) {
     base::WorkerPool::PostTask(FROM_HERE,
                                base::Bind(&OverscrollGlow::EnsureResources),
                                true);
   }
 
   host_->SetView(this);
   SetContentViewCore(content_view_core);
   ImageTransportFactoryAndroid::AddObserver(this);
+
+  using_synchronous_compositor_ =
+      SynchronousCompositorImpl::FromID(host_->GetProcess()->GetID(),
+                                        host_->GetRoutingID()) != NULL;
 }
 
 RenderWidgetHostViewAndroid::~RenderWidgetHostViewAndroid() {
   ImageTransportFactoryAndroid::RemoveObserver(this);
   SetContentViewCore(NULL);
   DCHECK(ack_callbacks_.empty());
   if (texture_id_in_layer_) {
     ImageTransportFactoryAndroid::GetInstance()->DeleteTexture(
         texture_id_in_layer_);
   }
@@ skipping 39 matching lines @@
 RenderWidgetHost*
 RenderWidgetHostViewAndroid::GetRenderWidgetHost() const {
   return host_;
 }
 
 void RenderWidgetHostViewAndroid::WasShown() {
   if (!host_ || !host_->is_hidden())
     return;
 
   host_->WasShown();
+
+  if (content_view_core_ && !using_synchronous_compositor_)
+      content_view_core_->GetWindowAndroid()->AddObserver(this);
 }
 
 void RenderWidgetHostViewAndroid::WasHidden() {
   RunAckCallbacks();
 
   if (!host_ || host_->is_hidden())
     return;
 
   // Inform the renderer that we are being hidden so it can reduce its resource
   // utilization.
   host_->WasHidden();
+
+  if (content_view_core_ && !using_synchronous_compositor_)
+      content_view_core_->GetWindowAndroid()->RemoveObserver(this);
 }
 
 void RenderWidgetHostViewAndroid::WasResized() {
   host_->WasResized();
 }
 
 void RenderWidgetHostViewAndroid::SetSize(const gfx::Size& size) {
   // Ignore the given size as only the Java code has the power to
   // resize the view on Android.
   default_size_ = size;
@@ skipping 283 matching lines @@
   NOTIMPLEMENTED();
 }
 
 void RenderWidgetHostViewAndroid::RenderProcessGone(
     base::TerminationStatus status, int error_code) {
   Destroy();
 }
 
 void RenderWidgetHostViewAndroid::Destroy() {
   RemoveLayers();
-  content_view_core_ = NULL;
+  // This must happen before setting host_ NULL.
+  SetContentViewCore(NULL);
 
   // The RenderWidgetHost's destruction led here, so don't call it.
   host_ = NULL;
 
   delete this;
 }
 
 void RenderWidgetHostViewAndroid::SetTooltipText(
     const string16& tooltip_text) {
   // Tooltips don't makes sense on Android.
@@ skipping 181 matching lines @@
       resource_collection_ = new cc::DelegatedFrameResourceCollection;
       resource_collection_->SetClient(this);
     }
     if (!frame_provider_ ||
         texture_size_in_layer_ != frame_provider_->frame_size()) {
       if (are_layers_attached_)
         RemoveLayers();
       frame_provider_ = new cc::DelegatedFrameProvider(
           resource_collection_.get(), frame_data.Pass());
       delegated_renderer_layer_ =
-          cc::DelegatedRendererLayer::Create(this, frame_provider_);
+          cc::DelegatedRendererLayer::Create(NULL, frame_provider_);
       layer_ = delegated_renderer_layer_;
       if (are_layers_attached_)
         AttachLayers();
     } else {
       frame_provider_->SetFrameData(frame_data.Pass());
     }
   }
 
   if (delegated_renderer_layer_.get()) {
     delegated_renderer_layer_->SetDisplaySize(texture_size_in_layer_);
@@ skipping 117 matching lines @@
 
 void RenderWidgetHostViewAndroid::BuffersSwapped(
     const gpu::Mailbox& mailbox,
     uint32_t output_surface_id,
     const base::Closure& ack_callback) {
   ImageTransportFactoryAndroid* factory =
       ImageTransportFactoryAndroid::GetInstance();
 
   if (!texture_id_in_layer_) {
     texture_id_in_layer_ = factory->CreateTexture();
+    texture_layer_->SetTextureId(texture_id_in_layer_);
     texture_layer_->SetIsDrawable(true);
     texture_layer_->SetContentsOpaque(true);
   }
 
   ImageTransportFactoryAndroid::GetInstance()->AcquireTexture(
       texture_id_in_layer_, mailbox.name);
 
   ResetClipping();
 
   current_mailbox_ = mailbox;
@@ skipping 378 matching lines @@
   ScheduleAnimationIfNecessary();
 }
 
 void RenderWidgetHostViewAndroid::SetContentViewCore(
     ContentViewCoreImpl* content_view_core) {
   RunAckCallbacks();
 
   if (are_layers_attached_)
     RemoveLayers();
 
+  if (content_view_core == NULL) {
+    if (content_view_core_ && !using_synchronous_compositor_)
+      content_view_core_->GetWindowAndroid()->RemoveObserver(this);
+  }
+
   content_view_core_ = content_view_core;
 
   if (GetBrowserAccessibilityManager()) {
     base::android::ScopedJavaLocalRef<jobject> obj;
     if (content_view_core_)
       obj = content_view_core_->GetJavaObject();
     GetBrowserAccessibilityManager()->ToBrowserAccessibilityManagerAndroid()->
         SetContentViewCore(obj);
   }
 
-  if (are_layers_attached_)
+  if (are_layers_attached_) {
     AttachLayers();
+    if (content_view_core_ && !using_synchronous_compositor_)
+      content_view_core_->GetWindowAndroid()->AddObserver(this);
+  }
 }
 
 void RenderWidgetHostViewAndroid::RunAckCallbacks() {
   while (!ack_callbacks_.empty()) {
     ack_callbacks_.front().Run();
     ack_callbacks_.pop();
   }
 }
 
 void RenderWidgetHostViewAndroid::HasTouchEventHandlers(
     bool need_touch_events) {
   if (content_view_core_)
     content_view_core_->HasTouchEventHandlers(need_touch_events);
 }
 
-unsigned RenderWidgetHostViewAndroid::PrepareTexture() {
-  RunAckCallbacks();
-  return texture_id_in_layer_;
-}
-
-void RenderWidgetHostViewAndroid::DidCommitFrameData() {
+void RenderWidgetHostViewAndroid::OnCompositingDidCommit() {
   RunAckCallbacks();
 }
 
-bool RenderWidgetHostViewAndroid::PrepareTextureMailbox(
-    cc::TextureMailbox* mailbox,
-    scoped_ptr<cc::SingleReleaseCallback>* release_callback,
-    bool use_shared_memory) {
-  return false;
+void RenderWidgetHostViewAndroid::OnDetachCompositor() {
+  DCHECK(content_view_core_);
+  DCHECK(!using_synchronous_compositor_);
+  RunAckCallbacks();
 }
 
 void RenderWidgetHostViewAndroid::OnLostResources() {
   if (texture_layer_.get())
     texture_layer_->SetIsDrawable(false);
   if (delegated_renderer_layer_.get())
     DestroyDelegatedContent();
   texture_id_in_layer_ = 0;
   RunAckCallbacks();
 }
@@ skipping 93 matching lines @@
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView*
 RenderWidgetHostView::CreateViewForWidget(RenderWidgetHost* widget) {
   RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(widget);
   return new RenderWidgetHostViewAndroid(rwhi, NULL);
 }
 
 } // namespace content