Remove code used by --disable-delegated-renderer 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 <OpenGL/gl.h>
 #include <QuartzCore/QuartzCore.h>
 
@@ skipping 379 matching lines @@
       [[screen colorSpace] colorSpaceModel] == NSGrayColorSpaceModel;
   results.rect = display.bounds();
   results.availableRect = display.work_area();
   results.orientationAngle = display.RotationAsDegree();
   results.orientationType =
       content::RenderWidgetHostViewBase::GetOrientationTypeForDesktop(display);
 
   return results;
 }
 
-void RemoveLayerFromSuperlayer(
-    base::scoped_nsobject<CompositingIOSurfaceLayer> layer) {
-  // Disable the fade-out animation as the layer is removed.
-  ScopedCAActionDisabler disabler;
-  [layer removeFromSuperlayer];
-}
-
 }  // namespace
 
 namespace content {
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, public:
 
 ui::Compositor* RenderWidgetHostViewMac::GetCompositor() const {
   if (browser_compositor_view_)
     return browser_compositor_view_->GetCompositor();
@@ skipping 82 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewMac, public:
 
 RenderWidgetHostViewMac::RenderWidgetHostViewMac(RenderWidgetHost* widget)
     : render_widget_host_(RenderWidgetHostImpl::From(widget)),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       can_compose_inline_(true),
       browser_compositor_view_placeholder_(
           new BrowserCompositorViewPlaceholderMac),
-      backing_store_scale_factor_(1),
       is_loading_(false),
       allow_pause_for_resize_or_repaint_(true),
       weak_factory_(this),
-      fullscreen_parent_host_view_(NULL),
-      software_frame_weak_ptr_factory_(this) {
-  software_frame_manager_.reset(new SoftwareFrameManager(
-      software_frame_weak_ptr_factory_.GetWeakPtr()));
+      fullscreen_parent_host_view_(NULL) {
   // |cocoa_view_| owns us and we will be deleted when |cocoa_view_|
   // goes away.  Since we autorelease it, our caller must put
   // |GetNativeView()| into the view hierarchy right after calling us.
   cocoa_view_ = [[[RenderWidgetHostViewCocoa alloc]
                   initWithRenderWidgetHostViewMac:this] autorelease];
 
   // Make this view host a solid white layer when there is no content ready to
   // draw.
   background_layer_.reset([[CALayer alloc] init]);
   [background_layer_
       setBackgroundColor:CGColorGetConstantColor(kCGColorWhite)];
   [cocoa_view_ setLayer:background_layer_];
   [cocoa_view_ setWantsLayer:YES];
 
-  if (!IsDelegatedRendererEnabled()) {
-    // Add a flipped transparent layer as a child, so that we don't need to
-    // fiddle with the position of sub-layers -- they will always be at the
-    // origin.
-    flipped_layer_.reset([[CALayer alloc] init]);
-    [flipped_layer_ setGeometryFlipped:YES];
-    [flipped_layer_
-        setAutoresizingMask:kCALayerWidthSizable|kCALayerHeightSizable];
-    [background_layer_ addSublayer:flipped_layer_];
-  }
-
-  if (IsDelegatedRendererEnabled()) {
-    root_layer_.reset(new ui::Layer(ui::LAYER_TEXTURED));
-    delegated_frame_host_.reset(new DelegatedFrameHost(this));
-  }
+  root_layer_.reset(new ui::Layer(ui::LAYER_TEXTURED));
+  delegated_frame_host_.reset(new DelegatedFrameHost(this));
 
   gfx::Screen::GetScreenFor(cocoa_view_)->AddObserver(this);
 
   render_widget_host_->SetView(this);
 }
 
 RenderWidgetHostViewMac::~RenderWidgetHostViewMac() {
   gfx::Screen::GetScreenFor(cocoa_view_)->RemoveObserver(this);
 
   // This is being called from |cocoa_view_|'s destructor, so invalidate the
   // pointer.
   cocoa_view_ = nil;
 
   UnlockMouse();
 
   // Ensure that the browser compositor is destroyed in a safe order.
   ShutdownBrowserCompositor();
 
-  // Make sure that the layer doesn't reach into the now-invalid object.
-  DestroyCompositedIOSurfaceAndLayer();
-  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_)
     render_widget_host_->SetView(NULL);
 }
 
 void RenderWidgetHostViewMac::SetDelegate(
     NSObject<RenderWidgetHostViewMacDelegate>* delegate) {
   [cocoa_view_ setResponderDelegate:delegate];
 }
 
 void RenderWidgetHostViewMac::SetAllowPauseForResizeOrRepaint(bool allow) {
   allow_pause_for_resize_or_repaint_ = allow;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewMac, RenderWidgetHostView implementation:
 
-bool RenderWidgetHostViewMac::EnsureCompositedIOSurface() {
-  // If the context or the IOSurface's context has had an error, re-build
-  // everything from scratch.
-  if (compositing_iosurface_context_ &&
-      compositing_iosurface_context_->HasBeenPoisoned()) {
-    LOG(ERROR) << "Failing EnsureCompositedIOSurface because "
-               << "context was poisoned";
-    return false;
-  }
-  if (compositing_iosurface_ &&
-      compositing_iosurface_->HasBeenPoisoned()) {
-    LOG(ERROR) << "Failing EnsureCompositedIOSurface because "
-               << "surface was poisoned";
-    return false;
-  }
-
-  int current_window_number =
-      CompositingIOSurfaceContext::kOffscreenContextWindowNumber;
-  bool new_surface_needed = !compositing_iosurface_;
-  bool new_context_needed =
-    !compositing_iosurface_context_ ||
-        (compositing_iosurface_context_ &&
-            compositing_iosurface_context_->window_number() !=
-                current_window_number);
-
-  if (!new_surface_needed && !new_context_needed)
-    return true;
-
-  // Create the GL context and shaders.
-  if (new_context_needed) {
-    scoped_refptr<CompositingIOSurfaceContext> new_context =
-        CompositingIOSurfaceContext::Get(current_window_number);
-    // Un-bind the GL context from this view before binding the new GL
-    // context. Having two GL contexts bound to a view will result in
-    // crashes and corruption.
-    // http://crbug.com/230883
-    if (!new_context) {
-      LOG(ERROR) << "Failed to create CompositingIOSurfaceContext";
-      return false;
-    }
-    compositing_iosurface_context_ = new_context;
-  }
-
-  // Create the IOSurface texture.
-  if (new_surface_needed) {
-    compositing_iosurface_ = CompositingIOSurfaceMac::Create();
-    if (!compositing_iosurface_) {
-      LOG(ERROR) << "Failed to create CompositingIOSurface";
-      return false;
-    }
-  }
-
-  return true;
-}
-
 void RenderWidgetHostViewMac::EnsureBrowserCompositorView() {
-  if (!delegated_frame_host_)
-    return;
   if (browser_compositor_view_)
     return;
 
   TRACE_EVENT0("browser",
                "RenderWidgetHostViewMac::EnsureBrowserCompositorView");
 
   browser_compositor_view_.reset(new BrowserCompositorViewMac(this));
   delegated_frame_host_->AddedToWindow();
   delegated_frame_host_->WasShown(ui::LatencyInfo());
 }
 
 void RenderWidgetHostViewMac::DestroyBrowserCompositorView() {
   TRACE_EVENT0("browser",
                "RenderWidgetHostViewMac::DestroyBrowserCompositorView");
   if (!browser_compositor_view_)
     return;
 
   // Marking the DelegatedFrameHost as removed from the window hierarchy is
   // necessary to remove all connections to its old ui::Compositor.
   delegated_frame_host_->WasHidden();
   delegated_frame_host_->RemovingFromWindow();
   browser_compositor_view_.reset();
 }
 
-void RenderWidgetHostViewMac::EnsureSoftwareLayer() {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewMac::EnsureSoftwareLayer");
-  if (software_layer_)
-    return;
-
-  software_layer_.reset([[SoftwareLayer alloc] init]);
-  DCHECK(software_layer_);
-
-  // Disable the fade-in animation as the layer is added.
-  ScopedCAActionDisabler disabler;
-  [flipped_layer_ addSublayer:software_layer_];
-}
-
-void RenderWidgetHostViewMac::DestroySoftwareLayer() {
-  if (!software_layer_)
-    return;
-
-  // Disable the fade-out animation as the layer is removed.
-  ScopedCAActionDisabler disabler;
-  [software_layer_ removeFromSuperlayer];
-  software_layer_.reset();
-}
-
-void RenderWidgetHostViewMac::EnsureCompositedIOSurfaceLayer() {
-  TRACE_EVENT0("browser",
-               "RenderWidgetHostViewMac::EnsureCompositedIOSurfaceLayer");
-  DCHECK(compositing_iosurface_context_);
-  if (compositing_iosurface_layer_)
-    return;
-
-  compositing_iosurface_layer_.reset([[CompositingIOSurfaceLayer alloc]
-      initWithIOSurface:compositing_iosurface_
-        withScaleFactor:compositing_iosurface_->scale_factor()
-             withClient:this]);
-  DCHECK(compositing_iosurface_layer_);
-
-  // Disable the fade-in animation as the layer is added.
-  ScopedCAActionDisabler disabler;
-  [flipped_layer_ addSublayer:compositing_iosurface_layer_];
-}
-
-void RenderWidgetHostViewMac::DestroyCompositedIOSurfaceLayer(
-    DestroyCompositedIOSurfaceLayerBehavior destroy_layer_behavior) {
-  if (!compositing_iosurface_layer_)
-    return;
-
-  if (destroy_layer_behavior == kRemoveLayerFromHierarchy) {
-    // Disable the fade-out animation as the layer is removed.
-    ScopedCAActionDisabler disabler;
-    [compositing_iosurface_layer_ removeFromSuperlayer];
-  }
-  [compositing_iosurface_layer_ resetClient];
-  compositing_iosurface_layer_.reset();
-}
-
-void RenderWidgetHostViewMac::DestroyCompositedIOSurfaceAndLayer() {
-  // Any pending frames will not be displayed, so ack them now.
-  SendPendingSwapAck();
-
-  DestroyCompositedIOSurfaceLayer(kRemoveLayerFromHierarchy);
-  compositing_iosurface_ = NULL;
-  compositing_iosurface_context_ = NULL;
-}
-
 bool RenderWidgetHostViewMac::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderWidgetHostViewMac, message)
     IPC_MESSAGE_HANDLER(ViewHostMsg_PluginFocusChanged, OnPluginFocusChanged)
     IPC_MESSAGE_HANDLER(ViewHostMsg_StartPluginIme, OnStartPluginIme)
     IPC_MESSAGE_HANDLER(ViewMsg_GetRenderedTextCompleted,
         OnGetRenderedTextCompleted)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
@@ skipping 135 matching lines @@
   render_widget_host_->UpdateVSyncParameters(vsync_timebase_, vsync_interval_);
 }
 
 void RenderWidgetHostViewMac::SpeakText(const std::string& text) {
   [NSApp speakString:base::SysUTF8ToNSString(text)];
 }
 
 void RenderWidgetHostViewMac::UpdateBackingStoreScaleFactor() {
   if (!render_widget_host_)
     return;
-
-  float new_scale_factor = ui::GetScaleFactorForNativeView(cocoa_view_);
-  if (new_scale_factor == backing_store_scale_factor_)
-    return;
-  backing_store_scale_factor_ = new_scale_factor;
-
   render_widget_host_->NotifyScreenInfoChanged();
 }
 
 RenderWidgetHost* RenderWidgetHostViewMac::GetRenderWidgetHost() const {
   return render_widget_host_;
 }
 
 void RenderWidgetHostViewMac::WasShown() {
   if (!render_widget_host_->is_hidden())
     return;
 
   ui::LatencyInfo renderer_latency_info;
-  if ((compositing_iosurface_ && compositing_iosurface_->HasIOSurface()) ||
-      software_frame_manager_->HasCurrentFrame() ||
-      (delegated_frame_host_ && delegated_frame_host_->HasSavedFrame())) {
-    ui::LatencyInfo browser_latency_info;
-    browser_latency_info.AddLatencyNumber(
-        ui::TAB_SHOW_COMPONENT,
-        render_widget_host_->GetLatencyComponentId(),
-        0);
-    pending_latency_info_.push_back(browser_latency_info);
-  } else {
-    renderer_latency_info.AddLatencyNumber(
-        ui::TAB_SHOW_COMPONENT,
-        render_widget_host_->GetLatencyComponentId(),
-        0);
-  }
-
+  renderer_latency_info.AddLatencyNumber(
+      ui::TAB_SHOW_COMPONENT,
+      render_widget_host_->GetLatencyComponentId(),
+      0);
   render_widget_host_->WasShown(renderer_latency_info);
-  software_frame_manager_->SetVisibility(true);
 
   // If there is not a frame being currently drawn, kick one, so that the below
   // pause will have a frame to wait on.
-  if (IsDelegatedRendererEnabled())
-    render_widget_host_->ScheduleComposite();
-
-  // Call setNeedsDisplay before pausing for new frames to come in -- if any
-  // do, and are drawn, then the needsDisplay bit will be cleared.
-  [compositing_iosurface_layer_ setNeedsDisplay];
+  render_widget_host_->ScheduleComposite();
   PauseForPendingResizeOrRepaintsAndDraw();
 }
 
 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();
-
   DestroyBrowserCompositorView();
 
   // 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);
 }
 
 void RenderWidgetHostViewMac::SetSize(const gfx::Size& size) {
   gfx::Rect rect = GetViewBounds();
   rect.set_size(size);
   SetBounds(rect);
 }
 
 void RenderWidgetHostViewMac::SetBounds(const gfx::Rect& rect) {
   // |rect.size()| is view coordinates, |rect.origin| is screen coordinates,
@@ skipping 73 matching lines @@
   [[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());
+  return false;
 }
 
 void RenderWidgetHostViewMac::Show() {
   [cocoa_view_ setHidden:NO];
 
   WasShown();
 }
 
 void RenderWidgetHostViewMac::Hide() {
   [cocoa_view_ setHidden:YES];
@@ skipping 230 matching lines @@
 }
 
 void RenderWidgetHostViewMac::CopyFromCompositingSurface(
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     const base::Callback<void(bool, const SkBitmap&)>& callback,
     const SkColorType color_type) {
   if (delegated_frame_host_) {
     delegated_frame_host_->CopyFromCompositingSurface(
         src_subrect, dst_size, callback, color_type);
-    return;
-  }
-
-  if (color_type != kN32_SkColorType) {
-    NOTIMPLEMENTED();
-    callback.Run(false, SkBitmap());
-  }
-  base::ScopedClosureRunner scoped_callback_runner(
-      base::Bind(callback, false, SkBitmap()));
-  float scale = ui::GetScaleFactorForNativeView(cocoa_view_);
-  gfx::Size dst_pixel_size = gfx::ToFlooredSize(
-      gfx::ScaleSize(dst_size, scale));
-  if (compositing_iosurface_ && compositing_iosurface_->HasIOSurface()) {
-    ignore_result(scoped_callback_runner.Release());
-    compositing_iosurface_->CopyTo(GetScaledOpenGLPixelRect(src_subrect),
-                                   dst_pixel_size,
-                                   callback);
-  } else if (software_frame_manager_->HasCurrentFrame()) {
-    gfx::Rect src_pixel_rect = gfx::ToEnclosingRect(gfx::ScaleRect(
-        src_subrect,
-        software_frame_manager_->GetCurrentFrameDeviceScaleFactor()));
-    SkBitmap source_bitmap;
-    SkImageInfo source_info = SkImageInfo::MakeN32(
-        software_frame_manager_->GetCurrentFrameSizeInPixels().width(),
-        software_frame_manager_->GetCurrentFrameSizeInPixels().height(),
-        kOpaque_SkAlphaType);
-    source_bitmap.installPixels(
-        source_info,
-        software_frame_manager_->GetCurrentFramePixels(),
-        source_info.minRowBytes());
-
-    SkBitmap target_bitmap;
-    if (!target_bitmap.allocN32Pixels(
-            dst_pixel_size.width(), dst_pixel_size.height(), true))
-      return;
-
-    SkCanvas target_canvas(target_bitmap);
-    SkRect src_pixel_skrect = SkRect::MakeXYWH(
-        src_pixel_rect.x(), src_pixel_rect.y(),
-        src_pixel_rect.width(), src_pixel_rect.height());
-    target_canvas.drawBitmapRectToRect(
-        source_bitmap,
-        &src_pixel_skrect,
-        SkRect::MakeXYWH(0, 0, dst_pixel_size.width(), dst_pixel_size.height()),
-        NULL,
-        SkCanvas::kNone_DrawBitmapRectFlag);
-
-    ignore_result(scoped_callback_runner.Release());
-    callback.Run(true, target_bitmap);
-  } else {
-    callback.Run(false, SkBitmap());
   }
 }
 
 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 (!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() &&
-          compositing_iosurface_ &&
-          compositing_iosurface_->HasIOSurface());
+  return false;
 }
 
 bool RenderWidgetHostViewMac::CanSubscribeFrame() const {
   if (delegated_frame_host_)
     return delegated_frame_host_->CanSubscribeFrame();
-
-  return !software_frame_manager_->HasCurrentFrame();
+  return false;
 }
 
 void RenderWidgetHostViewMac::BeginFrameSubscription(
     scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
-  if (delegated_frame_host_) {
+  if (delegated_frame_host_)
     delegated_frame_host_->BeginFrameSubscription(subscriber.Pass());
-    return;
-  }
-  frame_subscriber_ = subscriber.Pass();
 }
 
 void RenderWidgetHostViewMac::EndFrameSubscription() {
-  if (delegated_frame_host_) {
+  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_)
     render_widget_host_->ForwardMouseEvent(event);
@@ skipping 27 matching lines @@
 }
 
 void RenderWidgetHostViewMac::PluginImeCompositionCompleted(
     const base::string16& text, int plugin_id) {
   if (render_widget_host_) {
     render_widget_host_->Send(new ViewMsg_PluginImeCompositionCompleted(
         render_widget_host_->GetRoutingID(), text, plugin_id));
   }
 }
 
