Implement TextureImageTransportSurface using texture 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 29 matching lines @@
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 #include "ui/base/events/event.h"
 #include "ui/base/gestures/gesture_recognizer.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ui_base_types.h"
-#include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/skia_util.h"
 
 #if defined(OS_WIN)
 #include "ui/base/win/hidden_window.h"
 #endif
 
+using gfx::RectToSkIRect;
+using gfx::SkIRectToRect;
+
 using WebKit::WebScreenInfo;
 using WebKit::WebTouchEvent;
 
 namespace content {
 namespace {
 
 // In mouse lock mode, we need to prevent the (invisible) cursor from hitting
 // the border of the view, in order to get valid movement information. However,
 // forcing the cursor back to the center of the view after each mouse move
 // doesn't work well. It reduces the frequency of useful mouse move messages
@@ skipping 196 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,
+    uint64 surface_handle)
+    : route_id(route_id),
+      gpu_host_id(gpu_host_id),
+      surface_handle(surface_handle) {
+}
+
+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),
       is_loading_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       can_compose_inline_(true),
       has_composition_text_(false),
       device_scale_factor_(1.0f),
       current_surface_(0),
-      current_surface_is_protected_(true),
-      current_surface_in_use_by_compositor_(true),
-      protection_state_id_(0),
-      surface_route_id_(0),
       paint_canvas_(NULL),
       synthetic_move_sent_(false),
       accelerated_compositing_state_changed_(false),
       can_lock_compositor_(YES) {
   host_->SetView(this);
   window_observer_.reset(new WindowObserver(this));
   window_->AddObserver(window_observer_.get());
   aura::client::SetTooltipText(window_, &tooltip_);
   aura::client::SetActivationDelegate(window_, this);
   gfx::Screen::GetScreenFor(window_)->AddObserver(this);
@@ skipping 80 matching lines @@
 void RenderWidgetHostViewAura::WasShown() {
   if (!host_->is_hidden())
     return;
   host_->WasShown();
 
   if (!current_surface_ && host_->is_accelerated_compositing_active() &&
       !released_front_lock_.get()) {
     released_front_lock_ = GetCompositor()->GetCompositorLock();
   }
 
-  AdjustSurfaceProtection();
-
 #if defined(OS_WIN)
   LPARAM lparam = reinterpret_cast<LPARAM>(this);
   EnumChildWindows(ui::GetHiddenWindow(), ShowWindowsCallback, lparam);
 #endif
 }
 
 void RenderWidgetHostViewAura::WasHidden() {
   if (host_->is_hidden())
     return;
   host_->WasHidden();
 
   released_front_lock_ = NULL;
 
-  if (ShouldReleaseFrontSurface() &&
-      host_->is_accelerated_compositing_active()) {
-    current_surface_ = 0;
-    UpdateExternalTexture();
-  }
-
-  AdjustSurfaceProtection();
-
 #if defined(OS_WIN)
   aura::RootWindow* root_window = window_->GetRootWindow();
   if (root_window) {
     HWND parent = root_window->GetAcceleratedWidget();
     LPARAM lparam = reinterpret_cast<LPARAM>(this);
 
     EnumChildWindows(parent, HideWindowsCallback, lparam);
   }
 #endif
 }
@@ skipping 287 matching lines @@
 
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   GLHelper* gl_helper = factory->GetGLHelper();
   if (!gl_helper)
     return;
 
   unsigned char* addr = static_cast<unsigned char*>(
       output->GetBitmap().getPixels());
   scoped_callback_runner.Release();
   // Wrap the callback with an internal handler so that we can inject our
-  // own completion handlers (where we can call AdjustSurfaceProtection).
+  // own completion handlers (where we can try to free the frontbuffer).
   base::Callback<void(bool)> wrapper_callback = base::Bind(
       &RenderWidgetHostViewAura::CopyFromCompositingSurfaceFinished,
       AsWeakPtr(),
       callback);
   ++pending_thumbnail_tasks_;
 
   // Convert |src_subrect| from the views coordinate (upper-left origin) into
   // the OpenGL coordinate (lower-left origin).
   gfx::Rect src_subrect_in_gl = src_subrect;
   src_subrect_in_gl.set_y(GetViewBounds().height() - src_subrect.bottom());
@@ skipping 12 matching lines @@
   // switching to software mode or receive a buffers swapped notification
   // if switching to accelerated mode.
   // Sometimes (e.g. on a page load) the renderer will spuriously disable then
   // re-enable accelerated compositing, causing us to flash.
   // TODO(piman): factor the enable/disable accelerated compositing message into
   // the UpdateRect/AcceleratedSurfaceBuffersSwapped messages so that we have
   // fewer inconsistent temporary states.
   accelerated_compositing_state_changed_ = true;
 }
 
