Unobfuscate RWHVMac accelerated compositing code path by separating it from plugin code

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"
 
 #include <QuartzCore/QuartzCore.h>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/closure_blocks_leopard_compat.h"
 #include "base/mac/scoped_cftyperef.h"
 #import "base/mac/scoped_nsautorelease_pool.h"
 #import "base/memory/scoped_nsobject.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #import "content/browser/accessibility/browser_accessibility_cocoa.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/plugin_process_host.h"
 #import "content/browser/renderer_host/accelerated_plugin_view_mac.h"
 #include "content/browser/renderer_host/backing_store_mac.h"
+#include "content/browser/renderer_host/compositing_iosurface_mac.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.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/plugin_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 198 matching lines @@
 RenderWidgetHostViewMac::RenderWidgetHostViewMac(RenderWidgetHost* widget)
     : render_widget_host_(RenderWidgetHostImpl::From(widget)),
       about_to_validate_and_paint_(false),
       call_set_needs_display_in_rect_pending_(false),
       last_frame_was_accelerated_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       can_compose_inline_(true),
       is_loading_(false),
       is_hidden_(false),
       weak_factory_(this),
-      accelerated_compositing_active_(false),
-      needs_gpu_visibility_update_after_repaint_(false),
       compositing_surface_(gfx::kNullPluginWindow) {
   // |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];
   render_widget_host_->SetView(this);
 }
 
 RenderWidgetHostViewMac::~RenderWidgetHostViewMac() {
@@ skipping 46 matching lines @@
 }
 
 void RenderWidgetHostViewMac::DidBecomeSelected() {
   if (!is_hidden_)
     return;
 
   if (tab_switch_paint_time_.is_null())
     tab_switch_paint_time_ = base::TimeTicks::Now();
   is_hidden_ = false;
   render_widget_host_->WasRestored();
+
+  // We're messing with the window, so do this to ensure no flashes.
+  [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
 }
 
 void RenderWidgetHostViewMac::WasHidden() {
   if (is_hidden_)
     return;
 
   // If we receive any more paint messages while we are hidden, we want to
   // ignore them so we don't re-allocate the backing store.  We will paint
   // everything again when we become selected again.
   is_hidden_ = true;
 
+  // Send ACKs for any pending SwapBuffers (if any) since we won't be displaying
+  // them and the GPU process is waiting.
+  CompositorSwapBuffersComplete();
+
   // If we have a renderer, then inform it that we are being hidden so it can
   // reduce its resource utilization.
   render_widget_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.
+  [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
 }
 
 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 249 matching lines @@
           invalid_rect_ = NSUnionRect(invalid_rect_, ns_rect);
         }
       } else {
         [cocoa_view_ setNeedsDisplayInRect:ns_rect];
       }
     }
 
     if (!about_to_validate_and_paint_)
       [cocoa_view_ displayIfNeeded];
   }
