Make --enable-delegated-renderer show stuff on Mac

content/browser/renderer_host/render_widget_host_view_mac.mm

 // 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_mac.h"
 
 #import <objc/runtime.h>
 #include <QuartzCore/QuartzCore.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #import "base/mac/scoped_nsobject.h"
 #include "base/mac/sdk_forward_declarations.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #import "content/browser/accessibility/browser_accessibility_cocoa.h"
 #include "content/browser/accessibility/browser_accessibility_manager_mac.h"
+#include "content/browser/compositor/resize_lock.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
+#include "content/browser/gpu/gpu_process_host.h"
+#include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/browser/renderer_host/compositing_iosurface_context_mac.h"
 #include "content/browser/renderer_host/compositing_iosurface_layer_mac.h"
 #include "content/browser/renderer_host/compositing_iosurface_mac.h"
+#include "content/browser/renderer_host/render_widget_helper.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #import "content/browser/renderer_host/render_widget_host_view_mac_dictionary_helper.h"
 #import "content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper.h"
 #import "content/browser/renderer_host/text_input_client_mac.h"
 #include "content/common/accessibility_messages.h"
 #include "content/common/edit_command.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
 #include "content/common/webplugin_geometry.h"
 #include "content/port/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #import "content/public/browser/render_widget_host_view_mac_delegate.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/platform/WebScreenInfo.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "third_party/WebKit/public/web/mac/WebInputEventFactory.h"
 #import "third_party/mozilla/ComplexTextInputPanel.h"
 #include "ui/base/cocoa/animation_utils.h"
 #import "ui/base/cocoa/fullscreen_window_manager.h"
 #import "ui/base/cocoa/underlay_opengl_hosting_window.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/base/layout.h"
+#include "ui/compositor/compositor.h"
+#include "ui/compositor/layer.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/gl/io_surface_support_mac.h"
 
 using content::BrowserAccessibility;
@@ skipping 27 matching lines @@
     MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7
 @interface NSView (NSOpenGLSurfaceResolutionLionAPI)
 - (void)setWantsBestResolutionOpenGLSurface:(BOOL)flag;
 @end
 
 static NSString* const NSWindowDidChangeBackingPropertiesNotification =
     @"NSWindowDidChangeBackingPropertiesNotification";
 
 #endif  // 10.7
 
