[Mac] Support windowless Flash plugin rendering directly to the context for single-process apps

webkit/plugins/npapi/webplugin_delegate_impl_mac.mm

 // Copyright (c) 2011 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.
 
 #import <Cocoa/Cocoa.h>
 #import <QuartzCore/QuartzCore.h>
 
 #include "webkit/plugins/npapi/webplugin_delegate_impl.h"
 
 #include <string>
@@ skipping 244 matching lines @@
 WebPluginDelegateImpl::WebPluginDelegateImpl(
     gfx::PluginWindowHandle containing_view,
     PluginInstance *instance)
     : windowed_handle_(NULL),
       // all Mac plugins are "windowless" in the Windows/X11 sense
       windowless_(true),
       plugin_(NULL),
       instance_(instance),
       parent_(containing_view),
       quirks_(0),
+      use_buffer_context_(true),
       buffer_context_(NULL),
       layer_(nil),
       surface_(NULL),
       renderer_(nil),
       containing_window_has_focus_(false),
       initial_window_focus_(false),
       container_is_visible_(false),
       have_called_set_window_(false),
       ime_enabled_(false),
       keyup_ignore_count_(0),
@@ skipping 410 matching lines @@
 #endif
 
   if (window_size_changed || clip_rect_changed || force_set_window)
     WindowlessSetWindow();
 }
 
 void WebPluginDelegateImpl::WindowlessPaint(gfx::NativeDrawingContext context,
                                             const gfx::Rect& damage_rect) {
   // If we get a paint event before we are completely set up (e.g., a nested
   // call while the plugin is still in NPP_SetWindow), bail.
-  if (!have_called_set_window_ || !buffer_context_)
+  if (!have_called_set_window_ || (use_buffer_context_ && !buffer_context_))
     return;
-  DCHECK(buffer_context_ == context);
+  DCHECK(!use_buffer_context_ || buffer_context_ == context);
 
   static base::StatsRate plugin_paint("Plugin.Paint");
   base::StatsScope<base::StatsRate> scope(plugin_paint);
 
-  // Plugin invalidates trigger asynchronous paints with the original
-  // invalidation rect; the plugin may be resized before the paint is handled,
-  // so we need to ensure that the damage rect is still sane.
-  const gfx::Rect paint_rect(damage_rect.Intersect(
-      gfx::Rect(0, 0, window_rect_.width(), window_rect_.height())));
+  gfx::Rect paint_rect;
+  if (use_buffer_context_) {
+    // Plugin invalidates trigger asynchronous paints with the original
+    // invalidation rect; the plugin may be resized before the paint is handled,
+    // so we need to ensure that the damage rect is still sane.
+    paint_rect = damage_rect.Intersect(
+        gfx::Rect(0, 0, window_rect_.width(), window_rect_.height()));
+  } else {
+    // Use the actual window region when drawing directly to the window context.
+    paint_rect = damage_rect.Intersect(window_rect_);
+  }
 
   ScopedActiveDelegate active_delegate(this);
 
 #ifndef NP_NO_QUICKDRAW
   if (instance()->drawing_model() == NPDrawingModelQuickDraw)
     qd_manager_->MakePortCurrent();
 #endif
 
   CGContextSaveGState(context);
 
+  if (!use_buffer_context_) {
+    // Reposition the context origin so that plugins will draw at the correct
+    // location in the window.
+    CGContextClipToRect(context, paint_rect.ToCGRect());
+    CGContextTranslateCTM(context, window_rect_.x(), window_rect_.y());
+  }
+
   switch (instance()->event_model()) {
 #ifndef NP_NO_CARBON
     case NPEventModelCarbon: {
       NPEvent paint_event = { 0 };
       paint_event.what = updateEvt;
       paint_event.message = reinterpret_cast<uint32>(np_cg_context_.window);
       paint_event.when = TickCount();
       instance()->NPP_HandleEvent(&paint_event);
       break;
     }
 #endif
     case NPEventModelCocoa: {
       NPCocoaEvent paint_event;
       memset(&paint_event, 0, sizeof(NPCocoaEvent));
       paint_event.type = NPCocoaEventDrawRect;
       paint_event.data.draw.context = context;
       paint_event.data.draw.x = paint_rect.x();
       paint_event.data.draw.y = paint_rect.y();
       paint_event.data.draw.width = paint_rect.width();
       paint_event.data.draw.height = paint_rect.height();
       instance()->NPP_HandleEvent(&paint_event);
       break;
     }
   }
 
-  // The backing buffer can change during the call to NPP_HandleEvent, in which
-  // case the old context is (or is about to be) invalid.
-  if (context == buffer_context_)
+  if (use_buffer_context_) {
+    // The backing buffer can change during the call to NPP_HandleEvent, in
+    // which case the old context is (or is about to be) invalid.
+    if (context == buffer_context_)
+      CGContextRestoreGState(context);
+  } else {
+    // Always restore the context to the saved state.
     CGContextRestoreGState(context);
+  }
 }
 
 void WebPluginDelegateImpl::WindowlessSetWindow() {
   if (!instance())
     return;
 
   window_.x = 0;
   window_.y = 0;
   window_.height = window_rect_.height();
   window_.width = window_rect_.width();
@@ skipping 352 matching lines @@
       new_bounds.bottom != current_bounds.bottom)
     SetWindowBounds(window, kWindowContentRgn, &new_bounds);
 }
 
 void WebPluginDelegateImpl::UpdateIdleEventRate() {
   bool plugin_visible = container_is_visible_ && !clip_rect_.IsEmpty();
   CarbonIdleEventSource::SharedInstance()->RegisterDelegate(this,
                                                             plugin_visible);
 }
 
+void WebPluginDelegateImpl::SetNoBufferContext() {
+  use_buffer_context_ = false;
+}
+
 void WebPluginDelegateImpl::FireIdleEvent() {
   // Avoid a race condition between IO and UI threads during plugin shutdown
   if (!instance())
     return;
   // Don't send idle events until we've called SetWindow.
   if (!have_called_set_window_)
     return;
 
 #ifndef NP_NO_QUICKDRAW
   // Check whether it's time to turn the QuickDraw fast path back on.
@@ skipping 61 matching lines @@
   qd_manager_->SetFastPathEnabled(enabled);
   qd_port_.port = qd_manager_->port();
   WindowlessSetWindow();
   // Send a paint event so that the new buffer gets updated immediately.
   WindowlessPaint(buffer_context_, clip_rect_);
 }
 #endif  // !NP_NO_QUICKDRAW
 
 }  // namespace npapi
 }  // namespace webkit