Aura: Browser-side changes for Composite-To-Mailbox

content/browser/renderer_host/render_widget_host_view_aura.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_aura.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
+#include "cc/compositor_frame.h"
+#include "cc/compositor_frame_ack.h"
 #include "content/browser/renderer_host/backing_store_aura.h"
 #include "content/browser/renderer_host/dip_util.h"
 #include "content/browser/renderer_host/overscroll_controller.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/ui_events_helper.h"
 #include "content/browser/renderer_host/web_input_event_aura.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/view_messages.h"
@@ skipping 243 matching lines @@
 
   if (event.type() == ui::ET_GESTURE_BEGIN) {
     const ui::GestureEvent& gesture =
         static_cast<const ui::GestureEvent&>(event);
     return gesture.details().touch_points() == 1;
   }
 
   return false;
 }
 
+// Swap ack for the renderer when kCompositeToMailbox is enabled.
+void SendCompositorFrameAck(
+    int32 route_id,
+    int renderer_host_id,
+    const cc::Mailbox& received_mailbox,
+    const gfx::Size& received_size,
+    bool skip_frame,
+    const scoped_refptr<ui::Texture>& texture_to_produce) {
+  cc::CompositorFrameAck ack;
+  ack.gl_frame_data.reset(new cc::GLFrameData());
+  DCHECK(!texture_to_produce || !skip_frame);
+  if (texture_to_produce) {
+    std::string mailbox_name = texture_to_produce->Produce();
+    std::copy(mailbox_name.data(),
+              mailbox_name.data() + mailbox_name.length(),
+              reinterpret_cast<char*>(ack.gl_frame_data->mailbox.name));
+    ack.gl_frame_data->size = texture_to_produce->size();
+    ack.gl_frame_data->sync_point =
+        content::ImageTransportFactory::GetInstance()->InsertSyncPoint();
+  } else if (skip_frame) {
+    // Skip the frame, i.e. tell the producer to reuse the same buffer that
+    // we just received.
+    ack.gl_frame_data->size = received_size;
+    ack.gl_frame_data->mailbox = received_mailbox;
+  }
+
+  RenderWidgetHostImpl::SendSwapCompositorFrameAck(
+      route_id, renderer_host_id, ack);
+}
+
+void AcknowledgeBufferForGpu(
+    int32 route_id,
+    int gpu_host_id,
+    const std::string& received_mailbox,
+    bool skip_frame,
+    const scoped_refptr<ui::Texture>& texture_to_produce) {
+  AcceleratedSurfaceMsg_BufferPresented_Params ack;
+  uint32 sync_point = 0;
+  DCHECK(!texture_to_produce || !skip_frame);
+  if (texture_to_produce) {
+    ack.mailbox_name = texture_to_produce->Produce();
+    sync_point =
+        content::ImageTransportFactory::GetInstance()->InsertSyncPoint();
+  } else if (skip_frame) {
+    ack.mailbox_name = received_mailbox;
+    ack.sync_point = 0;
+  }
+
+  ack.sync_point = sync_point;
+  RenderWidgetHostImpl::AcknowledgeBufferPresent(
+      route_id, gpu_host_id, ack);
+}
+
 }  // namespace
 
 // We need to watch for mouse events outside a Web Popup or its parent
 // and dismiss the popup for certain events.
 class RenderWidgetHostViewAura::EventFilterForPopupExit :
     public ui::EventHandler {
  public:
   explicit EventFilterForPopupExit(RenderWidgetHostViewAura* rwhva)
       : rwhva_(rwhva) {
     DCHECK(rwhva_);
@@ skipping 227 matching lines @@
  private:
   aura::RootWindow* root_window_;
   gfx::Size new_size_;
   scoped_refptr<ui::CompositorLock> compositor_lock_;
   base::WeakPtrFactory<ResizeLock> weak_ptr_factory_;
   bool defer_compositor_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(ResizeLock);
 };
 
-RenderWidgetHostViewAura::BufferPresentedParams::BufferPresentedParams(
-    int route_id,
-    int gpu_host_id)
-    : route_id(route_id),
-      gpu_host_id(gpu_host_id) {
-}
-
-RenderWidgetHostViewAura::BufferPresentedParams::~BufferPresentedParams() {
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, public:
 
 RenderWidgetHostViewAura::RenderWidgetHostViewAura(RenderWidgetHost* host)
     : host_(RenderWidgetHostImpl::From(host)),
       ALLOW_THIS_IN_INITIALIZER_LIST(window_(new aura::Window(this))),
       in_shutdown_(false),
       is_fullscreen_(false),
       popup_parent_host_view_(NULL),
       popup_child_host_view_(NULL),
@@ skipping 567 matching lines @@
   } else {
     window_->SetExternalTexture(NULL);
     resize_locks_.clear();
   }
 }
 
 bool RenderWidgetHostViewAura::SwapBuffersPrepare(
     const gfx::Rect& surface_rect,
     const gfx::Rect& damage_rect,
     const std::string& mailbox_name,
-    BufferPresentedParams* params) {
-  DCHECK(!mailbox_name.empty());
-  DCHECK(!params->texture_to_produce);
-
+    const BufferPresentedCallback& ack_callback) {
   if (last_swapped_surface_size_ != surface_rect.size()) {
     // The surface could have shrunk since we skipped an update, in which
     // case we can expect a full update.
     DLOG_IF(ERROR, damage_rect != surface_rect) << "Expected full damage rect";
     skipped_damage_.setEmpty();
     last_swapped_surface_size_ = surface_rect.size();
   }
 
-  if (ShouldSkipFrame(surface_rect.size())) {
+  if (ShouldSkipFrame(surface_rect.size()) || mailbox_name.empty()) {
     skipped_damage_.op(RectToSkIRect(damage_rect), SkRegion::kUnion_Op);
-    AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
-    ack_params.mailbox_name = mailbox_name;
-    ack_params.sync_point = 0;
-    RenderWidgetHostImpl::AcknowledgeBufferPresent(
-        params->route_id, params->gpu_host_id, ack_params);
+    ack_callback.Run(true, scoped_refptr<ui::Texture>());
     return false;
   }
 
-  params->texture_to_produce = current_surface_;
-
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   current_surface_ = factory->CreateTransportClient(device_scale_factor_);
   if (!current_surface_) {
     LOG(ERROR) << "Failed to create ImageTransport texture";
+    ack_callback.Run(true, scoped_refptr<ui::Texture>());
     return false;
   }
 
   current_surface_->Consume(mailbox_name, surface_rect.size());
   released_front_lock_ = NULL;
   UpdateExternalTexture();
 
   return true;
 }
 
 void RenderWidgetHostViewAura::SwapBuffersCompleted(
-    const BufferPresentedParams& params) {
+    const BufferPresentedCallback& ack_callback,
+    const scoped_refptr<ui::Texture>& texture_to_return) {
   ui::Compositor* compositor = GetCompositor();
   if (!compositor) {
-    InsertSyncPointAndACK(params);
+    ack_callback.Run(false, texture_to_return);
   } else {
     // Add sending an ACK to the list of things to do OnCompositingDidCommit
     can_lock_compositor_ = NO_PENDING_COMMIT;
     on_compositing_did_commit_callbacks_.push_back(
-        base::Bind(&RenderWidgetHostViewAura::InsertSyncPointAndACK, params));
+        base::Bind(ack_callback, false, texture_to_return));
     if (!compositor->HasObserver(this))
       compositor->AddObserver(this);
   }
 }
 
 #if defined(OS_WIN)
 void RenderWidgetHostViewAura::UpdateTransientRects(
     const std::vector<gfx::Rect>& rects) {
   transient_rects_ = rects;
   UpdateCutoutRects();
@@ skipping 17 matching lines @@
                              constrained_rects_.end());
   params.geometry = &plugin_window_moves_;
   LPARAM lparam = reinterpret_cast<LPARAM>(&params);
   EnumChildWindows(parent, SetCutoutRectsCallback, lparam);
 }
 #endif
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params_in_pixel,
     int gpu_host_id) {
-  const gfx::Rect surface_rect = gfx::Rect(gfx::Point(), params_in_pixel.size);
-  BufferPresentedParams ack_params(params_in_pixel.route_id, gpu_host_id);
+  BufferPresentedCallback ack_callback = base::Bind(
+      &AcknowledgeBufferForGpu,
+      params_in_pixel.route_id,
+      gpu_host_id,
+      params_in_pixel.mailbox_name);
+  BuffersSwapped(
+      params_in_pixel.size, params_in_pixel.mailbox_name, ack_callback);
+}
+
+void RenderWidgetHostViewAura::OnSwapCompositorFrame(
+    const cc::CompositorFrame& frame, int render_host_id, int route_id) {
+  if (!frame.gl_frame_data || frame.gl_frame_data->mailbox.isZero())
+    return;
+
+  BufferPresentedCallback ack_callback = base::Bind(
+      &SendCompositorFrameAck, route_id, render_host_id,
+      frame.gl_frame_data->mailbox, frame.gl_frame_data->size);
+
+  if (!frame.gl_frame_data->sync_point) {
+    LOG(ERROR) << "CompositorFrame without sync point. Skipping frame...";
+    ack_callback.Run(true, scoped_refptr<ui::Texture>());
+    return;
+  }
+
+  ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
+  factory->WaitSyncPoint(frame.gl_frame_data->sync_point);
+
+  std::string mailbox_name(
+      reinterpret_cast<const char*>(frame.gl_frame_data->mailbox.name),
+      sizeof(frame.gl_frame_data->mailbox.name));
+  BuffersSwapped(
+      frame.gl_frame_data->size, mailbox_name, ack_callback);
+}
+
+void RenderWidgetHostViewAura::BuffersSwapped(
+    const gfx::Size& size,
+    const std::string& mailbox_name,
+    const BufferPresentedCallback& ack_callback) {
+  scoped_refptr<ui::Texture> texture_to_return(current_surface_);
+  const gfx::Rect surface_rect = gfx::Rect(gfx::Point(), size);
   if (!SwapBuffersPrepare(
-      surface_rect, surface_rect, params_in_pixel.mailbox_name, &ack_params))
+      surface_rect, surface_rect, mailbox_name, ack_callback)) {
     return;
+  }
 
   previous_damage_.setRect(RectToSkIRect(surface_rect));
   skipped_damage_.setEmpty();
 
   ui::Compositor* compositor = GetCompositor();
   if (compositor) {
-    gfx::Size surface_size = ConvertSizeToDIP(this, params_in_pixel.size);
+    gfx::Size surface_size = ConvertSizeToDIP(this, size);
     window_->SchedulePaintInRect(gfx::Rect(surface_size));
   }
 
   if (paint_observer_)
     paint_observer_->OnUpdateCompositorContent();