+// Declare methods used to present swaps to this view.
+@interface NSView (ContentCompositingView)
+- (void)onNativeSurfaceBuffersSwappedWithParams:
+      (GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params)params;
+@end
+
+@implementation NSView (ContentCompositingView)
+- (void)onNativeSurfaceBuffersSwappedWithParams:
+      (GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params)params {
+}
+@end
+
 // This method will return YES for OS X versions 10.7.3 and later, and NO
 // otherwise.
 // Used to prevent a crash when building with the 10.7 SDK and accessing the
 // notification below. See: http://crbug.com/260595.
 static BOOL SupportsBackingPropertiesChangedNotification() {
   // windowDidChangeBackingProperties: method has been added to the
   // NSWindowDelegate protocol in 10.7.3, at the same time as the
   // NSWindowDidChangeBackingPropertiesNotification notification was added.
   // If the protocol contains this method description, the notification should
   // be supported as well.
@@ skipping 122 matching lines @@
       [NSNotificationCenter defaultCenter];
   [notificationCenter removeObserver:self
                 name:NSMenuDidBeginTrackingNotification
               object:[NSApp mainMenu]];
 }
 
 @end
 
 namespace {
 
+// Class used to manage the lifetime of the UI compositor.
+class CompositorInitializer {
+ public:
+  CompositorInitializer() {
+    ui::Compositor::Initialize();
+  }
+  ~CompositorInitializer() {
+    ui::Compositor::Terminate();
+  }
+};
+
 // Maximum number of characters we allow in a tooltip.
 const size_t kMaxTooltipLength = 1024;
 
 // TODO(suzhe): Upstream this function.
 blink::WebColor WebColorFromNSColor(NSColor *color) {
   CGFloat r, g, b, a;
   [color getRed:&r green:&g blue:&b alpha:&a];
 
   return
       std::max(0, std::min(static_cast<int>(lroundf(255.0f * a)), 255)) << 24 |
@@ skipping 123 matching lines @@
   // Disable the fade-out animation as the layer is removed.
   ScopedCAActionDisabler disabler;
   [layer removeFromSuperlayer];
 }
 
 }  // namespace
 
 namespace content {
 
 ///////////////////////////////////////////////////////////////////////////////
+// RenderWidgetHelper, public:
+
+void RenderWidgetHelper::OnNativeSurfaceBuffersSwapped(

[piman, 2014/05/06 00:59:01]

nit: move to render_widget_helper.cc

[ccameron, 2014/05/06 17:15:56]

This need to (at some point), bottom out in Objective C call, which can't be
done from a .cc.

For similar reasons, the other option of making it an RWHVMac static method and
calling that here wasn't an option (can't include rwhv_mac.h because of its
Objective C isms).

Other ideas of how to go about it?

[piman, 2014/05/06 19:58:09]

I guess render_widget_helper_mac.mm is probably the best.

[ccameron, 2014/05/06 20:39:00]

Done.

+    const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params) {
+  if (BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    // Immediately acknowledge this frame on the IO thread instead of the UI
+    // thread. The UI thread will wait on the GPU process. If the UI thread
+    // were to be responsible for acking swaps, then there would be a cycle
+    // and a potential deadlock.
+    // TODO(ccameron): This immediate ack circumvents GPU back-pressure that
+    // is necessary to throttle renderers. Fix that.
+    // TODO(ccameron): It is possible that the IOSurface will be deleted or
+    // reused soon as it is acked. Take out a reference to the IOSurface here,
+    // to ensure the IOSurface does not disappear before routing to the UI
+    // thread.
+    GpuProcessHost* gpu_process_host = GpuProcessHost::Get(
+        GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
+        CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH);

[piman, 2014/05/06 00:59:01]

This is coming from  GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped, so
maybe you can pass |this| from there?

[ccameron, 2014/05/06 17:15:56]

Good idea. Done.

+    if (gpu_process_host) {
+      AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
+      ack_params.sync_point = 0;
+      ack_params.renderer_id = 0;
+      gpu_process_host->Send(new AcceleratedSurfaceMsg_BufferPresented(
+          params.route_id, ack_params));
+    }
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&OnNativeSurfaceBuffersSwapped, params));
+    return;
+  }
+
+  gfx::AcceleratedWidget native_widget =
+      GpuSurfaceTracker::Get()->AcquireNativeWidget(params.surface_id);

[piman, 2014/05/06 00:59:01]

Because of races, this could be kNullAcceleratedWidget (e.g. if a frame is in
flight during destruction).

[ccameron, 2014/05/06 17:15:56]

Calling a method on a NULL object in Objective C is a no-op, so there's a
convention of doing
  [x meth]
instead of
  if (x)
    [x meth]
to be more concise.

[piman, 2014/05/06 19:58:09]

Ok, thanks.

