Delete background tab IOSurfaces on Mac.

content/browser/renderer_host/render_widget_host_impl.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_impl.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 47 matching lines @@
 using WebKit::WebMouseEvent;
 using WebKit::WebMouseWheelEvent;
 using WebKit::WebTextDirection;
 
 namespace {
 
 // How long to (synchronously) wait for the renderer to respond with a
 // PaintRect message, when our backing-store is invalid, before giving up and
 // returning a null or incorrectly sized backing-store from GetBackingStore.
 // This timeout impacts the "choppiness" of our window resize perf.
-static const int kPaintMsgTimeoutMS = 40;
+static const int kPaintMsgTimeoutMS = 50;
 
 // How long to wait before we consider a renderer hung.
 static const int kHungRendererDelayMs = 20000;
 
 // Returns |true| if the two wheel events should be coalesced.
 bool ShouldCoalesceMouseWheelEvents(const WebMouseWheelEvent& last_event,
                                     const WebMouseWheelEvent& new_event) {
   return last_event.modifiers == new_event.modifiers &&
          last_event.scrollByPage == new_event.scrollByPage &&
          last_event.hasPreciseScrollingDeltas
@@ skipping 33 matching lines @@
       is_accelerated_compositing_active_(false),
       repaint_ack_pending_(false),
       resize_ack_pending_(false),
       should_auto_resize_(false),
       mouse_move_pending_(false),
       mouse_wheel_pending_(false),
       needs_repainting_on_restore_(false),
       is_unresponsive_(false),
       in_flight_event_count_(0),
       in_get_backing_store_(false),
+      abort_get_backing_store_(false),
       view_being_painted_(false),
       ignore_input_events_(false),
       text_direction_updated_(false),
       text_direction_(WebKit::WebTextDirectionLeftToRight),
       text_direction_canceled_(false),
       suppress_next_char_events_(false),
       pending_mouse_lock_request_(false),
       has_touch_handler_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       tap_suppression_controller_(new TapSuppressionController(this)) {
@@ skipping 118 matching lines @@
 bool RenderWidgetHostImpl::OnMessageReceived(const IPC::Message &msg) {
   bool handled = true;
   bool msg_is_ok = true;
   IPC_BEGIN_MESSAGE_MAP_EX(RenderWidgetHostImpl, msg, msg_is_ok)
     IPC_MESSAGE_HANDLER(ViewHostMsg_RenderViewReady, OnMsgRenderViewReady)
     IPC_MESSAGE_HANDLER(ViewHostMsg_RenderViewGone, OnMsgRenderViewGone)
     IPC_MESSAGE_HANDLER(ViewHostMsg_Close, OnMsgClose)
     IPC_MESSAGE_HANDLER(ViewHostMsg_RequestMove, OnMsgRequestMove)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SetTooltipText, OnMsgSetTooltipText)
     IPC_MESSAGE_HANDLER(ViewHostMsg_PaintAtSize_ACK, OnMsgPaintAtSizeAck)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_CompositorSurfaceBuffersSwapped,
+                        OnCompositorSurfaceBuffersSwapped)
     IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateRect, OnMsgUpdateRect)
     IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateIsDelayed, OnMsgUpdateIsDelayed)
     IPC_MESSAGE_HANDLER(ViewHostMsg_HandleInputEvent_ACK, OnMsgInputEventAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_Focus, OnMsgFocus)
     IPC_MESSAGE_HANDLER(ViewHostMsg_Blur, OnMsgBlur)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DidChangeNumTouchEvents,
                         OnMsgDidChangeNumTouchEvents)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SetCursor, OnMsgSetCursor)
     IPC_MESSAGE_HANDLER(ViewHostMsg_TextInputStateChanged,
                         OnMsgTextInputStateChanged)
@@ skipping 297 matching lines @@
                                        int tag,
                                        const gfx::Size& page_size,
                                        const gfx::Size& desired_size) {
   // Ask the renderer to create a bitmap regardless of whether it's
   // hidden, being resized, redrawn, etc.  It resizes the web widget
   // to the page_size and then scales it to the desired_size.
   Send(new ViewMsg_PaintAtSize(routing_id_, dib_handle, tag,
                                page_size, desired_size));
 }
 