-bool RenderWidgetHostViewAura::ShouldFastACK(uint64 surface_id) {
-  ui::Texture* container = image_transport_clients_[surface_id];
-  DCHECK(container);
-
+bool RenderWidgetHostViewAura::ShouldSkipFrame(const gfx::Size& size) {
   if (can_lock_compositor_ == NO_PENDING_RENDERER_FRAME ||
       can_lock_compositor_ == NO_PENDING_COMMIT ||
       resize_locks_.empty())
     return false;
 
-  gfx::Size container_size = ConvertSizeToDIP(this, container->size());
+  gfx::Size container_size = ConvertSizeToDIP(this, size);
   ResizeLockList::iterator it = resize_locks_.begin();
   while (it != resize_locks_.end()) {
     if ((*it)->expected_size() == container_size)
       break;
     ++it;
   }
 
   // We could be getting an unexpected frame due to an animation
   // (i.e. we start resizing but we get an old size frame first).
   return it == resize_locks_.end() || ++it != resize_locks_.end();
 }
 
 void RenderWidgetHostViewAura::UpdateExternalTexture() {
   // Delay processing accelerated compositing state change till here where we
   // act upon the state change. (Clear the external texture if switching to
   // software mode or set the external texture if going to accelerated mode).
   if (accelerated_compositing_state_changed_)
     accelerated_compositing_state_changed_ = false;
 
   if (current_surface_ != 0 && host_->is_accelerated_compositing_active()) {
     ui::Texture* container = image_transport_clients_[current_surface_];
     window_->SetExternalTexture(container);
-    current_surface_in_use_by_compositor_ = true;
 
     if (!container) {
       resize_locks_.clear();
     } else {
       ResizeLockList::iterator it = resize_locks_.begin();
       while (it != resize_locks_.end()) {
         gfx::Size container_size = ConvertSizeToDIP(this,
             container->size());
         if ((*it)->expected_size() == container_size)
           break;
@@ skipping 15 matching lines @@
             it2->get()->UnlockCompositor();
           }
           if (!compositor->HasObserver(this))
             compositor->AddObserver(this);
         }
         resize_locks_.erase(resize_locks_.begin(), it);
       }
     }
   } else {
     window_->SetExternalTexture(NULL);
-    if (ShouldReleaseFrontSurface() &&
-        host_->is_accelerated_compositing_active()) {
-      // We need to wait for a commit to clear to guarantee that all we
-      // will not issue any more GL referencing the previous surface.
-      ui::Compositor* compositor = GetCompositor();
-      if (compositor) {
-        can_lock_compositor_ = NO_PENDING_COMMIT;
-        on_compositing_did_commit_callbacks_.push_back(
-            base::Bind(&RenderWidgetHostViewAura::
-                           SetSurfaceNotInUseByCompositor,
-                       AsWeakPtr()));
-        if (!compositor->HasObserver(this))
-          compositor->AddObserver(this);
-      }
-    }
     resize_locks_.clear();
   }
 }
 
