Remove support for the QuickDraw NPAPI drawing model

webkit/plugins/npapi/webplugin_delegate_impl_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.
 
 #import <Cocoa/Cocoa.h>
 #import <QuartzCore/QuartzCore.h>
 
 #include "webkit/plugins/npapi/webplugin_delegate_impl.h"
 
 #include <string>
@@ skipping 15 matching lines @@
 #include "webkit/plugins/npapi/plugin_list.h"
 #include "webkit/plugins/npapi/plugin_stream_url.h"
 #include "webkit/plugins/npapi/plugin_web_event_converter_mac.h"
 #include "webkit/plugins/npapi/webplugin.h"
 #include "webkit/plugins/npapi/webplugin_accelerated_surface_mac.h"
 
 #ifndef NP_NO_CARBON
 #include "webkit/plugins/npapi/carbon_plugin_window_tracker_mac.h"
 #endif
 
-#ifndef NP_NO_QUICKDRAW
-#include "webkit/plugins/npapi/quickdraw_drawing_manager_mac.h"
-#endif
-
 #if defined(USE_SKIA)
 #include "skia/ext/skia_utils_mac.h"
 #endif
 
 using WebKit::WebCursorInfo;
 using WebKit::WebKeyboardEvent;
 using WebKit::WebInputEvent;
 using WebKit::WebMouseEvent;
 using WebKit::WebMouseWheelEvent;
 