+bool RenderWidgetHostImpl::TryGetBackingStore(const gfx::Size& desired_size,
+                                              BackingStore** backing_store) {
+  // Check if the view has an accelerated surface of the desired size.
+  if (view_->HasAcceleratedSurface(desired_size)) {
+    *backing_store = NULL;
+    return true;
+  }
+
+  // Check for a software backing store of the desired size.
+  *backing_store = BackingStoreManager::GetBackingStore(this, desired_size);
+  return !!*backing_store;
+}
+
 BackingStore* RenderWidgetHostImpl::GetBackingStore(bool force_create) {
+  if (!view_)
+    return NULL;
+
+  // The view_size will be current_size_ for auto-sized views and otherwise the
+  // size of the view_. (For auto-sized views, current_size_ is updated during
+  // UpdateRect messages.)
+  gfx::Size view_size = current_size_;
+  if (!should_auto_resize_) {
+    // Get the desired size from the current view bounds.
+    gfx::Rect view_rect = view_->GetViewBounds();
+    if (view_rect.IsEmpty())
+      return NULL;
+    view_size = view_rect.size();
+  }
+
   TRACE_EVENT2("renderer_host", "RenderWidgetHostImpl::GetBackingStore",
-               "width", base::IntToString(current_size_.width()),
-               "height", base::IntToString(current_size_.height()));
+               "width", base::IntToString(view_size.width()),
+               "height", base::IntToString(view_size.height()));
 
   // We should not be asked to paint while we are hidden.  If we are hidden,
   // then it means that our consumer failed to call WasRestored. If we're not
   // force creating the backing store, it's OK since we can feel free to give
   // out our cached one if we have it.
   DCHECK(!is_hidden_ || !force_create) <<
       "GetBackingStore called while hidden!";
 
   // We should never be called recursively; this can theoretically lead to
   // infinite recursion and almost certainly leads to lower performance.
   DCHECK(!in_get_backing_store_) << "GetBackingStore called recursively!";
   AutoReset<bool> auto_reset_in_get_backing_store(&in_get_backing_store_, true);
 
   // We might have a cached backing store that we can reuse!
-  BackingStore* backing_store =
-      BackingStoreManager::GetBackingStore(this, current_size_);
-  if (!force_create)
+  BackingStore* backing_store = NULL;
+  if (TryGetBackingStore(view_size, &backing_store) || !force_create)
     return backing_store;
 