+bool RenderWidgetHostViewAura::SwapBuffersPrepare(
+    const gfx::Rect& surface_rect,
+    const gfx::Rect& damage_rect,
+    BufferPresentedParams* params) {
+  DCHECK(params->surface_handle);
+  DCHECK(!params->texture_to_produce);
+
+  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())) {
+    skipped_damage_.op(RectToSkIRect(damage_rect), SkRegion::kUnion_Op);
+    InsertSyncPointAndACK(*params);
+    return false;
+  }
+
+  DCHECK(!current_surface_ || image_transport_clients_.find(current_surface_) !=
+      image_transport_clients_.end());
+  if (current_surface_)
+    params->texture_to_produce = image_transport_clients_[current_surface_];
+
+  std::swap(current_surface_, params->surface_handle);
+
+  DCHECK(image_transport_clients_.find(current_surface_) !=
+      image_transport_clients_.end());
+
+  image_transport_clients_[current_surface_]->Consume(surface_rect.size());
+  released_front_lock_ = NULL;
+  UpdateExternalTexture();
+
+  return true;
+}
+
+void RenderWidgetHostViewAura::SwapBuffersCompleted(
+    const BufferPresentedParams& params) {
+  ui::Compositor* compositor = GetCompositor();
+  if (!compositor) {
+    InsertSyncPointAndACK(params);
+  } 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));
+    if (!compositor->HasObserver(this))
+      compositor->AddObserver(this);
+  }
+}
+
 void RenderWidgetHostViewAura::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params_in_pixel,
     int gpu_host_id) {
-  surface_route_id_ = params_in_pixel.route_id;
-  // If protection state changed, then this swap is stale. We must still ACK but
-  // do not update current_surface_ since it may have been discarded.
-  if (params_in_pixel.protection_state_id &&
-      params_in_pixel.protection_state_id != protection_state_id_) {
-    DCHECK(!current_surface_);
-    if (!params_in_pixel.skip_ack)
-      InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id, false, NULL);
+  const gfx::Rect surface_rect = gfx::Rect(gfx::Point(), params_in_pixel.size);
+  BufferPresentedParams ack_params(
+      params_in_pixel.route_id, gpu_host_id, params_in_pixel.surface_handle);
+  if (!SwapBuffersPrepare(surface_rect, surface_rect, &ack_params))
     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);
+    window_->SchedulePaintInRect(gfx::Rect(surface_size));
   }
 
-  if (ShouldFastACK(params_in_pixel.surface_handle)) {
-    if (!params_in_pixel.skip_ack)
-      InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id, false, NULL);
-    return;
-  }
-
-  current_surface_ = params_in_pixel.surface_handle;
-  // If we don't require an ACK that means the content is not a fresh updated
-  // new frame, rather we are just resetting our handle to some old content
-  // that we still hadn't discarded. Although we could display immediately,
-  // by not resetting the compositor lock here, we give us some time to get
-  // a fresh frame which means fewer content flashes.
-  if (!params_in_pixel.skip_ack)
-    released_front_lock_ = NULL;
-
-  UpdateExternalTexture();
-
-  ui::Compositor* compositor = GetCompositor();
-  if (!compositor) {
-    if (!params_in_pixel.skip_ack)
-      InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id, true, NULL);
-  } else {
-    DCHECK(image_transport_clients_.find(params_in_pixel.surface_handle) !=
-           image_transport_clients_.end());
-    gfx::Size surface_size_in_pixel =
-        image_transport_clients_[params_in_pixel.surface_handle]->size();
-    gfx::Size surface_size = ConvertSizeToDIP(this, surface_size_in_pixel);
-    window_->SchedulePaintInRect(gfx::Rect(surface_size));
-
-    if (!params_in_pixel.skip_ack) {
-      // 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_in_pixel.route_id,
-                     gpu_host_id,
-                     true));
-      if (!compositor->HasObserver(this))
-        compositor->AddObserver(this);
-    }
-  }
+  SwapBuffersCompleted(ack_params);
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params_in_pixel,
     int gpu_host_id) {
-  surface_route_id_ = params_in_pixel.route_id;
-  // If visible state changed, then this PSB is stale. We must still ACK but
-  // do not update current_surface_.
-  if (params_in_pixel.protection_state_id &&
-      params_in_pixel.protection_state_id != protection_state_id_) {
-    DCHECK(!current_surface_);
-    InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id, false, NULL);
+  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, params_in_pixel.surface_handle);
+  if (!SwapBuffersPrepare(surface_rect, damage_rect, &ack_params))
     return;