+  [native_widget onNativeSurfaceBuffersSwappedWithParams:params];
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// DelegatedFrameHost, public:
+
+ui::Compositor* RenderWidgetHostViewMac::GetCompositor() const {
+  return compositor_.get();
+}
+
+ui::Layer* RenderWidgetHostViewMac::GetLayer() {
+  return root_layer_.get();
+}
+
+RenderWidgetHostImpl* RenderWidgetHostViewMac::GetHost() {
+  return render_widget_host_;
+}
+
+void RenderWidgetHostViewMac::SchedulePaintInRect(
+    const gfx::Rect& damage_rect_in_dip) {
+  compositor_->ScheduleFullRedraw();
+}
+
+bool RenderWidgetHostViewMac::IsVisible() {
+  return !render_widget_host_->is_hidden();
+}
+
+gfx::Size RenderWidgetHostViewMac::DesiredFrameSize() {
+  return GetViewBounds().size();
+}
+
+float RenderWidgetHostViewMac::CurrentDeviceScaleFactor() {
+  return ViewScaleFactor();
+}
+
+gfx::Size RenderWidgetHostViewMac::ConvertViewSizeToPixel(
+    const gfx::Size& size) {
+  return gfx::ToEnclosingRect(gfx::ScaleRect(gfx::Rect(size),
+                                             ViewScaleFactor())).size();
+}
+
+scoped_ptr<ResizeLock> RenderWidgetHostViewMac::CreateResizeLock(
+    bool defer_compositor_lock) {
+  NOTREACHED();
+  ResizeLock* lock = NULL;
+  return scoped_ptr<ResizeLock>(lock);
+}
+
+DelegatedFrameHost* RenderWidgetHostViewMac::GetDelegatedFrameHost() const {
+  return delegated_frame_host_.get();
+}
+
+///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewBase, public:
 
 // static
 void RenderWidgetHostViewBase::GetDefaultScreenInfo(
     blink::WebScreenInfo* results) {
   *results = GetWebScreenInfo(NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewMac, public:
@@ skipping 35 matching lines @@
   }
 
   render_widget_host_->SetView(this);
 }
 
 RenderWidgetHostViewMac::~RenderWidgetHostViewMac() {
   // This is being called from |cocoa_view_|'s destructor, so invalidate the
   // pointer.
   cocoa_view_ = nil;
 
+  // Delete the delegated frame state.
+  delegated_frame_host_.reset();
+  compositor_.reset();
+  root_layer_.reset();
+
   UnlockMouse();
 
   // Make sure that the layer doesn't reach into the now-invalid object.
   DestroyCompositedIOSurfaceAndLayer(kDestroyContext);
   DestroySoftwareLayer();
 
   // We are owned by RenderWidgetHostViewCocoa, so if we go away before the
   // RenderWidgetHost does we need to tell it not to hold a stale pointer to
   // us.
   if (render_widget_host_)
@@ skipping 327 matching lines @@
 }
 
 void RenderWidgetHostViewMac::WasShown() {
   if (!render_widget_host_->is_hidden())
     return;
 
   if (web_contents_switch_paint_time_.is_null())
     web_contents_switch_paint_time_ = base::TimeTicks::Now();
   render_widget_host_->WasShown();
   software_frame_manager_->SetVisibility(true);
+  if (delegated_frame_host_)
+    delegated_frame_host_->WasShown();
 
   // Call setNeedsDisplay before pausing for new frames to come in -- if any
   // do, and are drawn, then the needsDisplay bit will be cleared.
   [software_layer_ setNeedsDisplay];
   [compositing_iosurface_layer_ setNeedsDisplay];
   PauseForPendingResizeOrRepaintsAndDraw();
 
   // We're messing with the window, so do this to ensure no flashes.
   if (!use_core_animation_)
     [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
 }
 
 void RenderWidgetHostViewMac::WasHidden() {
   if (render_widget_host_->is_hidden())
     return;
 
   // Any pending frames will not be displayed until this is shown again. Ack
   // them now.
   SendPendingSwapAck();
 
   // If we have a renderer, then inform it that we are being hidden so it can
   // reduce its resource utilization.
   render_widget_host_->WasHidden();
   software_frame_manager_->SetVisibility(false);
+  if (delegated_frame_host_)
+    delegated_frame_host_->WasHidden();
 
   // There can be a transparent flash as this view is removed and the next is
   // added, because of OSX windowing races between displaying the contents of
   // the NSView and its corresponding OpenGL context.
   // disableScreenUpdatesUntilFlush prevents the transparent flash by avoiding
   // screen updates until the next tab draws.
   if (!use_core_animation_)
     [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
 
   web_contents_switch_paint_time_ = base::TimeTicks();
@@ skipping 81 matching lines @@
 void RenderWidgetHostViewMac::Blur() {
   UnlockMouse();
   [[cocoa_view_ window] makeFirstResponder:nil];
 }
 
 bool RenderWidgetHostViewMac::HasFocus() const {
   return [[cocoa_view_ window] firstResponder] == cocoa_view_;
 }
 
 bool RenderWidgetHostViewMac::IsSurfaceAvailableForCopy() const {
+  if (delegated_frame_host_)
+    return delegated_frame_host_->CanCopyToBitmap();
+
   return software_frame_manager_->HasCurrentFrame() ||
          (compositing_iosurface_ && compositing_iosurface_->HasIOSurface());
 }
 
 void RenderWidgetHostViewMac::Show() {
   [cocoa_view_ setHidden:NO];
 
   WasShown();
 }
 
@@ skipping 220 matching lines @@
 
 bool RenderWidgetHostViewMac::IsPopup() const {
   return popup_type_ != blink::WebPopupTypeNone;
 }
 
 void RenderWidgetHostViewMac::CopyFromCompositingSurface(
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     const base::Callback<void(bool, const SkBitmap&)>& callback,
     const SkBitmap::Config config) {
+  if (delegated_frame_host_) {
+    delegated_frame_host_->CopyFromCompositingSurface(
+        src_subrect, dst_size, callback, config);
+    return;
+  }
+
   if (config != SkBitmap::kARGB_8888_Config) {
     NOTIMPLEMENTED();
     callback.Run(false, SkBitmap());
   }
   base::ScopedClosureRunner scoped_callback_runner(
       base::Bind(callback, false, SkBitmap()));
   float scale = ScaleFactorForView(cocoa_view_);
   gfx::Size dst_pixel_size = gfx::ToFlooredSize(
       gfx::ScaleSize(dst_size, scale));
   if (compositing_iosurface_ && compositing_iosurface_->HasIOSurface()) {
@@ skipping 37 matching lines @@
 
     ignore_result(scoped_callback_runner.Release());
     callback.Run(true, target_bitmap);
   }
 }
 
 void RenderWidgetHostViewMac::CopyFromCompositingSurfaceToVideoFrame(
       const gfx::Rect& src_subrect,
       const scoped_refptr<media::VideoFrame>& target,
       const base::Callback<void(bool)>& callback) {
+  if (delegated_frame_host_) {
+    delegated_frame_host_->CopyFromCompositingSurfaceToVideoFrame(
+        src_subrect, target, callback);
+    return;
+  }
+
   base::ScopedClosureRunner scoped_callback_runner(base::Bind(callback, false));
   if (!render_widget_host_->is_accelerated_compositing_active() ||
       !compositing_iosurface_ ||
       !compositing_iosurface_->HasIOSurface())
     return;
 
   if (!target.get()) {
     NOTREACHED();
     return;
   }
 
   if (target->format() != media::VideoFrame::YV12 &&
       target->format() != media::VideoFrame::I420) {
     NOTREACHED();
     return;
   }
 
   if (src_subrect.IsEmpty())
     return;
 
   ignore_result(scoped_callback_runner.Release());
   compositing_iosurface_->CopyToVideoFrame(
       GetScaledOpenGLPixelRect(src_subrect),
       target,
       callback);
 }
 
 bool RenderWidgetHostViewMac::CanCopyToVideoFrame() const {
+  if (delegated_frame_host_)
+    return delegated_frame_host_->CanCopyToVideoFrame();
+
   return (!software_frame_manager_->HasCurrentFrame() &&
           render_widget_host_->is_accelerated_compositing_active() &&
           compositing_iosurface_ &&
           compositing_iosurface_->HasIOSurface());
 }
 
 bool RenderWidgetHostViewMac::CanSubscribeFrame() const {
+  if (delegated_frame_host_)
+    return delegated_frame_host_->CanSubscribeFrame();
+
   return !software_frame_manager_->HasCurrentFrame();
 }
 
 void RenderWidgetHostViewMac::BeginFrameSubscription(
     scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
+  if (delegated_frame_host_) {
+    delegated_frame_host_->BeginFrameSubscription(subscriber.Pass());
+    return;
+  }
   frame_subscriber_ = subscriber.Pass();
 }
 
 void RenderWidgetHostViewMac::EndFrameSubscription() {
+  if (delegated_frame_host_) {
+    delegated_frame_host_->EndFrameSubscription();
+    return;
+  }
+
   frame_subscriber_.reset();
 }
 
 // Sets whether or not to accept first responder status.
 void RenderWidgetHostViewMac::SetTakesFocusOnlyOnMouseDown(bool flag) {
   [cocoa_view_ setTakesFocusOnlyOnMouseDown:flag];
 }
 
 void RenderWidgetHostViewMac::ForwardMouseEvent(const WebMouseEvent& event) {
   if (render_widget_host_)
@@ skipping 497 matching lines @@
     return (software_frame_manager_->HasCurrentFrame() &&
            (desired_size.IsEmpty() ||
                software_frame_manager_->GetCurrentFrameSizeInDIP() ==
                    desired_size));
   }
   return false;
 }
 
 void RenderWidgetHostViewMac::OnSwapCompositorFrame(
     uint32 output_surface_id, scoped_ptr<cc::CompositorFrame> frame) {
-  // Only software compositor frames are accepted.
-  if (!frame->software_frame_data) {
+  if (frame->delegated_frame_data) {
+    // Initialize the global UI compositor once.
+    static base::LazyInstance<CompositorInitializer>
+        compositor_initializer_;

[piman, 2014/05/06 00:59:01]

Can we move this to BrowserMainLoop? That is where we're doing Aura-specific
initialization, it seems like it'd be a good place to do this (possibly only if
--enable-delegated-rendering is set, if you're concerned about side effects).

[ccameron, 2014/05/06 17:15:56]

Done.

+    ignore_result(compositor_initializer_.Get());
+
+    if (!compositor_) {
+      compositor_.reset(new ui::Compositor(cocoa_view_));
+      root_layer_.reset(new ui::Layer(ui::LAYER_TEXTURED));
+      delegated_frame_host_.reset(new DelegatedFrameHost(this));
+    }
+
+    delegated_frame_host_->SwapDelegatedFrame(
+        output_surface_id,
+        frame->delegated_frame_data.Pass(),
+        frame->metadata.device_scale_factor,
+        frame->metadata.latency_info);
+
+    gfx::Size size = ToCeiledSize(frame->metadata.viewport_size);
+    float scale_factor = frame->metadata.page_scale_factor;
+    if (compositor_->size() != size ||
+        compositor_->device_scale_factor() != scale_factor) {
+      compositor_->SetScaleAndSize(scale_factor, size);
+      root_layer_->SetBounds(gfx::Rect(0, 0, size.width(), size.height()));

[piman, 2014/05/06 00:59:01]

I think both of these should be done when the RWHVMac changes size/DSF, not when
the frame changes size.

ui::Layer has some code to handle mismatch between frame size and layer size.
Also with DSF. Think transient states when moving from a low-DPI to a high-DPI
screen.

[ccameron, 2014/05/06 17:15:56]

I've found it best to resize everything to match the frame coming in (including
the dpi and CALayer size) -- CoreAnimation will display a lodpi layer correctly
on a hidpi screen (and vice-versa).

So, I suspect that this will be the place where I'll want to update sizes --
that way, the next frame that I get from the ui::Compositor will be the size and
DPI of the delegated frame.

This way I let CoreAnimation handle the transient states, and minimize the
number of ui::Compositor commits that I do (I try to make them 1:1 with
delegated frames).

[piman, 2014/05/06 19:58:09]

What about the non-CA path?

I guess what you suggest is possible, but it is a deviation from Aura...

[ccameron, 2014/05/06 20:39:00]

non-CA path will be deleted soon (grin).
There's a lot which is iffy about this area (the thing that I mentioned earlier
about transforms not getting updated -- the issues I'm having with window
resize). I suspect I'll have to clean up a few layers here.

+    }
+    if (compositor_->root_layer() != root_layer_)
+      compositor_->SetRootLayer(root_layer_.get());
+  } else if (frame->software_frame_data) {
+    if (!software_frame_manager_->SwapToNewFrame(
+            output_surface_id,
+            frame->software_frame_data.get(),
+            frame->metadata.device_scale_factor,
+            render_widget_host_->GetProcess()->GetHandle())) {
+      render_widget_host_->GetProcess()->ReceivedBadMessage();
+      return;
+    }
+
+    // Add latency info to report when the frame finishes drawing.
+    AddPendingLatencyInfo(frame->metadata.latency_info);

[piman, 2014/05/06 00:59:01]

you'll want to do this in either case.

[ccameron, 2014/05/06 17:15:56]

The DelegatedFrameHost tracks the latency_info for us (in particular, makes it a
compositor on-commit callback).

I should probably move the latency_info tracking here into SoftwareFrameManager,
to better match what DelegatedFrameHost does.

[piman, 2014/05/06 19:58:09]

Ok.

+    GotSoftwareFrame();
+
+    cc::CompositorFrameAck ack;
+    RenderWidgetHostImpl::SendSwapCompositorFrameAck(
+        render_widget_host_->GetRoutingID(),
+        software_frame_manager_->GetCurrentFrameOutputSurfaceId(),
+        render_widget_host_->GetProcess()->GetID(),
+        ack);
+    software_frame_manager_->SwapToNewFrameComplete(
+        !render_widget_host_->is_hidden());
+
+    // Notify observers, tab capture observers in particular, that a new
+    // software frame has come in.
+    NotificationService::current()->Notify(
+        NOTIFICATION_RENDER_WIDGET_HOST_DID_UPDATE_BACKING_STORE,
+        Source<RenderWidgetHost>(render_widget_host_),
+        NotificationService::NoDetails());
+  } else {
     DLOG(ERROR) << "Received unexpected frame type.";
     RecordAction(
         base::UserMetricsAction("BadMessageTerminate_UnexpectedFrameType"));
     render_widget_host_->GetProcess()->ReceivedBadMessage();
-    return;
   }
-
-  if (!software_frame_manager_->SwapToNewFrame(
-          output_surface_id,
-          frame->software_frame_data.get(),
-          frame->metadata.device_scale_factor,
-          render_widget_host_->GetProcess()->GetHandle())) {
-    render_widget_host_->GetProcess()->ReceivedBadMessage();
-    return;
-  }
-
-  // Add latency info to report when the frame finishes drawing.
-  AddPendingLatencyInfo(frame->metadata.latency_info);
-  GotSoftwareFrame();
-
-  cc::CompositorFrameAck ack;
-  RenderWidgetHostImpl::SendSwapCompositorFrameAck(
-      render_widget_host_->GetRoutingID(),
-      software_frame_manager_->GetCurrentFrameOutputSurfaceId(),
-      render_widget_host_->GetProcess()->GetID(),
-      ack);
-  software_frame_manager_->SwapToNewFrameComplete(
-      !render_widget_host_->is_hidden());
-
-  // Notify observers, tab capture observers in particular, that a new software
-  // frame has come in.
-  NotificationService::current()->Notify(
-      NOTIFICATION_RENDER_WIDGET_HOST_DID_UPDATE_BACKING_STORE,
-      Source<RenderWidgetHost>(render_widget_host_),
-      NotificationService::NoDetails());
 }
 
 void RenderWidgetHostViewMac::OnAcceleratedCompositingStateChange() {
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceInitialized(int host_id,
                                                             int route_id) {
 }
 
 void RenderWidgetHostViewMac::GetScreenInfo(blink::WebScreenInfo* results) {
@@ skipping 1279 matching lines @@
   if (!renderWidgetHostView_->render_widget_host_)
     return;
 
   // Move the CALayers to their positions in the new view size. Note that
   // this will not draw anything because the non-background layers' sizes
   // didn't actually change.
   renderWidgetHostView_->LayoutLayers();
 
   renderWidgetHostView_->render_widget_host_->SendScreenRects();
   renderWidgetHostView_->render_widget_host_->WasResized();
+  if (renderWidgetHostView_->delegated_frame_host_)
+    renderWidgetHostView_->delegated_frame_host_->WasResized();
 
   // Wait for the frame that WasResize might have requested. If the view is
   // being made visible at a new size, then this call will have no effect
   // because the view widget is still hidden, and the pause call in WasShown
   // will have this effect for us.
   renderWidgetHostView_->PauseForPendingResizeOrRepaintsAndDraw();
 }
 
 // Fills with white the parts of the area to the right and bottom for |rect|
 // that intersect |damagedRect|.
@@ skipping 39 matching lines @@
       height = -height;
     }
 
     NSRect r = [self flipRectToNSRect:gfx::Rect(x, y, width, height)];
     CGContextSetFillColorWithColor(context,
                                    CGColorGetConstantColor(kCGColorWhite));
     CGContextFillRect(context, NSRectToCGRect(r));
   }
 }
 
+- (void)onNativeSurfaceBuffersSwappedWithParams:
+      (GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params)params {
+
+  renderWidgetHostView_->CompositorSwapBuffers(
+      params.surface_handle,
+      params.size,
+      params.scale_factor,
+      params.latency_info);
+}
+
 - (void)drawRect:(NSRect)dirtyRect {
   TRACE_EVENT0("browser", "RenderWidgetHostViewCocoa::drawRect");
   DCHECK(!renderWidgetHostView_->use_core_animation_);
 
   if (!renderWidgetHostView_->render_widget_host_) {
     // When using CoreAnimation, this path is used to paint the contents area
     // white before any frames come in. When layers to draw frames exist, this
     // is not hit.
     [[NSColor whiteColor] set];
     NSRectFill(dirtyRect);
@@ skipping 1093 matching lines @@
 }
 
 - (void)disableRendering {
   // Disable the fade-out animation as the layer is removed.
   ScopedCAActionDisabler disabler;
   [self removeFromSuperlayer];
   renderWidgetHostView_ = nil;
 }
 
 @end  // implementation SoftwareLayer