Aura: Support --enable-partial-swap with --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"
@@ skipping 1466 matching lines @@
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params_in_pixel,
     int 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,
+                 gfx::Rect(params_in_pixel.size),
                  params_in_pixel.scale_factor,
                  params_in_pixel.mailbox_name,
                  params_in_pixel.latency_info,
                  ack_callback);
 }
 
 void RenderWidgetHostViewAura::SwapDelegatedFrame(
     scoped_ptr<cc::DelegatedFrameData> frame_data,
     float frame_device_scale_factor,
     const ui::LatencyInfo& latency_info) {
@@ skipping 137 matching lines @@
     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,
+                 frame->gl_frame_data->sub_buffer_rect,
                  frame->metadata.device_scale_factor,
                  mailbox_name,
                  frame->metadata.latency_info,
                  ack_callback);
 }
 
 #if defined(OS_WIN)
 void RenderWidgetHostViewAura::SetParentNativeViewAccessible(
     gfx::NativeViewAccessible accessible_parent) {
   if (GetBrowserAccessibilityManager()) {
     GetBrowserAccessibilityManager()->ToBrowserAccessibilityManagerWin()
         ->set_parent_iaccessible(accessible_parent);
   }
 }
 #endif
 
 void RenderWidgetHostViewAura::BuffersSwapped(
-    const gfx::Size& size,
+    const gfx::Size& surface_size,
+    const gfx::Rect& damage_rect,
     float surface_scale_factor,
     const std::string& mailbox_name,
     const ui::LatencyInfo& latency_info,
     const BufferPresentedCallback& ack_callback) {
-  scoped_refptr<ui::Texture> texture_to_return(current_surface_);
-  const gfx::Rect surface_rect = gfx::Rect(size);
-  if (!SwapBuffersPrepare(surface_rect, surface_scale_factor, surface_rect,
-                          mailbox_name, ack_callback)) {
+  scoped_refptr<ui::Texture> previous_texture(current_surface_);
+  const gfx::Rect surface_rect = gfx::Rect(surface_size);
+
+  if (!SwapBuffersPrepare(surface_rect,
+                          surface_scale_factor,
+                          damage_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(surface_scale_factor, size);
-    window_->SchedulePaintInRect(gfx::Rect(surface_size));
-    compositor->SetLatencyInfo(latency_info);
-  }
-
-  if (paint_observer_)
-    paint_observer_->OnUpdateCompositorContent();
-
-  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(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);
-  BufferPresentedCallback ack_callback = base::Bind(
-      &AcknowledgeBufferForGpu, params_in_pixel.route_id, gpu_host_id,
-      params_in_pixel.mailbox_name);
-
-  if (!SwapBuffersPrepare(
-      surface_rect, params_in_pixel.surface_scale_factor, 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;
+  const gfx::Size surface_size_in_pixel = surface_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 (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(),
         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(
-        params_in_pixel.surface_scale_factor,
-        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));
+    gfx::Rect rect_to_paint =
+        ConvertRectToDIP(surface_scale_factor,
+                         gfx::Rect(damage_rect.x(),
+                                   surface_size_in_pixel.height() -
+                                       damage_rect.y() - damage_rect.height(),
+                                   damage_rect.width(),
+                                   damage_rect.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);
-    compositor->SetLatencyInfo(params_in_pixel.latency_info);
+    compositor->SetLatencyInfo(latency_info);
   }
 
   SwapBuffersCompleted(ack_callback, previous_texture);
 }
 
+void RenderWidgetHostViewAura::AcceleratedSurfacePostSubBuffer(
+    const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params_in_pixel,
+    int gpu_host_id) {
+  gfx::Rect damage_rect(params_in_pixel.x,
+                        params_in_pixel.y,
+                        params_in_pixel.width,
+                        params_in_pixel.height);
+  BufferPresentedCallback ack_callback =
+      base::Bind(&AcknowledgeBufferForGpu,
+                 params_in_pixel.route_id,
+                 gpu_host_id,
+                 params_in_pixel.mailbox_name);
+  BuffersSwapped(params_in_pixel.surface_size,
+                 damage_rect,
+                 params_in_pixel.surface_scale_factor,
+                 params_in_pixel.mailbox_name,
+                 params_in_pixel.latency_info,
+                 ack_callback);
+}
+
 void RenderWidgetHostViewAura::AcceleratedSurfaceSuspend() {
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceRelease() {
   // This really tells us to release the frontbuffer.
   if (current_surface_) {
     ui::Compositor* compositor = GetCompositor();
     if (compositor) {
       // We need to wait for a commit to clear to guarantee that all we
       // will not issue any more GL referencing the previous surface.
@@ skipping 1267 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content