+
+  SkRegion damage(RectToSkIRect(damage_rect));
+  if (!skipped_damage_.isEmpty()) {
+    damage.op(skipped_damage_, SkRegion::kUnion_Op);
+    skipped_damage_.setEmpty();
   }
 
-  if (ShouldFastACK(params_in_pixel.surface_handle)) {
-    InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id, false, NULL);
-    return;
+  DCHECK(surface_rect.Contains(SkIRectToRect(damage.getBounds())));
+  ui::Texture* current_texture = image_transport_clients_[current_surface_];
+
+  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() &&
+      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()) {
+    ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
+    GLHelper* gl_helper = factory->GetGLHelper();
+    gl_helper->CopySubBufferDamage(
+        current_texture->PrepareTexture(),
+        ack_params.texture_to_produce->PrepareTexture(),
+        damage,
+        previous_damage_);
   }
-
-  current_surface_ = params_in_pixel.surface_handle;
-  released_front_lock_ = NULL;
-  DCHECK(current_surface_);
-  UpdateExternalTexture();
+  previous_damage_ = damage;
 
   ui::Compositor* compositor = GetCompositor();
-  if (!compositor) {
-    InsertSyncPointAndACK(params_in_pixel.route_id, gpu_host_id, true, NULL);
-  } else {
-    DCHECK(image_transport_clients_.find(params_in_pixel.surface_handle) !=
-           image_transport_clients_.end());
-    gfx::Size surface_size_in_pixel =
-        image_transport_clients_[params_in_pixel.surface_handle]->size();
-
+  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.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());
 
     window_->SchedulePaintInRect(rect_to_paint);
+  }
 
-    // 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_in_pixel.route_id,
-                   gpu_host_id,
-                   true));
-    if (!compositor->HasObserver(this))
-      compositor->AddObserver(this);
-  }
+  SwapBuffersCompleted(ack_params);
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceSuspend() {
 }
 
 bool RenderWidgetHostViewAura::HasAcceleratedSurface(
       const gfx::Size& desired_size) {
   // Aura doesn't use GetBackingStore for accelerated pages, so it doesn't
   // matter what is returned here as GetBackingStore is the only caller of this
   // method. TODO(jbates) implement this if other Aura code needs it.
   return false;
 }
 
 // TODO(backer): Drop the |shm_handle| once I remove some unused service side
 // code.
 void RenderWidgetHostViewAura::AcceleratedSurfaceNew(
       int32 width_in_pixel,
       int32 height_in_pixel,
-      uint64 surface_handle) {
+      uint64 surface_handle,
+      const std::string& mailbox_name) {
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   scoped_refptr<ui::Texture> surface(factory->CreateTransportClient(
       gfx::Size(width_in_pixel, height_in_pixel), device_scale_factor_,
-      surface_handle));
+      mailbox_name));
   if (!surface) {
     LOG(ERROR) << "Failed to create ImageTransport texture";
     return;
   }
-
   image_transport_clients_[surface_handle] = surface;
 }
 