-void RenderWidgetHostViewMac::CompositorSwapBuffers(
-    IOSurfaceID surface_handle,
-    const gfx::Rect& damage_rect,
-    const gfx::Size& size,
-    float surface_scale_factor,
-    const std::vector<ui::LatencyInfo>& latency_info) {
-  // Ensure that the frame be acked unless it is explicitly passed to a
-  // display function.
-  base::ScopedClosureRunner scoped_ack(
-      base::Bind(&RenderWidgetHostViewMac::SendPendingSwapAck,
-                 weak_factory_.GetWeakPtr()));
-
-  if (render_widget_host_->is_hidden())
-    return;
-
-  // Ensure that if this function exits before the frame is set up (but not
-  // necessarily drawn) then it is treated as an error.
-  base::ScopedClosureRunner scoped_error(
-      base::Bind(&RenderWidgetHostViewMac::GotAcceleratedCompositingError,
-                 weak_factory_.GetWeakPtr()));
-
-  AddPendingLatencyInfo(latency_info);
-
-  // If compositing_iosurface_ exists and has been poisoned, destroy it
-  // and allow EnsureCompositedIOSurface to recreate it below. Keep a
-  // reference to the destroyed layer around until after the below call
-  // to LayoutLayers, to avoid flickers.
-  base::ScopedClosureRunner scoped_layer_remover;
-  if (compositing_iosurface_context_ &&
-      compositing_iosurface_context_->HasBeenPoisoned()) {
-    scoped_layer_remover.Reset(
-        base::Bind(RemoveLayerFromSuperlayer, compositing_iosurface_layer_));
-    DestroyCompositedIOSurfaceLayer(kLeaveLayerInHierarchy);
-    DestroyCompositedIOSurfaceAndLayer();
-  }
-
-  // Ensure compositing_iosurface_ and compositing_iosurface_context_ be
-  // allocated.
-  if (!EnsureCompositedIOSurface()) {
-    LOG(ERROR) << "Failed EnsureCompositingIOSurface";
-    return;
-  }
-
-  // Make the context current and update the IOSurface with the handle
-  // passed in by the swap command.
-  {
-    gfx::ScopedCGLSetCurrentContext scoped_set_current_context(
-        compositing_iosurface_context_->cgl_context());
-    if (!compositing_iosurface_->SetIOSurfaceWithContextCurrent(
-            compositing_iosurface_context_, surface_handle, size,
-            surface_scale_factor)) {
-      LOG(ERROR) << "Failed SetIOSurface on CompositingIOSurfaceMac";
-      return;
-    }
-  }
-
-  // Grab video frames now that the IOSurface has been set up. Note that this
-  // will be done in an offscreen context, so it is necessary to re-set the
-  // current context afterward.
-  bool frame_was_captured = false;
-  if (frame_subscriber_) {
-    const base::TimeTicks now = gfx::FrameTime::Now();
-    base::TimeTicks present_time;
-    if (vsync_timebase_.is_null() || vsync_interval_ <= base::TimeDelta()) {
-      present_time = now;
-    } else {
-      const int64 intervals_elapsed = (now - vsync_timebase_) / vsync_interval_;
-      present_time = vsync_timebase_ +
-          (intervals_elapsed + 1) * vsync_interval_;
-    }
-
-    scoped_refptr<media::VideoFrame> frame;
-    RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback callback;
-    if (frame_subscriber_->ShouldCaptureFrame(
-            damage_rect, present_time, &frame, &callback)) {
-      // Flush the context that updated the IOSurface, to ensure that the
-      // context that does the copy picks up the correct version.
-      {
-        gfx::ScopedCGLSetCurrentContext scoped_set_current_context(
-            compositing_iosurface_context_->cgl_context());
-        glFlush();
-      }
-      compositing_iosurface_->CopyToVideoFrame(
-          gfx::Rect(size), frame,
-          base::Bind(callback, present_time));
-      frame_was_captured = true;
-    }
-  }
-
-  // At this point the surface, its context, and its layer have been set up, so
-  // don't generate an error (one may be generated when drawing).
-  ignore_result(scoped_error.Release());
-
-  GotAcceleratedFrame();
-
-  gfx::Size window_size(NSSizeToCGSize([cocoa_view_ frame].size));
-  if (window_size.IsEmpty()) {
-    // setNeedsDisplay will never display and we'll never ack if the window is
-    // empty, so ack now and don't bother calling setNeedsDisplay below.
-    return;
-  }
-  if (window_number() <= 0) {
-    // It's normal for a backgrounded tab that is being captured to have no
-    // window but not be hidden. Immediately ack the frame, and don't try to
-    // draw it.
-    if (frame_was_captured)
-      return;
-
-    // If this frame was not captured, there is likely some sort of bug. Ack
-    // the frame and hope for the best. Because the IOSurface and layer are
-    // populated, it will likely be displayed when the view is added to a
-    // window's hierarchy.
-
-    // TODO(shess) If the view does not have a window, or the window
-    // does not have backing, the IOSurface will log "invalid drawable"
-    // in -setView:.  It is not clear how this code is reached with such
-    // a case, so record some info into breakpad (some subset of
-    // browsers are likely to crash later for unrelated reasons).
-    // http://crbug.com/148882
-    const char* const kCrashKey = "rwhvm_window";
-    NSWindow* window = [cocoa_view_ window];
-    if (!window) {
-      base::debug::SetCrashKeyValue(kCrashKey, "Missing window");
-    } else {
-      std::string value =
-          base::StringPrintf("window %s delegate %s controller %s",
-              object_getClassName(window),
-              object_getClassName([window delegate]),
-              object_getClassName([window windowController]));
-      base::debug::SetCrashKeyValue(kCrashKey, value);
-    }
-    return;
-  }
-
-  // If we reach here, then the frame will be displayed by a future draw
-  // call, so don't make the callback.
-  ignore_result(scoped_ack.Release());
-  DCHECK(compositing_iosurface_layer_);
-  [compositing_iosurface_layer_ gotNewFrame];
-
-  // Try to finish previous copy requests after draw to get better pipelining.
-  if (compositing_iosurface_)
-    compositing_iosurface_->CheckIfAllCopiesAreFinished(false);
-
-  // The IOSurface's size may have changed, so re-layout the layers to take
-  // this into account. This may force an immediate draw.
-  LayoutLayers();
-}
-
-void RenderWidgetHostViewMac::GotAcceleratedCompositingError() {
-  LOG(ERROR) << "Encountered accelerated compositing error";
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE,
-      base::Bind(&RenderWidgetHostViewMac::DestroyCompositingStateOnError,
-                 weak_factory_.GetWeakPtr()));
-}
-
-void RenderWidgetHostViewMac::DestroyCompositingStateOnError() {
-  // This should be called with a clean stack. Make sure that no context is
-  // current.
-  DCHECK(!CGLGetCurrentContext());
-
-  // The existing GL contexts may be in a bad state, so don't re-use any of the
-  // existing ones anymore, rather, allocate new ones.
-  if (compositing_iosurface_context_)
-    compositing_iosurface_context_->PoisonContextAndSharegroup();
-
-  DestroyCompositedIOSurfaceAndLayer();
-
-  // Request that a new frame be generated and dirty the view.
-  if (render_widget_host_)
-    render_widget_host_->ScheduleComposite();
-  [cocoa_view_ setNeedsDisplay:YES];
-
-  // TODO(ccameron): It may be a good idea to request that the renderer recreate
-  // its GL context as well, and fall back to software if this happens
-  // repeatedly.
-}
-
 bool RenderWidgetHostViewMac::GetLineBreakIndex(
     const std::vector<gfx::Rect>& bounds,
     const gfx::Range& range,
     size_t* line_break_point) {
   DCHECK(line_break_point);
   if (range.start() >= bounds.size() || range.is_reversed() || range.is_empty())
     return false;
 
   // We can't check line breaking completely from only rectangle array. Thus we
   // assume the line breaking as the next character's y offset is larger than
@@ skipping 116 matching lines @@
     *actual_range = gfx::Range(
         composition_range_.start() + ui_actual_range.start(),
         composition_range_.start() + ui_actual_range.end()).ToNSRange();
   }
   return true;
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params,
     int gpu_host_id) {
-  TRACE_EVENT0("browser",
-      "RenderWidgetHostViewMac::AcceleratedSurfaceBuffersSwapped");
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  AddPendingSwapAck(params.route_id,
-                    gpu_host_id,
-                    compositing_iosurface_ ?
-                        compositing_iosurface_->GetRendererID() : 0);
-
-  switch (GetSurfaceHandleType(params.surface_handle)) {
-    case kSurfaceHandleTypeIOSurface: {
-      IOSurfaceID io_surface_id = IOSurfaceIDFromSurfaceHandle(
-          params.surface_handle);
-
-      CompositorSwapBuffers(io_surface_id,
-                            gfx::Rect(),
-                            params.size,
-                            params.scale_factor,
-                            params.latency_info);
-    } break;
-    case kSurfaceHandleTypeCAContext: {
-      // Disable the fade-out animation as the layer is added.
-      ScopedCAActionDisabler disabler;
-
-      CAContextID context_id = CAContextIDFromSurfaceHandle(
-          params.surface_handle);
-
-      // If if the layer has changed put the new layer in the hierarchy and
-      // take the old one out.
-      if ([remote_layer_host_ contextId] != context_id) {
-        [remote_layer_host_ removeFromSuperlayer];
-
-        remote_layer_host_.reset([[CALayerHost alloc] init]);
-        [remote_layer_host_ setContextId:context_id];
-        [remote_layer_host_
-            setAutoresizingMask:kCALayerMaxXMargin|kCALayerMaxYMargin];
-        [flipped_layer_ addSublayer:remote_layer_host_];
-      }
-
-      // Ack the frame immediately. Any GPU back pressure will be applied by
-      // the remote layer from within the GPU process.
-      SendPendingSwapAck();
-    } break;
-    default:
-      LOG(ERROR) << "Invalid surface handle type.";
-      break;
-  }
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
-  TRACE_EVENT0("browser",
-      "RenderWidgetHostViewMac::AcceleratedSurfacePostSubBuffer");
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  AddPendingSwapAck(params.route_id,
-                    gpu_host_id,
-                    compositing_iosurface_ ?
-                        compositing_iosurface_->GetRendererID() : 0);
-  CompositorSwapBuffers(
-      IOSurfaceIDFromSurfaceHandle(params.surface_handle),
-      gfx::Rect(params.x, params.y, params.width, params.height),
-      params.surface_size,
-      params.surface_scale_factor,
-      params.latency_info);
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceSuspend() {
-  if (render_widget_host_->is_hidden())
-    DestroyCompositedIOSurfaceAndLayer();
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceRelease() {
-  DestroyCompositedIOSurfaceAndLayer();
 }
 
 bool RenderWidgetHostViewMac::HasAcceleratedSurface(
       const gfx::Size& desired_size) {
   if (browser_compositor_view_)
     return browser_compositor_view_->HasFrameOfSize(desired_size);
-  if (compositing_iosurface_) {
-    return compositing_iosurface_->HasIOSurface() &&
-           (desired_size.IsEmpty() ||
-               compositing_iosurface_->dip_io_surface_size() == desired_size);
-  }
-  if (software_frame_manager_->HasCurrentFrame()) {
-    return (desired_size.IsEmpty() ||
-               software_frame_manager_->GetCurrentFrameSizeInDIP() ==
-                   desired_size);
-  }
   return false;
 }
 
 void RenderWidgetHostViewMac::OnSwapCompositorFrame(
     uint32 output_surface_id, scoped_ptr<cc::CompositorFrame> frame) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewMac::OnSwapCompositorFrame");
 
   if (frame->delegated_frame_data) {
     float scale_factor = frame->metadata.device_scale_factor;
 
@@ skipping 11 matching lines @@
           scale_factor, pixel_size);
     }
 
     SendVSyncParametersToRenderer();
 
     delegated_frame_host_->SwapDelegatedFrame(
         output_surface_id,
         frame->delegated_frame_data.Pass(),
         frame->metadata.device_scale_factor,
         frame->metadata.latency_info);
-  } 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);
-
-    const void* pixels = software_frame_manager_->GetCurrentFramePixels();
-    gfx::Size size_in_pixels =
-        software_frame_manager_->GetCurrentFrameSizeInPixels();
-
-    EnsureSoftwareLayer();
-    [software_layer_ setContentsToData:pixels
-                          withRowBytes:4 * size_in_pixels.width()
-                         withPixelSize:size_in_pixels
-                       withScaleFactor:frame->metadata.device_scale_factor];
-
-    // Send latency information to the host immediately, as there will be no
-    // subsequent draw call in which to do so.
-    SendPendingLatencyInfoToHost();
-
-    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();
   }
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceInitialized(int host_id,
                                                             int route_id) {
@@ skipping 60 matching lines @@
     [cocoa_view_ processedWheelEvent:event consumed:consumed];
 }
 
 bool RenderWidgetHostViewMac::Send(IPC::Message* message) {
   if (render_widget_host_)
     return render_widget_host_->Send(message);
   delete message;
   return false;
 }
 