-
-  // If |about_to_validate_and_paint_| is set, then -drawRect: is on the stack
-  // and it's not allowed to call -setHidden on the accelerated view.  In that
-  // case, -callSetNeedsDisplayInRect: will hide it later.
-  // If |about_to_validate_and_paint_| is not set, do it now.
-  if (!about_to_validate_and_paint_)
-    HandleDelayedGpuViewHiding();
 }
 
 void RenderWidgetHostViewMac::RenderViewGone(base::TerminationStatus status,
                                              int error_code) {
   Destroy();
 }
 
 void RenderWidgetHostViewMac::Destroy() {
   // On Windows, popups are implemented with a popup window style, so that when
   // an event comes in that would "cancel" it, it receives the OnCancelMode
@@ skipping 223 matching lines @@
 
 AcceleratedPluginView* RenderWidgetHostViewMac::ViewForPluginWindowHandle(
     gfx::PluginWindowHandle window) {
   PluginViewMap::iterator it = plugin_views_.find(window);
   DCHECK(plugin_views_.end() != it);
   if (plugin_views_.end() == it)
     return nil;
   return it->second;
 }
 
-void RenderWidgetHostViewMac::UpdatePluginGeometry(
-    gfx::PluginWindowHandle window,
-    int32 width,
-    int32 height) {
-  if (plugin_container_manager_.IsRootContainer(window)) {
-    // Fake up a WebPluginGeometry for the root window to set the
-    // container's size; we will never get a notification from the
-    // browser about the root window, only plugins.
-    webkit::npapi::WebPluginGeometry geom;
-    gfx::Rect rect(0, 0, width, height);
-    geom.window = window;
-    geom.window_rect = rect;
-    geom.clip_rect = rect;
-    geom.visible = true;
-    geom.rects_valid = true;
-    MovePluginWindows(std::vector<webkit::npapi::WebPluginGeometry>(1, geom));
-  }
-}
-
 void RenderWidgetHostViewMac::AcceleratedSurfaceSetIOSurface(
     gfx::PluginWindowHandle window,
     int32 width,
     int32 height,
     uint64 io_surface_identifier) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   plugin_container_manager_.SetSizeAndIOSurface(window,
                                                 width,
                                                 height,
                                                 io_surface_identifier);
-  UpdatePluginGeometry(window, width, height);
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceSetTransportDIB(
     gfx::PluginWindowHandle window,
     int32 width,
     int32 height,
     TransportDIB::Handle transport_dib) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   plugin_container_manager_.SetSizeAndTransportDIB(window,
                                                    width,
                                                    height,
                                                    transport_dib);
-  UpdatePluginGeometry(window, width, height);
+}
+
+void RenderWidgetHostViewMac::CompositorSwapBuffers(uint64 surface_handle,
+                                                    int32 route_id,
+                                                    int32 gpu_host_id) {
+  pending_swap_buffers_acks_.push_back(std::make_pair(route_id, gpu_host_id));
+  if (!compositing_iosurface_.get() && !is_hidden_) {
+    [cocoa_view_ addedGLContext];
+    compositing_iosurface_.reset(CompositingIOSurfaceMac::Create());
+  }
+
+  if (compositing_iosurface_.get() && !is_hidden_) {
+    last_frame_was_accelerated_ = true;
+    compositing_iosurface_->SetIOSurface(surface_handle);
+    [cocoa_view_ setNeedsDisplay:YES];
+  } else {
+    CompositorSwapBuffersComplete();
+  }
+}
+
+void RenderWidgetHostViewMac::CompositorSwapBuffersComplete() {
+  TRACE_EVENT0("browser",
+               "RenderWidgetHostViewMac::CompositorSwapBuffersComplete");
+  while (!pending_swap_buffers_acks_.empty()) {
+    if (pending_swap_buffers_acks_.front().first != 0) {
+      RenderWidgetHostImpl::AcknowledgeSwapBuffers(
+          pending_swap_buffers_acks_.front().first,
+          pending_swap_buffers_acks_.front().second);
+    }
+    pending_swap_buffers_acks_.erase(pending_swap_buffers_acks_.begin());
+  }
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params,
     int gpu_host_id) {
   TRACE_EVENT0("browser",
       "RenderWidgetHostViewMac::AcceleratedSurfaceBuffersSwapped");
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  AcceleratedPluginView* view = ViewForPluginWindowHandle(params.window);
-  DCHECK(view);
-  if (view) {
-    last_frame_was_accelerated_ = (params.window ==
-        plugin_container_manager_.root_container_handle());
-    plugin_container_manager_.SetSurfaceWasPaintedTo(params.window,
-                                                     params.surface_handle);
 
-    // The surface is hidden until its first paint, to not show garbage.
-    if (plugin_container_manager_.SurfaceShouldBeVisible(params.window))
-      [view setHidden:NO];
-    [view drawView];
-  }
+  if (params.window == compositing_surface_) {
+    CompositorSwapBuffers(params.surface_handle, params.route_id, gpu_host_id);
+  } else {
+    // Deprecated accelerated plugin code path.
+    AcceleratedPluginView* view = ViewForPluginWindowHandle(params.window);
+    DCHECK(view);
+    if (view) {
+      plugin_container_manager_.SetSurfaceWasPaintedTo(params.window,
+                                                       params.surface_handle);
 
-  if (params.route_id != 0) {
-    RenderWidgetHostImpl::AcknowledgeSwapBuffers(params.route_id, gpu_host_id);
+      // The surface is hidden until its first paint, to not show garbage.
+      if (plugin_container_manager_.SurfaceShouldBeVisible(params.window))
+        [view setHidden:NO];
+      [view drawView];
+    }
+
+    if (params.route_id != 0) {
+      RenderWidgetHostImpl::AcknowledgeSwapBuffers(params.route_id,
+                                                   gpu_host_id);
+    }
   }
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
   TRACE_EVENT0("browser",
       "RenderWidgetHostViewMac::AcceleratedSurfacePostSubBuffer");
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  AcceleratedPluginView* view = ViewForPluginWindowHandle(params.window);
-  DCHECK(view);
-  if (view) {
-    last_frame_was_accelerated_ = (params.window ==
-        plugin_container_manager_.root_container_handle());
-    plugin_container_manager_.SetSurfaceWasPaintedTo(
-        params.window,
-        params.surface_handle,
-        gfx::Rect(params.x, params.y, params.width, params.height));
 
-    // The surface is hidden until its first paint, to not show garbage.
-    if (plugin_container_manager_.SurfaceShouldBeVisible(params.window))
-      [view setHidden:NO];
-    [view drawView];
-  }
+  if (params.window == compositing_surface_) {
+    CompositorSwapBuffers(params.surface_handle, params.route_id, gpu_host_id);
+  } else {
+    // Deprecated accelerated plugin code path.
+    AcceleratedPluginView* view = ViewForPluginWindowHandle(params.window);
+    DCHECK(view);
+    if (view) {
+      plugin_container_manager_.SetSurfaceWasPaintedTo(
+          params.window,
+          params.surface_handle,
+          gfx::Rect(params.x, params.y, params.width, params.height));
 
-  if (params.route_id != 0) {
-    RenderWidgetHostImpl::AcknowledgePostSubBuffer(
-        params.route_id, gpu_host_id);
+      // The surface is hidden until its first paint, to not show garbage.
+      if (plugin_container_manager_.SurfaceShouldBeVisible(params.window))
+        [view setHidden:NO];
+      [view drawView];
+    }
+
+    if (params.route_id != 0) {
+      RenderWidgetHostImpl::AcknowledgePostSubBuffer(
+          params.route_id, gpu_host_id);
+    }
   }
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceSuspend() {
 }
 
-void RenderWidgetHostViewMac::UpdateRootGpuViewVisibility(
-    bool show_gpu_widget) {
-  TRACE_EVENT1("renderer_host",
-      "RenderWidgetHostViewMac::UpdateRootGpuViewVisibility",
-      "show", show_gpu_widget);
-  // Plugins are destroyed on page navigate. The compositor layer on the other
-  // hand is created on demand and then stays alive until its renderer process
-  // dies (usually on cross-domain navigation). Instead, only a flag
-  // |is_accelerated_compositing_active()| is flipped when the compositor output
-  // should be shown/hidden.
-  // Show/hide the view belonging to the compositor here.
-  plugin_container_manager_.set_gpu_rendering_active(show_gpu_widget);
-
-  gfx::PluginWindowHandle root_handle =
-      plugin_container_manager_.root_container_handle();
-  if (root_handle != gfx::kNullPluginWindow) {
-    AcceleratedPluginView* view = ViewForPluginWindowHandle(root_handle);
-    DCHECK(view);
-    bool visible =
-        plugin_container_manager_.SurfaceShouldBeVisible(root_handle);
-    [[view window] disableScreenUpdatesUntilFlush];
-    [view setHidden:!visible];
-  }
-}
-
-void RenderWidgetHostViewMac::HandleDelayedGpuViewHiding() {
-  TRACE_EVENT0("renderer_host",
-      "RenderWidgetHostViewMac::HandleDelayedGpuViewHiding");
-  if (needs_gpu_visibility_update_after_repaint_) {
-    UpdateRootGpuViewVisibility(false);
-    needs_gpu_visibility_update_after_repaint_ = false;
-  }
-}
-
 void RenderWidgetHostViewMac::OnAcceleratedCompositingStateChange() {
-  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  bool activated = RenderWidgetHostImpl::From(
-      GetRenderWidgetHost())->is_accelerated_compositing_active();
-  bool changed = accelerated_compositing_active_ != activated;
-  accelerated_compositing_active_ = activated;
-  if (!changed)
-    return;
-
-  TRACE_EVENT1("renderer_host",
-      "RenderWidgetHostViewMac::OnAcceleratedCompositingStateChange",
-      "active", accelerated_compositing_active_);
-  if (accelerated_compositing_active_) {
-    UpdateRootGpuViewVisibility(accelerated_compositing_active_);
-  } else {
-    needs_gpu_visibility_update_after_repaint_ = true;
-  }
 }
 
 void RenderWidgetHostViewMac::GetScreenInfo(WebKit::WebScreenInfo* results) {
   *results = WebKit::WebScreenInfoFactory::screenInfo(GetNativeView());
 }
 
 gfx::Rect RenderWidgetHostViewMac::GetRootWindowBounds() {
   // TODO(shess): In case of !window, the view has been removed from
   // the view hierarchy because the tab isn't main.  Could retrieve
   // the information from the main tab for our window.
   NSWindow* enclosing_window = ApparentWindowForView(cocoa_view_);
   if (!enclosing_window)
     return gfx::Rect();
 
   NSRect bounds = [enclosing_window frame];
   return FlipNSRectToRectScreen(bounds);
 }
 
 gfx::GLSurfaceHandle RenderWidgetHostViewMac::GetCompositingSurface() {
-  if (compositing_surface_ == gfx::kNullPluginWindow)
-    compositing_surface_ = AllocateFakePluginWindowHandle(
-        /*opaque=*/true, /*root=*/true);
+  // compositing_surface_ is always gfx::kNullPluginWindow.
   return gfx::GLSurfaceHandle(compositing_surface_, true);
 }
 
 void RenderWidgetHostViewMac::DrawAcceleratedSurfaceInstance(
       CGLContextObj context,
       gfx::PluginWindowHandle plugin_handle,
       NSSize size) {
   TRACE_EVENT0("browser",
       "RenderWidgetHostViewMac::DrawAcceleratedSurfaceInstance");
   // Called on the display link thread.
@@ skipping 145 matching lines @@
 
 - (id)initWithRenderWidgetHostViewMac:(RenderWidgetHostViewMac*)r {
   self = [super initWithFrame:NSZeroRect];
   if (self) {
     editCommand_helper_.reset(new RenderWidgetHostViewMacEditCommandHelper);
     editCommand_helper_->AddEditingSelectorsToClass([self class]);
 
     renderWidgetHostView_.reset(r);
     canBeKeyView_ = YES;
     focusedPluginIdentifier_ = -1;
+
+    // OpenGL support:
+    handlingGlobalFrameDidChange_ = NO;
+    hasGLContext_ = NO;
+    [[NSNotificationCenter defaultCenter]
+         addObserver:self
+            selector:@selector(globalFrameDidChange:)
+                name:NSViewGlobalFrameDidChangeNotification
+              object:self];
   }
   return self;
 }
 
 - (void)dealloc {
   if (delegate_ && [delegate_ respondsToSelector:@selector(viewGone:)])
     [delegate_ viewGone:self];
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
 
   [super dealloc];
 }
 
 - (void)setRWHVDelegate:(NSObject<RenderWidgetHostViewMacDelegate>*)delegate {
   delegate_ = delegate;
 }
 
 - (void)gotUnhandledWheelEvent {
   if (delegate_ &&
@@ skipping 494 matching lines @@
     for (NSView* subview in [self subviews]) {
       if (![subview isKindOfClass:[RenderWidgetHostViewCocoa class]])
         continue;  // Skip plugin views.
 
       [static_cast<RenderWidgetHostViewCocoa*>(subview)
           renderWidgetHostViewMac]->KillSelf();
     }
   }
 }
 
+// OpenGL support
+- (void)addedGLContext {
+  hasGLContext_ = YES;
+  if (![self isHiddenOrHasHiddenAncestor]) {
+    // Intentionally leak underlaySurface count so that the window never changes
+    // back to opaque. This is to prevent black/transparent flashing that
+    // appears during tab switching otherwise.

[Ken Russell (switch to Gerrit), 2012/04/04 17:27:17]

I think a TODO should be added here. I don't remember exactly how the
bookkeeping works right now, but if the underlay surface count could go back to
0 when all composited tabs were removed from a window (i.e., all tabs rendered
in software), would the flashes upon tab switch still be present?

[jbates, 2012/04/04 19:21:50]

Done. Added a TODO about cleaning up this code and pointed to bug 56154.
Allowing the count to go back to zero when the RWHVM was removed from the window
(backgrounded) caused the occasional black flash so I expect the same to occur
if the count went to zero when the RWHVM was deleted (which may occur during
back/forward navigation in addition to closing tabs).

+    if ([[self window] respondsToSelector:@selector(underlaySurfaceAdded)])
+      [static_cast<id>([self window]) underlaySurfaceAdded];
+  }
+}
+
+- (void)viewWillMoveToWindow:(NSWindow*)newWindow {
+  if (![self isHiddenOrHasHiddenAncestor]) {
+    // Intentionally leak underlaySurface count so that the window never changes
+    // back to opaque. This is to prevent black/transparent flashing that
+    // appears during tab switching otherwise.
+    if (hasGLContext_ &&
+        [newWindow respondsToSelector:@selector(underlaySurfaceAdded)])
+      [static_cast<id>(newWindow) underlaySurfaceAdded];
+  }
+}
+
+- (void) globalFrameDidChange:(NSNotification*)notification {
+  if (handlingGlobalFrameDidChange_)
+    return;
+
+  handlingGlobalFrameDidChange_ = YES;
+  if (renderWidgetHostView_->compositing_iosurface_.get())
+    renderWidgetHostView_->compositing_iosurface_->GlobalFrameDidChange();
+  handlingGlobalFrameDidChange_ = NO;
+}
+
 - (void)setFrameSize:(NSSize)newSize {
   // NB: -[NSView setFrame:] calls through -setFrameSize:, so overriding
   // -setFrame: isn't neccessary.
   [super setFrameSize:newSize];
   if (renderWidgetHostView_->render_widget_host_)
     renderWidgetHostView_->render_widget_host_->WasResized();
 }
 
 - (void)callSetNeedsDisplayInRect {
   DCHECK([NSThread isMainThread]);
   DCHECK(renderWidgetHostView_->call_set_needs_display_in_rect_pending_);
   [self setNeedsDisplayInRect:renderWidgetHostView_->invalid_rect_];
   renderWidgetHostView_->call_set_needs_display_in_rect_pending_ = false;
   renderWidgetHostView_->invalid_rect_ = NSZeroRect;
-
-  renderWidgetHostView_->HandleDelayedGpuViewHiding();
 }
 
 // Fills with white the parts of the area to the right and bottom for |rect|
 // that intersect |damagedRect|.
 - (void)fillBottomRightRemainderOfRect:(gfx::Rect)rect
                              dirtyRect:(gfx::Rect)damagedRect {
   if (damagedRect.right() > rect.right()) {
     int x = std::max(rect.right(), damagedRect.x());
     int y = std::min(rect.bottom(), damagedRect.bottom());
     int width = damagedRect.right() - x;
@@ skipping 41 matching lines @@
   if (!renderWidgetHostView_->render_widget_host_) {
     // TODO(shess): Consider using something more noticable?
     [[NSColor whiteColor] set];
     NSRectFill(dirtyRect);
     return;
   }
 
   const gfx::Rect damagedRect([self flipNSRectToRect:dirtyRect]);
 
   if (renderWidgetHostView_->last_frame_was_accelerated_) {
-    gfx::Rect gpuRect;
+    // Draw transparency to expose the GL underlay:
+    // TODO(jbates) avoid doing this every frame.
+    [[NSColor clearColor] set];
+    NSRectFill(dirtyRect);
 
-    gfx::PluginWindowHandle root_handle =
-       renderWidgetHostView_->plugin_container_manager_.root_container_handle();
-    if (root_handle != gfx::kNullPluginWindow) {
-      AcceleratedPluginView* view =
-          renderWidgetHostView_->ViewForPluginWindowHandle(root_handle);
-      DCHECK(view);
-      if (view && ![view isHidden]) {
-        gpuRect = [self flipNSRectToRect:[view frame]];
-      }
-    }
-
-    [self fillBottomRightRemainderOfRect:gpuRect dirtyRect:damagedRect];
+    renderWidgetHostView_->compositing_iosurface_->DrawLastIOSurface(self);
+    renderWidgetHostView_->CompositorSwapBuffersComplete();
     return;
   }
 
+  renderWidgetHostView_->CompositorSwapBuffersComplete();

[Ken Russell (switch to Gerrit), 2012/04/04 17:27:17]

It's a little confusing that this is on the software path. Presumably it's
needed to unblock the GPU process during switches from composited to
non-composited mode or similar. A comment would be useful.

[jbates, 2012/04/04 19:21:50]

Done.

+
   DCHECK(!renderWidgetHostView_->about_to_validate_and_paint_);
 
   renderWidgetHostView_->about_to_validate_and_paint_ = true;
   BackingStoreMac* backingStore = static_cast<BackingStoreMac*>(
       renderWidgetHostView_->render_widget_host_->GetBackingStore(true));
   renderWidgetHostView_->about_to_validate_and_paint_ = false;
 
   if (backingStore) {
     gfx::Rect bitmapRect(0, 0,
                          backingStore->size().width(),
@@ skipping 974 matching lines @@
   if (!string) return NO;
 
   // If the user is currently using an IME, confirm the IME input,
   // and then insert the text from the service, the same as TextEdit and Safari.
   [self confirmComposition];
   [self insertText:string];
   return YES;
 }
 
 @end