-void RenderWidgetHostViewAura::AcceleratedSurfaceRelease(
-    uint64 surface_handle) {
-  DCHECK(image_transport_clients_.find(surface_handle) !=
-         image_transport_clients_.end());
-  if (current_surface_ == surface_handle) {
+void RenderWidgetHostViewAura::AcceleratedSurfaceRelease() {
+  // This really tells us to release the frontbuffer.
+  if (current_surface_ && ShouldReleaseFrontSurface()) {
+    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.
+      can_lock_compositor_ = NO_PENDING_COMMIT;
+      scoped_refptr<ui::Texture> surface_ref =
+          image_transport_clients_[current_surface_];
+      on_compositing_did_commit_callbacks_.push_back(
+          base::Bind(&RenderWidgetHostViewAura::
+                     SetSurfaceNotInUseByCompositor,
+                     AsWeakPtr(),
+                     surface_ref));
+      if (!compositor->HasObserver(this))
+        compositor->AddObserver(this);
+    }
+    image_transport_clients_.erase(current_surface_);
     current_surface_ = 0;
     UpdateExternalTexture();
   }
-  image_transport_clients_.erase(surface_handle);
 }
 
-void RenderWidgetHostViewAura::SetSurfaceNotInUseByCompositor(ui::Compositor*) {
-  if (current_surface_ || !host_->is_hidden())
-    return;
-  current_surface_in_use_by_compositor_ = false;
-  AdjustSurfaceProtection();
-}
-
-void RenderWidgetHostViewAura::AdjustSurfaceProtection() {
-  // If the current surface is non null, it is protected.
-  // If we are visible, it is protected.
-  // Otherwise, change to not proctected once done thumbnailing and compositing.
-  bool surface_is_protected =
-      current_surface_ ||
-      !host_->is_hidden() ||
-      (current_surface_is_protected_ &&
-          (pending_thumbnail_tasks_ > 0 ||
-              current_surface_in_use_by_compositor_));
-  if (current_surface_is_protected_ == surface_is_protected)
-    return;
-  current_surface_is_protected_ = surface_is_protected;
-  ++protection_state_id_;
-
-  if (!surface_route_id_ || !shared_surface_handle_.parent_gpu_process_id)
-    return;
-
-  RenderWidgetHostImpl::SendFrontSurfaceIsProtected(
-      surface_is_protected,
-      protection_state_id_,
-      surface_route_id_,
-      shared_surface_handle_.parent_gpu_process_id);
+void RenderWidgetHostViewAura::SetSurfaceNotInUseByCompositor(
+    scoped_refptr<ui::Texture>) {
 }
 
 void RenderWidgetHostViewAura::CopyFromCompositingSurfaceFinished(
     base::WeakPtr<RenderWidgetHostViewAura> render_widget_host_view,
     const base::Callback<void(bool)>& callback,
     bool result) {
   callback.Run(result);
 
   if (!render_widget_host_view.get())
     return;
   --render_widget_host_view->pending_thumbnail_tasks_;
-  render_widget_host_view->AdjustSurfaceProtection();
 }
 
 void RenderWidgetHostViewAura::SetBackground(const SkBitmap& background) {
   RenderWidgetHostViewBase::SetBackground(background);
   host_->SetBackground(background);
   window_->layer()->SetFillsBoundsOpaquely(background.isOpaque());
 }
 
 void RenderWidgetHostViewAura::GetScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, window_);
@@ skipping 699 matching lines @@
 
 void RenderWidgetHostViewAura::OnCompositingDidCommit(
     ui::Compositor* compositor) {
   if (can_lock_compositor_ == NO_PENDING_COMMIT) {
     can_lock_compositor_ = YES;
     for (ResizeLockList::iterator it = resize_locks_.begin();
         it != resize_locks_.end(); ++it)
       if ((*it)->GrabDeferredLock())
         can_lock_compositor_ = YES_DID_LOCK;
   }
-  RunCompositingDidCommitCallbacks(compositor);
+  RunCompositingDidCommitCallbacks();
   locks_pending_commit_.clear();
 }
 
 void RenderWidgetHostViewAura::OnCompositingStarted(
     ui::Compositor* compositor) {
 }
 
 void RenderWidgetHostViewAura::OnCompositingEnded(
     ui::Compositor* compositor) {
 }
@@ skipping 10 matching lines @@
     can_lock_compositor_ = NO_PENDING_RENDERER_FRAME;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ImageTransportFactoryObserver implementation:
 
 void RenderWidgetHostViewAura::OnLostResources() {
   image_transport_clients_.clear();
   current_surface_ = 0;
-  protection_state_id_ = 0;
-  current_surface_is_protected_ = true;
-  current_surface_in_use_by_compositor_ = true;
-  surface_route_id_ = 0;
   UpdateExternalTexture();
   locks_pending_commit_.clear();
 
   DCHECK(!shared_surface_handle_.is_null());
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   factory->DestroySharedSurfaceHandle(shared_surface_handle_);
   shared_surface_handle_ = factory->CreateSharedSurfaceHandle();
   host_->CompositingSurfaceUpdated();
   host_->ScheduleComposite();
 }
@@ skipping 121 matching lines @@
   gfx::Rect rect = window_->bounds();
   int border_x = rect.width() * kMouseLockBorderPercentage / 100;
   int border_y = rect.height() * kMouseLockBorderPercentage / 100;
 
   return global_mouse_position_.x() < rect.x() + border_x ||
       global_mouse_position_.x() > rect.right() - border_x ||
       global_mouse_position_.y() < rect.y() + border_y ||
       global_mouse_position_.y() > rect.bottom() - border_y;
 }
 