-  SwapBuffersCompleted(ack_params);
+
+  SwapBuffersCompleted(ack_callback, texture_to_return);
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params_in_pixel,
     int gpu_host_id) {
+  scoped_refptr<ui::Texture> previous_texture(current_surface_);
   const gfx::Rect surface_rect =
       gfx::Rect(gfx::Point(), params_in_pixel.surface_size);
   gfx::Rect damage_rect(params_in_pixel.x,
                         params_in_pixel.y,
                         params_in_pixel.width,
                         params_in_pixel.height);
-  BufferPresentedParams ack_params(params_in_pixel.route_id, gpu_host_id);
+  BufferPresentedCallback ack_callback = base::Bind(
+      &AcknowledgeBufferForGpu, params_in_pixel.route_id, gpu_host_id,
+      params_in_pixel.mailbox_name);
+
   if (!SwapBuffersPrepare(
-      surface_rect, damage_rect, params_in_pixel.mailbox_name, &ack_params))
+      surface_rect, damage_rect, params_in_pixel.mailbox_name, ack_callback)) {
     return;
+  }
 
   SkRegion damage(RectToSkIRect(damage_rect));
   if (!skipped_damage_.isEmpty()) {
     damage.op(skipped_damage_, SkRegion::kUnion_Op);
     skipped_damage_.setEmpty();
   }
 
   DCHECK(surface_rect.Contains(SkIRectToRect(damage.getBounds())));
   ui::Texture* current_texture = current_surface_.get();
 
   const gfx::Size surface_size_in_pixel = params_in_pixel.surface_size;