-  // If we fail to find a backing store in the cache, send out a request
-  // to the renderer to paint the view if required.
-  if (!backing_store && !repaint_ack_pending_ && !resize_ack_pending_ &&
-      !view_being_painted_) {
+  // We do not have a suitable backing store in the cache, so send out a
+  // request to the renderer to paint the view if required.
+  if (!repaint_ack_pending_ && !resize_ack_pending_ && !view_being_painted_) {
     repaint_start_time_ = TimeTicks::Now();
     repaint_ack_pending_ = true;
-    Send(new ViewMsg_Repaint(routing_id_, current_size_));
+    Send(new ViewMsg_Repaint(routing_id_, view_size));
   }
 
-  // When we have asked the RenderWidget to resize, and we are still waiting on
-  // a response, block for a little while to see if we can't get a response
-  // before returning the old (incorrectly sized) backing store.
-  if (resize_ack_pending_ || !backing_store) {
+  TimeDelta max_delay = TimeDelta::FromMilliseconds(kPaintMsgTimeoutMS);
+  TimeTicks end_time = TimeTicks::Now() + max_delay;
+  do {
+    TRACE_EVENT0("renderer_host", "GetBackingStore::WaitForUpdate");
+
+    // When we have asked the RenderWidget to resize, and we are still waiting
+    // on a response, block for a little while to see if we can't get a response
+    // before returning the old (incorrectly sized) backing store.
     IPC::Message msg;
-    TimeDelta max_delay = TimeDelta::FromMilliseconds(kPaintMsgTimeoutMS);
-    if (process_->WaitForUpdateMsg(routing_id_, max_delay, &msg)) {
+    if (process_->WaitForBackingStoreMsg(routing_id_, max_delay, &msg)) {
       OnMessageReceived(msg);
-      backing_store = BackingStoreManager::GetBackingStore(this, current_size_);
+
+      // For auto-resized views, current_size_ determines the view_size and it
+      // may have changed during the handling of an UpdateRect message.
+      if (should_auto_resize_)
+        view_size = current_size_;
+
+      // Break now if we got a backing store or accelerated surface of the
+      // correct size.
+      if (TryGetBackingStore(view_size, &backing_store) ||
+          abort_get_backing_store_) {
+        abort_get_backing_store_ = false;
+        return backing_store;
+      }
+    } else {
+      TRACE_EVENT0("renderer_host", "GetBackingStore::Timeout");
+      break;
     }
-  }
 
+    // Loop if we still have time left and haven't gotten a properly sized
+    // BackingStore yet. This is necessary to support the GPU path which
+    // typically has multiple frames pipelined -- we may need to skip one or two
+    // BackingStore messages to get to the latest.
+    max_delay = end_time - TimeTicks::Now();
+  } while (max_delay > TimeDelta::FromSeconds(0));
+
+  // We have failed to get a backing store of view_size. Fall back on
+  // current_size_ to avoid a white flash while resizing slow pages.
+  if (view_size != current_size_)
+    TryGetBackingStore(current_size_, &backing_store);
   return backing_store;
 }
 
 BackingStore* RenderWidgetHostImpl::AllocBackingStore(const gfx::Size& size) {
   if (!view_)
     return NULL;
   return view_->AllocBackingStore(size);
 }
 
 void RenderWidgetHostImpl::DonePaintingToBackingStore() {
@@ skipping 505 matching lines @@
 }
 
 void RenderWidgetHostImpl::OnMsgPaintAtSizeAck(int tag, const gfx::Size& size) {
   std::pair<int, gfx::Size> details = std::make_pair(tag, size);
   NotificationService::current()->Notify(
       NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK,
       Source<RenderWidgetHost>(this),
       Details<std::pair<int, gfx::Size> >(&details));
 }
 
+void RenderWidgetHostImpl::OnCompositorSurfaceBuffersSwapped(
+      int32 surface_id,
+      uint64 surface_handle,
+      int32 route_id,
+      int32 gpu_process_host_id) {
+  TRACE_EVENT0("renderer_host",
+               "RenderWidgetHostImpl::OnCompositorSurfaceBuffersSwapped");
+  if (!view_) {
+    RenderWidgetHostImpl::AcknowledgeSwapBuffers(route_id,
+                                                 gpu_process_host_id);
+    return;
+  }
+  GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params gpu_params;
+  gpu_params.surface_id = surface_id;
+  gpu_params.surface_handle = surface_handle;
+  gpu_params.route_id = route_id;
+#if defined(OS_MACOSX)
+  // Compositor window is always gfx::kNullPluginWindow.
+  // TODO(jbates) http://crbug.com/105344 This will be removed when there are no
+  // plugin windows.
+  gpu_params.window = gfx::kNullPluginWindow;
+#endif
+  view_->AcceleratedSurfaceBuffersSwapped(gpu_params,
+                                          gpu_process_host_id);
+}
+
 void RenderWidgetHostImpl::OnMsgUpdateRect(
     const ViewHostMsg_UpdateRect_Params& params) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::OnMsgUpdateRect");
   TimeTicks paint_start = TimeTicks::Now();
 
   // Update our knowledge of the RenderWidget's size.
   current_size_ = params.view_size;
   // Update our knowledge of the RenderWidget's scroll offset.
   last_scroll_offset_ = params.scroll_offset;
 
@@ skipping 12 matching lines @@
       ViewHostMsg_UpdateRect_Flags::is_repaint_ack(params.flags);
   if (is_repaint_ack) {
     repaint_ack_pending_ = false;
     TimeDelta delta = TimeTicks::Now() - repaint_start_time_;
     UMA_HISTOGRAM_TIMES("MPArch.RWH_RepaintDelta", delta);
   }
 
   DCHECK(!params.view_size.IsEmpty());
 
   bool was_async = false;
-  if (!is_accelerated_compositing_active_) {
+
+  // If this is a GPU UpdateRect, params.bitmap is invalid and dib will be NULL.
+  TransportDIB* dib = process_->GetTransportDIB(params.bitmap);
+
+  // If gpu process does painting, scroll_rect and copy_rects are always empty
+  // and backing store is never used.
+  if (dib) {
     DCHECK(!params.bitmap_rect.IsEmpty());
     const size_t size = params.bitmap_rect.height() *
         params.bitmap_rect.width() * 4;
-    TransportDIB* dib = process_->GetTransportDIB(params.bitmap);
+    if (dib->size() < size) {
+      DLOG(WARNING) << "Transport DIB too small for given rectangle";
+      RecordAction(UserMetricsAction("BadMessageTerminate_RWH1"));
+      GetProcess()->ReceivedBadMessage();
+    } else {
+      UNSHIPPED_TRACE_EVENT_INSTANT2("test_latency", "UpdateRect",
+          "x+y", params.bitmap_rect.x() + params.bitmap_rect.y(),
+          "color", 0xffffff & *static_cast<uint32*>(dib->memory()));
+      UNSHIPPED_TRACE_EVENT_INSTANT1("test_latency", "UpdateRectWidth",
+          "width", params.bitmap_rect.width());
 
-    // If gpu process does painting, scroll_rect and copy_rects are always empty
-    // and backing store is never used.
-    if (dib) {
-      if (dib->size() < size) {
-        DLOG(WARNING) << "Transport DIB too small for given rectangle";
-        RecordAction(UserMetricsAction("BadMessageTerminate_RWH1"));
-        GetProcess()->ReceivedBadMessage();
-      } else {
-        UNSHIPPED_TRACE_EVENT_INSTANT2("test_latency", "UpdateRect",
-            "x+y", params.bitmap_rect.x() + params.bitmap_rect.y(),
-            "color", 0xffffff & *static_cast<uint32*>(dib->memory()));
-        UNSHIPPED_TRACE_EVENT_INSTANT1("test_latency", "UpdateRectWidth",
-            "width", params.bitmap_rect.width());
+      // Scroll the backing store.
+      if (!params.scroll_rect.IsEmpty()) {
+        ScrollBackingStoreRect(params.dx, params.dy,
+                               params.scroll_rect,
+                               params.view_size);
+      }
 
-        // Scroll the backing store.
-        if (!params.scroll_rect.IsEmpty()) {
-          ScrollBackingStoreRect(params.dx, params.dy,
-                                 params.scroll_rect,
-                                 params.view_size);
-        }
-
-        // Paint the backing store. This will update it with the
-        // renderer-supplied bits. The view will read out of the backing store
-        // later to actually draw to the screen.
-        was_async = PaintBackingStoreRect(
-            params.bitmap,
-            params.bitmap_rect,
-            params.copy_rects,
-            params.view_size,
-            base::Bind(&RenderWidgetHostImpl::DidUpdateBackingStore,
-                       weak_factory_.GetWeakPtr(), params, paint_start));
-      }
+      // Paint the backing store. This will update it with the
+      // renderer-supplied bits. The view will read out of the backing store
+      // later to actually draw to the screen.
+      was_async = PaintBackingStoreRect(
+          params.bitmap,
+          params.bitmap_rect,
+          params.copy_rects,
+          params.view_size,
+          base::Bind(&RenderWidgetHostImpl::DidUpdateBackingStore,
+                     weak_factory_.GetWeakPtr(), params, paint_start));
     }
   }
 
   if (!was_async) {
     DidUpdateBackingStore(params, paint_start);
   }
 
   if (should_auto_resize_) {
     bool post_callback = new_auto_size_.IsEmpty();
     new_auto_size_ = params.view_size;
     if (post_callback) {
       MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&RenderWidgetHostImpl::DelayedAutoResized,
                      weak_factory_.GetWeakPtr()));
     }
   }
 
   // Log the time delta for processing a paint message. On platforms that don't
   // support asynchronous painting, this is equivalent to
   // MPArch.RWH_TotalPaintTime.
   TimeDelta delta = TimeTicks::Now() - paint_start;
   UMA_HISTOGRAM_TIMES("MPArch.RWH_OnMsgUpdateRect", delta);
 }
 
 void RenderWidgetHostImpl::OnMsgUpdateIsDelayed() {
-  // Nothing to do, this message was just to unblock the UI thread.
+  if (in_get_backing_store_)
+    abort_get_backing_store_ = true;
 }
 
 void RenderWidgetHostImpl::DidUpdateBackingStore(
     const ViewHostMsg_UpdateRect_Params& params,
     const TimeTicks& paint_start) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::DidUpdateBackingStore");
   TimeTicks update_start = TimeTicks::Now();
 
   if (params.needs_ack) {
     // ACK early so we can prefetch the next PaintRect if there is a next one.
@@ skipping 26 matching lines @@
   }
 
   NotificationService::current()->Notify(
       NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT,
       Source<RenderWidgetHost>(this),
       NotificationService::NoDetails());
 
   // If we got a resize ack, then perhaps we have another resize to send?
   bool is_resize_ack =
       ViewHostMsg_UpdateRect_Flags::is_resize_ack(params.flags);
-  if (is_resize_ack && view_) {
-    gfx::Rect view_bounds = view_->GetViewBounds();
-    if (current_size_ != view_bounds.size())
-      WasResized();
-  }
+  if (is_resize_ack)
+    WasResized();
 
   // Log the time delta for processing a paint message.
   TimeTicks now = TimeTicks::Now();
   TimeDelta delta = now - update_start;
   UMA_HISTOGRAM_TIMES("MPArch.RWH_DidUpdateBackingStore", delta);
 
   // Measures the time from receiving the MsgUpdateRect IPC to completing the
   // DidUpdateBackingStore() method.  On platforms which have asynchronous
   // painting, such as Linux, this is the sum of MPArch.RWH_OnMsgUpdateRect,
   // MPArch.RWH_DidUpdateBackingStore, and the time spent asynchronously
@@ skipping 422 matching lines @@
   // indicate that no callback is in progress (i.e. without this line
   // DelayedAutoResized will not get called again).
   new_auto_size_.SetSize(0, 0);
   if (!should_auto_resize_)
     return;
 
   OnRenderAutoResized(new_size);
 }
 
 }  // namespace content