-void RenderWidgetHostViewAura::RunCompositingDidCommitCallbacks(
-    ui::Compositor* compositor) {
-  for (std::vector< base::Callback<void(ui::Compositor*)> >::const_iterator
+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(compositor);
+    it->Run();
   }
   on_compositing_did_commit_callbacks_.clear();
 }
 
 // static
 void RenderWidgetHostViewAura::InsertSyncPointAndACK(
-    int32 route_id, int gpu_host_id, bool presented,
-    ui::Compositor* compositor) {
+    const BufferPresentedParams& params) {
   uint32 sync_point = 0;
-  // If we have no compositor, so we must still send the ACK. A zero
-  // sync point will not be waited for in the GPU process.
-  if (compositor) {
-    ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
-    sync_point = factory->InsertSyncPoint();
+  // If we produced a texture, we have to synchronize with the consumer of
+  // that texture.
+  if (params.texture_to_produce) {
+    params.texture_to_produce->Produce();
+    sync_point = ImageTransportFactory::GetInstance()->InsertSyncPoint();
   }
 
   RenderWidgetHostImpl::AcknowledgeBufferPresent(
-      route_id, gpu_host_id, presented, sync_point);
+      params.route_id, params.gpu_host_id, params.surface_handle, sync_point);
 }
 
 void RenderWidgetHostViewAura::AddingToRootWindow() {
   host_->ParentChanged(GetNativeViewId());
   UpdateScreenInfo(window_);
 }
 
 void RenderWidgetHostViewAura::RemovingFromRootWindow() {
   host_->ParentChanged(0);
   // We are about to disconnect ourselves from the compositor, we need to issue
   // the callbacks now, because we won't get notified when the frame is done.
   // TODO(piman): this might in theory cause a race where the GPU process starts
   // drawing to the buffer we haven't yet displayed. This will only show for 1
   // frame though, because we will reissue a new frame right away without that
   // composited data.
   ui::Compositor* compositor = GetCompositor();
-  RunCompositingDidCommitCallbacks(compositor);
+  RunCompositingDidCommitCallbacks();
   locks_pending_commit_.clear();
   if (compositor && compositor->HasObserver(this))
     compositor->RemoveObserver(this);
   DetachFromInputMethod();
 }
 
 ui::Compositor* RenderWidgetHostViewAura::GetCompositor() {
   aura::RootWindow* root_window = window_->GetRootWindow();
   return root_window ? root_window->compositor() : NULL;
 }
@@ skipping 12 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content