-  DLOG_IF(ERROR, ack_params.texture_to_produce &&
-      ack_params.texture_to_produce->size() != current_texture->size() &&
+  DLOG_IF(ERROR, previous_texture &&
+      previous_texture->size() != current_texture->size() &&
       SkIRectToRect(damage.getBounds()) != surface_rect) <<
       "Expected full damage rect after size change";
-  if (ack_params.texture_to_produce && !previous_damage_.isEmpty() &&
-      ack_params.texture_to_produce->size() == current_texture->size()) {
+  if (previous_texture && !previous_damage_.isEmpty() &&
+      previous_texture->size() == current_texture->size()) {
     ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
     GLHelper* gl_helper = factory->GetGLHelper();
     gl_helper->CopySubBufferDamage(
         current_texture->PrepareTexture(),
-        ack_params.texture_to_produce->PrepareTexture(),
+        previous_texture->PrepareTexture(),
         damage,
         previous_damage_);
   }
   previous_damage_ = damage;
 
   ui::Compositor* compositor = GetCompositor();
   if (compositor) {
     // Co-ordinates come in OpenGL co-ordinate space.
     // We need to convert to layer space.
     gfx::Rect rect_to_paint = ConvertRectToDIP(this, gfx::Rect(
         params_in_pixel.x,
         surface_size_in_pixel.height() - params_in_pixel.y -
         params_in_pixel.height,
         params_in_pixel.width,
         params_in_pixel.height));
 
     // Damage may not have been DIP aligned, so inflate damage to compensate
     // for any round-off error.
     rect_to_paint.Inset(-1, -1);
     rect_to_paint.Intersect(window_->bounds());
 
     if (paint_observer_)
       paint_observer_->OnUpdateCompositorContent();
     window_->SchedulePaintInRect(rect_to_paint);
   }
 
-  SwapBuffersCompleted(ack_params);
+  SwapBuffersCompleted(ack_callback, previous_texture);
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceSuspend() {
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceRelease() {
   // This really tells us to release the frontbuffer.
   if (current_surface_) {
     ui::Compositor* compositor = GetCompositor();
     if (compositor) {
@@ skipping 1003 matching lines @@
 
 void RenderWidgetHostViewAura::RunCompositingDidCommitCallbacks() {
   for (std::vector<base::Closure>::const_iterator
       it = on_compositing_did_commit_callbacks_.begin();
       it != on_compositing_did_commit_callbacks_.end(); ++it) {
     it->Run();
   }
   on_compositing_did_commit_callbacks_.clear();
 }
 
-// static
-void RenderWidgetHostViewAura::InsertSyncPointAndACK(
-    const BufferPresentedParams& params) {
-  uint32 sync_point = 0;
-  AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
-
-  // If we produced a texture, we have to synchronize with the consumer of
-  // that texture.
-  if (params.texture_to_produce) {
-    ack_params.mailbox_name = params.texture_to_produce->Produce();
-    sync_point = ImageTransportFactory::GetInstance()->InsertSyncPoint();
-  }
-
-  ack_params.sync_point = sync_point;
-  RenderWidgetHostImpl::AcknowledgeBufferPresent(
-      params.route_id, params.gpu_host_id, ack_params);
-}
-
 void RenderWidgetHostViewAura::AddedToRootWindow() {
   window_->GetRootWindow()->AddRootWindowObserver(this);
   host_->ParentChanged(GetNativeViewId());
   UpdateScreenInfo(window_);
   if (popup_type_ != WebKit::WebPopupTypeNone)
     event_filter_for_popup_exit_.reset(new EventFilterForPopupExit(this));
 }
 
 void RenderWidgetHostViewAura::RemovingFromRootWindow() {
   event_filter_for_popup_exit_.reset();
@@ skipping 32 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content