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 265 matching lines @@
   // Disable the fade-out animation as the layer is removed.
   ScopedCAActionDisabler disabler;
   [layer removeFromSuperlayer];
 }
 
 }  // namespace
 
 namespace content {
 
 ///////////////////////////////////////////////////////////////////////////////
+// RenderWidgetHelper, public:
+
+void RenderWidgetHelper::OnNativeSurfaceBuffersSwapped(
+    GpuProcessHost* gpu_process_host,
+    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.
+    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));
+
+    gpu_process_host = NULL;
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&OnNativeSurfaceBuffersSwapped, gpu_process_host, params));

[piman, 2014/05/06 20:02:54]

It kinda calls for having a different function for the UI thread.
OnNativeSurfaceBuffersSwappedOnIO vs OnNativeSurfaceBuffersSwappedOnUI

That way we can DCHECK the thread and verify that the right thing is done (e.g.
calling OnNativeSurfaceBuffersSwapped directly on the UI thread would miss a
critical part).

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

Done.

+    return;
+  }
+
+  gfx::AcceleratedWidget native_widget =
+      GpuSurfaceTracker::Get()->AcquireNativeWidget(params.surface_id);
+  [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) {
+    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()));
+    }
+    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);
+    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