@@ skipping 229 matching lines @@
       handle_event_depth_(0),
       first_set_window_call_(true),
       plugin_has_focus_(false),
       has_webkit_focus_(false),
       containing_view_has_focus_(true),
       creation_succeeded_(false) {
   memset(&window_, 0, sizeof(window_));
 #ifndef NP_NO_CARBON
   memset(&np_cg_context_, 0, sizeof(np_cg_context_));
 #endif
-#ifndef NP_NO_QUICKDRAW
-  memset(&qd_port_, 0, sizeof(qd_port_));
-#endif
   instance->set_windowless(true);
 }
 
 WebPluginDelegateImpl::~WebPluginDelegateImpl() {
   DestroyInstance();
 
 #ifndef NP_NO_CARBON
   if (np_cg_context_.window) {
     CarbonPluginWindowTracker::SharedInstance()->DestroyDummyWindowForDelegate(
         this, reinterpret_cast<WindowRef>(np_cg_context_.window));
@@ skipping 21 matching lines @@
     np_cg_context_.window = window_tracker->CreateDummyWindowForDelegate(this);
     np_cg_context_.context = NULL;
     UpdateDummyWindowBounds(gfx::Point(0, 0));
   }
 #endif
 
   NPDrawingModel drawing_model = instance()->drawing_model();
   switch (drawing_model) {
 #ifndef NP_NO_QUICKDRAW
     case NPDrawingModelQuickDraw:
-      if (instance()->event_model() != NPEventModelCarbon)
-        return false;
-      qd_manager_.reset(new QuickDrawDrawingManager());
-      qd_manager_->SetPluginWindow(
-          reinterpret_cast<WindowRef>(np_cg_context_.window));
-      qd_port_.port = qd_manager_->port();
-      window_.window = &qd_port_;
-      window_.type = NPWindowTypeDrawable;
-      break;
+      return false;
 #endif
     case NPDrawingModelCoreGraphics:
 #ifndef NP_NO_CARBON
       if (instance()->event_model() == NPEventModelCarbon)
         window_.window = &np_cg_context_;
 #endif
       window_.type = NPWindowTypeDrawable;
       break;
     case NPDrawingModelCoreAnimation:
     case NPDrawingModelInvalidatingCoreAnimation: {
@@ skipping 54 matching lines @@
   // accelerated rendering is enabled.
   if (!layer_)
     plugin_->SetWindow(gfx::kNullPluginWindow);
 
 #ifndef NP_NO_CARBON
   // If the plugin wants Carbon events, hook up to the source of idle events.
   if (instance()->event_model() == NPEventModelCarbon)
     UpdateIdleEventRate();
 #endif
 
-  // QuickTime (in QD mode only) can crash if it gets other calls (e.g.,
-  // NPP_Write) before it gets a SetWindow call, so call SetWindow (with a 0x0
-  // rect) immediately.
-#ifndef NP_NO_QUICKDRAW
-  if (instance()->drawing_model() == NPDrawingModelQuickDraw) {
-    const WebPluginInfo& plugin_info = instance_->plugin_lib()->plugin_info();
-    if (plugin_info.name.find(ASCIIToUTF16("QuickTime")) != string16::npos)
-      WindowlessSetWindow();
-  }
-#endif
-
   return true;
 }
 
 void WebPluginDelegateImpl::PlatformDestroyInstance() {
 #ifndef NP_NO_CARBON
   if (instance()->event_model() == NPEventModelCarbon)
     CarbonIdleEventSource::SharedInstance()->UnregisterDelegate(this);
 #endif
   if (redraw_timer_.get())
     redraw_timer_->Stop();
@@ skipping 10 matching lines @@
   if (instance()->event_model() == NPEventModelCarbon) {
     // Update the structure that is passed to Carbon+CoreGraphics plugins in
     // NPP_SetWindow before calling UpdateGeometry, since that will trigger an
     // NPP_SetWindow call if the geometry changes (which is the only time the
     // context would be different), and some plugins (e.g., Flash) have an
     // internal cache of the context that they only update when NPP_SetWindow
     // is called.
     np_cg_context_.context = context;
   }
 #endif
-#ifndef NP_NO_QUICKDRAW
-  if (instance()->drawing_model() == NPDrawingModelQuickDraw)
-    qd_manager_->SetTargetContext(context, window_rect.size());
-#endif
   UpdateGeometry(window_rect, clip_rect);
 }
 
 void WebPluginDelegateImpl::Paint(WebKit::WebCanvas* canvas,
                                   const gfx::Rect& rect) {
 #if defined(USE_SKIA)
   gfx::SkiaBitLocker bit_locker(canvas);
   CGContextRef context = bit_locker.cgContext();
 #else
   CGContextRef context = canvas;
 #endif
   CGPaint(context, rect);
 }
 
 void WebPluginDelegateImpl::CGPaint(CGContextRef context,
                                     const gfx::Rect& rect) {
   WindowlessPaint(context, rect);
-
-#ifndef NP_NO_QUICKDRAW
-  // Paint events are our cue to dump the current plugin bits into the buffer
-  // context if we are dealing with a QuickDraw plugin.
-  if (instance()->drawing_model() == NPDrawingModelQuickDraw) {
-    qd_manager_->UpdateContext();
-  }
-#endif
 }
 
 bool WebPluginDelegateImpl::PlatformHandleInputEvent(
     const WebInputEvent& event, WebCursorInfo* cursor_info) {
   DCHECK(cursor_info != NULL);
 
   // If we get an event before we've set up the plugin, bail.
   if (!have_called_set_window_)
     return false;
 #ifndef NP_NO_CARBON
@@ skipping 43 matching lines @@
     // because the keydown wasn't sent to the plugin, the keyup shouldn't be
     // either (per the spec).
     if (event.type == WebInputEvent::KeyDown)
       ++keyup_ignore_count_;
     else
       --keyup_ignore_count_;
     return true;
   }
 
 #ifndef NP_NO_CARBON
-  if (instance()->event_model() == NPEventModelCarbon) {
-#ifndef NP_NO_QUICKDRAW
-    if (instance()->drawing_model() == NPDrawingModelQuickDraw)
-      qd_manager_->MakePortCurrent();
-#endif
-
-    if (event.type == WebInputEvent::MouseMove) {
-      return true;  // The recurring FireIdleEvent will send null events.
-    }
+  if (instance()->event_model() == NPEventModelCarbon &&
+      event.type == WebInputEvent::MouseMove) {
+    return true;  // The recurring FireIdleEvent will send null events.
   }
 #endif
 
   ScopedActiveDelegate active_delegate(this);
 
   // Create the plugin event structure.
   NPEventModel event_model = instance()->event_model();
   scoped_ptr<PluginWebEventConverter> event_converter(
       PluginWebEventConverterFactory::CreateConverterForModel(event_model));
   if (!(event_converter.get() && event_converter->InitWithEvent(event))) {
@@ skipping 65 matching lines @@
 void WebPluginDelegateImpl::WindowlessUpdateGeometry(
     const gfx::Rect& window_rect,
     const gfx::Rect& clip_rect) {
   gfx::Rect old_clip_rect = clip_rect_;
   cached_clip_rect_ = clip_rect;
   if (container_is_visible_)  // Remove check when cached_clip_rect_ is removed.
     clip_rect_ = clip_rect;
   bool clip_rect_changed = (clip_rect_ != old_clip_rect);
   bool window_size_changed = (window_rect.size() != window_rect_.size());
 
-  bool force_set_window = false;
-#ifndef NP_NO_QUICKDRAW
-  // In a QuickDraw plugin, a geometry update might have caused a port change;
-  // if so, we need to call SetWindow even if nothing else changed.
-  if (qd_manager_.get() && (qd_port_.port != qd_manager_->port())) {
-    qd_port_.port = qd_manager_->port();
-    force_set_window = true;
-  }
-#endif
-
-  if (window_rect == window_rect_ && !clip_rect_changed && !force_set_window)
+  if (window_rect == window_rect_ && !clip_rect_changed)
     return;
 
   if (old_clip_rect.IsEmpty() != clip_rect_.IsEmpty()) {
     PluginVisibilityChanged();
   }
 
   SetPluginRect(window_rect);
 
-  if (window_size_changed || clip_rect_changed || force_set_window)
+  if (window_size_changed || clip_rect_changed)
     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_ || (use_buffer_context_ && !buffer_context_))
     return;
   DCHECK(!use_buffer_context_ || buffer_context_ == context);
 
   base::StatsRate plugin_paint("Plugin.Paint");
   base::StatsScope<base::StatsRate> scope(plugin_paint);
 
   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()) {
@@ skipping 404 matching lines @@
 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;
 
   ScopedActiveDelegate active_delegate(this);
 
-#ifndef NP_NO_QUICKDRAW
-  if (instance()->drawing_model() == NPDrawingModelQuickDraw)
-    qd_manager_->MakePortCurrent();
-#endif
-
   // Send an idle event so that the plugin can do background work
   NPEvent np_event = {0};
   np_event.what = nullEvent;
   np_event.when = TickCount();
   np_event.modifiers = GetCurrentKeyModifiers();
   if (!Button())
     np_event.modifiers |= btnState;
   HIPoint mouse_location;
   HIGetMousePosition(kHICoordSpaceScreenPixel, NULL, &mouse_location);
   np_event.where.h = mouse_location.x;
   np_event.where.v = mouse_location.y;
   instance()->NPP_HandleEvent(&np_event);
-
-#ifndef NP_NO_QUICKDRAW
-  // Quickdraw-based plugins can draw at any time, so tell the renderer to
-  // repaint.
-  if (instance() && instance()->drawing_model() == NPDrawingModelQuickDraw)
-    instance()->webplugin()->Invalidate();
-#endif
 }
 #endif  // !NP_NO_CARBON
 
 }  // namespace npapi
 }  // namespace webkit