-void RenderWidgetHostViewMac::SoftwareFrameWasFreed(
-    uint32 output_surface_id, unsigned frame_id) {
-  if (!render_widget_host_)
-    return;
-  cc::CompositorFrameAck ack;
-  ack.last_software_frame_id = frame_id;
-  RenderWidgetHostImpl::SendReclaimCompositorResources(
-      render_widget_host_->GetRoutingID(),
-      output_surface_id,
-      render_widget_host_->GetProcess()->GetID(),
-      ack);
-}
-
-void RenderWidgetHostViewMac::ReleaseReferencesToSoftwareFrame() {
-  DestroySoftwareLayer();
-}
-
 void RenderWidgetHostViewMac::ShutdownHost() {
   weak_factory_.InvalidateWeakPtrs();
   render_widget_host_->Shutdown();
   // Do not touch any members at this point, |this| has been deleted.
 }
 
 void RenderWidgetHostViewMac::ShutdownBrowserCompositor() {
   DestroyBrowserCompositorView();
   delegated_frame_host_.reset();
   root_layer_.reset();
   browser_compositor_view_placeholder_.reset();
 }
 
-void RenderWidgetHostViewMac::GotAcceleratedFrame() {
-  EnsureCompositedIOSurfaceLayer();
-  SendVSyncParametersToRenderer();
-
-  // Delete software backingstore and layer.
-  software_frame_manager_->DiscardCurrentFrame();
-  DestroySoftwareLayer();
-}
-
-void RenderWidgetHostViewMac::GotSoftwareFrame() {
-  TRACE_EVENT0("browser", "RenderWidgetHostViewMac::GotSoftwareFrame");
-
-  if (!render_widget_host_)
-    return;
-
-  EnsureSoftwareLayer();
-  LayoutLayers();
-  SendVSyncParametersToRenderer();
-
-  // Draw the contents of the frame immediately. It is critical that this
-  // happen before the frame be acked, otherwise the new frame will likely be
-  // ready before the drawing is complete, thrashing the browser main thread.
-  [software_layer_ displayIfNeeded];
-
-  DestroyCompositedIOSurfaceAndLayer();
-}
-
 void RenderWidgetHostViewMac::SetActive(bool active) {
   if (render_widget_host_) {
     render_widget_host_->SetActive(active);
     if (active) {
       if (HasFocus())
         render_widget_host_->Focus();
     } else {
       render_widget_host_->Blur();
     }
   }
@@ skipping 88 matching lines @@
 
 void RenderWidgetHostViewMac::OnStartPluginIme() {
   [cocoa_view_ setPluginImeActive:YES];
 }
 
 void RenderWidgetHostViewMac::OnGetRenderedTextCompleted(
     const std::string& text) {
   SpeakText(text);
 }
 
-gfx::Rect RenderWidgetHostViewMac::GetScaledOpenGLPixelRect(
-    const gfx::Rect& rect) {
-  gfx::Rect src_gl_subrect = rect;
-  src_gl_subrect.set_y(GetViewBounds().height() - rect.bottom());
-
-  return gfx::ToEnclosingRect(gfx::ScaleRect(src_gl_subrect,
-                                             ViewScaleFactor()));
-}
-
-void RenderWidgetHostViewMac::AddPendingLatencyInfo(
-    const std::vector<ui::LatencyInfo>& latency_info) {
-  for (size_t i = 0; i < latency_info.size(); i++) {
-    pending_latency_info_.push_back(latency_info[i]);
-  }
-}
-
-void RenderWidgetHostViewMac::SendPendingLatencyInfoToHost() {
-  for (size_t i = 0; i < pending_latency_info_.size(); i++) {
-    pending_latency_info_[i].AddLatencyNumber(
-        ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 0, 0);
-    render_widget_host_->FrameSwapped(pending_latency_info_[i]);
-  }
-  pending_latency_info_.clear();
-}
-
-void RenderWidgetHostViewMac::AddPendingSwapAck(
-    int32 route_id, int gpu_host_id, int32 renderer_id) {
-  // Note that multiple un-acked swaps can come in the event of a GPU process
-  // loss. Drop the old acks.
-  pending_swap_ack_.reset(new PendingSwapAck(
-      route_id, gpu_host_id, renderer_id));
-}
-
-void RenderWidgetHostViewMac::SendPendingSwapAck() {
-  if (!pending_swap_ack_)
-    return;
-
-  AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
-  ack_params.sync_point = 0;
-  ack_params.renderer_id = pending_swap_ack_->renderer_id;
-  RenderWidgetHostImpl::AcknowledgeBufferPresent(pending_swap_ack_->route_id,
-                                                 pending_swap_ack_->gpu_host_id,
-                                                 ack_params);
-  pending_swap_ack_.reset();
-}
-
 void RenderWidgetHostViewMac::PauseForPendingResizeOrRepaintsAndDraw() {
   if (!render_widget_host_ || render_widget_host_->is_hidden())
     return;
 
   // Pausing for one view prevents others from receiving frames.
   // This may lead to large delays, causing overlaps. See crbug.com/352020.
   if (!allow_pause_for_resize_or_repaint_)
     return;
 
-  // Ensure that all frames are acked before waiting for a frame to come in.
-  // Note that we will draw a frame at the end of this function, so it is safe
-  // to ack a never-drawn frame here.
-  SendPendingSwapAck();
-
   // Wait for a frame of the right size to come in.
   if (browser_compositor_view_)
     browser_compositor_view_->BeginPumpingFrames();
   render_widget_host_->PauseForPendingResizeOrRepaints();
   if (browser_compositor_view_)
     browser_compositor_view_->EndPumpingFrames();
-
-  // Immediately draw any frames that haven't been drawn yet. This is necessary
-  // to keep the window and the window's contents in sync.
-  [cocoa_view_ displayIfNeeded];
-  [software_layer_ displayIfNeeded];
-  [compositing_iosurface_layer_ displayIfNeededAndAck];
-}
-
-void RenderWidgetHostViewMac::LayoutLayers() {
-  if (delegated_frame_host_) {
-    return;
-  }
-
-  // Disable animation of the layer's resizing or change in contents scale.
-  ScopedCAActionDisabler disabler;
-
-  // Dynamically calling setContentsScale on a CAOpenGLLayer for which
-  // setAsynchronous is dynamically toggled can result in flashes of corrupt
-  // content. Work around this by replacing the entire layer when the scale
-  // factor changes.
-  if (compositing_iosurface_ &&
-      [compositing_iosurface_layer_
-          respondsToSelector:(@selector(contentsScale))]) {
-    if (compositing_iosurface_->scale_factor() !=
-        [compositing_iosurface_layer_ contentsScale]) {
-      DestroyCompositedIOSurfaceLayer(kRemoveLayerFromHierarchy);
-      EnsureCompositedIOSurfaceLayer();
-    }
-  }
-  if (compositing_iosurface_ &&
-      compositing_iosurface_->HasIOSurface() &&
-      compositing_iosurface_layer_) {
-    CGRect layer_bounds = CGRectMake(
-      0,
-      0,
-      compositing_iosurface_->dip_io_surface_size().width(),
-      compositing_iosurface_->dip_io_surface_size().height());
-    bool bounds_changed = !CGRectEqualToRect(
-        layer_bounds, [compositing_iosurface_layer_ bounds]);
-    [compositing_iosurface_layer_ setBounds:layer_bounds];
-
-    // If the bounds changed, then draw the frame immediately, to ensure that
-    // content displayed is in sync with the window size.
-    if (bounds_changed) {
-      // Also, sometimes, especially when infobars are being removed, the
-      // setNeedsDisplay calls are dropped on the floor, and stale content is
-      // displayed. Calling displayIfNeeded will ensure that the right size
-      // frame is drawn to the screen.
-      // http://crbug.com/350817
-      [compositing_iosurface_layer_ setNeedsDisplayAndDisplayAndAck];
-    }
-  }
 }
 
 SkColorType RenderWidgetHostViewMac::PreferredReadbackFormat() {
   return kN32_SkColorType;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // CompositingIOSurfaceLayerClient, public:
 
 bool RenderWidgetHostViewMac::AcceleratedLayerShouldAckImmediately() const {
   // If vsync is disabled, then always draw and ack frames immediately.
   static bool is_vsync_disabled =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableGpuVsync);
   if (is_vsync_disabled)
     return true;
 
   // If the window is occluded, then this frame's display call may be severely
   // throttled. This is a good thing, unless tab capture may be active, because
   // the broadcast will be inappropriately throttled.
   // http://crbug.com/350410
 
   // If tab capture isn't active then only ack frames when we draw them.
-  if (delegated_frame_host_) {
-    if (!delegated_frame_host_->HasFrameSubscriber())
-      return false;
-  } else {
-    if (!frame_subscriber_)
-      return false;
-  }
+  if (delegated_frame_host_ && !delegated_frame_host_->HasFrameSubscriber())
+    return false;
 
   NSWindow* window = [cocoa_view_ window];
   // If the view isn't even in the heirarchy then frames will never be drawn,
   // so ack them immediately.
   if (!window)
     return true;
 
   // Check the window occlusion API.
   if ([window respondsToSelector:@selector(occlusionState)]) {
     if ([window occlusionState] & NSWindowOcclusionStateVisible) {
       // If the window is visible then it is safe to wait until frames are
       // drawn to ack them.
       return false;
     } else {
       // If the window is occluded then frames may never be drawn, so ack them
       // immediately.
       return true;
     }
   }
 
   // If the window occlusion API is not present then ack frames when we draw
   // them.
   return false;
 }
 
 void RenderWidgetHostViewMac::AcceleratedLayerDidDrawFrame() {
-  if (!render_widget_host_)
-    return;
-
-  SendPendingLatencyInfoToHost();
-  SendPendingSwapAck();
 }
 
 void RenderWidgetHostViewMac::AcceleratedLayerHitError() {
-  if (!render_widget_host_)
-    return;
-  // Perform all acks that would have been done if the frame had succeeded, to
-  // un-block the renderer.
-  AcceleratedLayerDidDrawFrame();
-  GotAcceleratedCompositingError();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // gfx::DisplayObserver, public:
 
 void RenderWidgetHostViewMac::OnDisplayAdded(const gfx::Display& display) {
 }
 
 void RenderWidgetHostViewMac::OnDisplayRemoved(const gfx::Display& display) {
 }
@@ skipping 19 matching lines @@
 - (id)initWithRenderWidgetHostViewMac:(RenderWidgetHostViewMac*)r {
   self = [super initWithFrame:NSZeroRect];
   if (self) {
     self.acceptsTouchEvents = YES;
     editCommand_helper_.reset(new RenderWidgetHostViewMacEditCommandHelper);
     editCommand_helper_->AddEditingSelectorsToClass([self class]);
 
     renderWidgetHostView_.reset(r);
     canBeKeyView_ = YES;
     focusedPluginIdentifier_ = -1;
-    renderWidgetHostView_->backing_store_scale_factor_ =
-        ui::GetScaleFactorForNativeView(self);
 
     // OpenGL support:
     if ([self respondsToSelector:
         @selector(setWantsBestResolutionOpenGLSurface:)]) {
       [self setWantsBestResolutionOpenGLSurface:YES];
     }
-    handlingGlobalFrameDidChange_ = NO;
     [[NSNotificationCenter defaultCenter]
         addObserver:self
            selector:@selector(didChangeScreenParameters:)
                name:NSApplicationDidChangeScreenParametersNotification
              object:nil];
   }
   return self;
 }
 
 - (void)dealloc {
@@ skipping 693 matching lines @@
 - (void)setFrameSize:(NSSize)newSize {
   TRACE_EVENT0("browser", "RenderWidgetHostViewCocoa::setFrameSize");
 
   // NB: -[NSView setFrame:] calls through -setFrameSize:, so overriding
   // -setFrame: isn't neccessary.
   [super setFrameSize:newSize];
 
   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();
@@ skipping 936 matching lines @@
 
 // "-webkit-app-region: drag | no-drag" is implemented on Mac by excluding
 // regions that are not draggable. (See ControlRegionView in
 // native_app_window_cocoa.mm). This requires the render host view to be
 // draggable by default.
 - (BOOL)mouseDownCanMoveWindow {
   return YES;
 }
 
 @end