Remove a bunch of NPAPI quirks and related support code

content/renderer/npapi/webplugin_delegate_proxy.cc

 // 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/renderer/npapi/webplugin_delegate_proxy.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 90 matching lines @@
     WebPluginImpl* plugin,
     const std::string& mime_type,
     const base::WeakPtr<RenderViewImpl>& render_view,
     RenderFrameImpl* render_frame)
     : render_view_(render_view),
       render_frame_(render_frame),
       plugin_(plugin),
       uses_shared_bitmaps_(true),
 #if defined(OS_MACOSX)
       uses_compositor_(false),
-#elif defined(OS_WIN)
-      dummy_activation_window_(NULL),
 #endif
       mime_type_(mime_type),
       instance_id_(MSG_ROUTING_NONE),
       npobject_(NULL),
       npp_(new NPP_t),
       sad_plugin_(NULL),
       invalidate_pending_(false),
       transparent_(false),
       front_buffer_index_(0),
       page_url_(render_view_->webview()->mainFrame()->document().url()) {
 }
 
 WebPluginDelegateProxy::~WebPluginDelegateProxy() {
   if (npobject_)
     WebBindings::releaseObject(npobject_);
 }
 
 WebPluginDelegateProxy::SharedBitmap::SharedBitmap() {}
 
 WebPluginDelegateProxy::SharedBitmap::~SharedBitmap() {}
 
 void WebPluginDelegateProxy::PluginDestroyed() {
-#if defined(OS_MACOSX) || defined(OS_WIN)
+#if defined(OS_MACOSX)
   // Ensure that the renderer doesn't think the plugin still has focus.
   if (render_view_)
     render_view_->PluginFocusChanged(false, instance_id_);
 #endif
 
-#if defined(OS_WIN)
-  if (dummy_activation_window_ && render_view_) {
-    render_view_->Send(new ViewHostMsg_WindowlessPluginDummyWindowDestroyed(
-        render_view_->GetRoutingID(), dummy_activation_window_));
-  }
-  dummy_activation_window_ = NULL;
-#endif
-
   if (render_view_.get())
     render_view_->UnregisterPluginDelegate(this);
 
   if (channel_host_.get()) {
     Send(new PluginMsg_DestroyInstance(instance_id_));
 
     // Must remove the route after sending the destroy message, rather than
     // before, since RemoveRoute can lead to all the outstanding NPObjects
     // being told the channel went away if this was the last instance.
     channel_host_->RemoveRoute(instance_id_);
@@ skipping 138 matching lines @@
     IPC_MESSAGE_HANDLER(PluginHostMsg_InvalidateRect, OnInvalidateRect)
     IPC_MESSAGE_HANDLER(PluginHostMsg_GetWindowScriptNPObject,
                         OnGetWindowScriptNPObject)
     IPC_MESSAGE_HANDLER(PluginHostMsg_GetPluginElement, OnGetPluginElement)
     IPC_MESSAGE_HANDLER(PluginHostMsg_ResolveProxy, OnResolveProxy)
     IPC_MESSAGE_HANDLER(PluginHostMsg_SetCookie, OnSetCookie)
     IPC_MESSAGE_HANDLER(PluginHostMsg_GetCookies, OnGetCookies)
     IPC_MESSAGE_HANDLER(PluginHostMsg_CancelDocumentLoad, OnCancelDocumentLoad)
     IPC_MESSAGE_HANDLER(PluginHostMsg_DidStartLoading, OnDidStartLoading)
     IPC_MESSAGE_HANDLER(PluginHostMsg_DidStopLoading, OnDidStopLoading)
-#if defined(OS_WIN)
-    IPC_MESSAGE_HANDLER(PluginHostMsg_SetWindowlessData, OnSetWindowlessData)
-    IPC_MESSAGE_HANDLER(PluginHostMsg_NotifyIMEStatus, OnNotifyIMEStatus)
-#endif
 #if defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(PluginHostMsg_FocusChanged,
                         OnFocusChanged);
     IPC_MESSAGE_HANDLER(PluginHostMsg_StartIme,
                         OnStartIme);
     IPC_MESSAGE_HANDLER(PluginHostMsg_AcceleratedPluginEnabledRendering,
                         OnAcceleratedPluginEnabledRendering)
     IPC_MESSAGE_HANDLER(PluginHostMsg_AcceleratedPluginAllocatedIOSurface,
                         OnAcceleratedPluginAllocatedIOSurface)
     IPC_MESSAGE_HANDLER(PluginHostMsg_AcceleratedPluginSwappedIOSurface,
                         OnAcceleratedPluginSwappedIOSurface)
 #endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled);
   return handled;
 }
 
 void WebPluginDelegateProxy::OnChannelError() {
   if (plugin_) {
     plugin_->Invalidate();
   }
   if (channel_host_.get() && !channel_host_->expecting_shutdown()) {
     render_view_->GetMainRenderFrame()->PluginCrashed(
         info_.path, channel_host_->peer_pid());
   }
 
-#if defined(OS_MACOSX) || defined(OS_WIN)
+#if defined(OS_MACOSX)
   // Ensure that the renderer doesn't think the plugin still has focus.
   if (render_view_)
     render_view_->PluginFocusChanged(false, instance_id_);
 #endif
 }
 
 static void CopySharedMemoryHandleForMessage(
     const base::SharedMemoryHandle& handle_in,
     base::SharedMemoryHandle* handle_out,
     base::ProcessId peer_pid) {
@@ skipping 235 matching lines @@
 }
 
 bool WebPluginDelegateProxy::GetFormValue(base::string16* value) {
   bool success = false;
   Send(new PluginMsg_GetFormValue(instance_id_, value, &success));
   return success;
 }
 
 void WebPluginDelegateProxy::SetFocus(bool focused) {
   Send(new PluginMsg_SetFocus(instance_id_, focused));
-#if defined(OS_WIN)
-  if (render_view_)
-    render_view_->PluginFocusChanged(focused, instance_id_);
-#endif
 }
 
 bool WebPluginDelegateProxy::HandleInputEvent(
     const WebInputEvent& event,
     WebCursor::CursorInfo* cursor_info) {
   bool handled = false;
   WebCursor cursor;
-  // A windowless plugin can enter a modal loop in the context of a
-  // NPP_HandleEvent call, in which case we need to pump messages to
-  // the plugin. We pass of the corresponding event handle to the
-  // plugin process, which is set if the plugin does enter a modal loop.
-  IPC::SyncMessage* message = new PluginMsg_HandleInputEvent(
-      instance_id_, &event, &handled, &cursor);
-  message->set_pump_messages_event(modal_loop_pump_messages_event_.get());
-  Send(message);
+  Send(new PluginMsg_HandleInputEvent(instance_id_, &event, &handled, &cursor));
   return handled;
 }
 
 int WebPluginDelegateProxy::GetProcessId() {
   return channel_host_->peer_pid();
 }
 
 void WebPluginDelegateProxy::SetContentAreaFocus(bool has_focus) {
   IPC::Message* msg = new PluginMsg_SetContentAreaFocus(instance_id_,
                                                         has_focus);
   // Make sure focus events are delivered in the right order relative to
   // sync messages they might interact with (Paint, HandleEvent, etc.).
   msg->set_unblock(true);
   Send(msg);
 }
 
-#if defined(OS_WIN)
-void WebPluginDelegateProxy::ImeCompositionUpdated(
-    const base::string16& text,
-    const std::vector<int>& clauses,
-    const std::vector<int>& target,
-    int cursor_position,
-    int plugin_id) {
-  // Dispatch the raw IME data if this plugin is the focused one.
-  if (instance_id_ != plugin_id)
-    return;
-
-  IPC::Message* msg = new PluginMsg_ImeCompositionUpdated(instance_id_,
-      text, clauses, target, cursor_position);
-  msg->set_unblock(true);
-  Send(msg);
-}
-
-void WebPluginDelegateProxy::ImeCompositionCompleted(const base::string16& text,
-                                                     int plugin_id) {
-  // Dispatch the IME text if this plugin is the focused one.
-  if (instance_id_ != plugin_id)
-    return;
-
-  IPC::Message* msg = new PluginMsg_ImeCompositionCompleted(instance_id_, text);
-  msg->set_unblock(true);
-  Send(msg);
-}
-#endif
-
 #if defined(OS_MACOSX)
 void WebPluginDelegateProxy::SetWindowFocus(bool window_has_focus) {
   IPC::Message* msg = new PluginMsg_SetWindowFocus(instance_id_,
                                                    window_has_focus);
   // Make sure focus events are delivered in the right order relative to
   // sync messages they might interact with (Paint, HandleEvent, etc.).
   msg->set_unblock(true);
   Send(msg);
 }
 
@@ skipping 31 matching lines @@
     return;
 
   IPC::Message* msg = new PluginMsg_ImeCompositionCompleted(instance_id_,
                                                             text);
   // Order relative to other key events is important.
   msg->set_unblock(true);
   Send(msg);
 }
 #endif  // OS_MACOSX
 
-#if defined(OS_WIN)
-void WebPluginDelegateProxy::OnSetWindowlessData(
-      HANDLE modal_loop_pump_messages_event_handle,
-      gfx::NativeViewId dummy_activation_window) {
-  DCHECK(!modal_loop_pump_messages_event_.get());
-  DCHECK(!dummy_activation_window_);
-  base::win::ScopedHandle modal_loop_pump_messages_event(
-      modal_loop_pump_messages_event_handle);
-
-  dummy_activation_window_ = dummy_activation_window;
-  render_view_->Send(new ViewHostMsg_WindowlessPluginDummyWindowCreated(
-      render_view_->GetRoutingID(), dummy_activation_window_));
-
-  // Bug 25583: this can be null because some "virus scanners" block the
-  // DuplicateHandle call in the plugin process.
-  if (!modal_loop_pump_messages_event.IsValid())
-    return;
-
-  modal_loop_pump_messages_event_.reset(
-      new base::WaitableEvent(std::move(modal_loop_pump_messages_event)));
-}
-
-void WebPluginDelegateProxy::OnNotifyIMEStatus(int input_type,
-                                               const gfx::Rect& caret_rect) {
-  if (!render_view_)
-    return;
-
-  ViewHostMsg_TextInputState_Params params;
-  params.type = static_cast<ui::TextInputType>(input_type);
-  params.mode = ui::TEXT_INPUT_MODE_DEFAULT;
-  params.can_compose_inline = true;
-  render_view_->Send(new ViewHostMsg_TextInputStateChanged(
-      render_view_->GetRoutingID(), params));
-
-  ViewHostMsg_SelectionBounds_Params bounds_params;
-  bounds_params.anchor_rect = bounds_params.focus_rect = caret_rect;
-  bounds_params.anchor_dir = bounds_params.focus_dir =
-      blink::WebTextDirectionLeftToRight;
-  bounds_params.is_anchor_first = true;
-  render_view_->Send(new ViewHostMsg_SelectionBoundsChanged(
-      render_view_->GetRoutingID(), bounds_params));
-}
-#endif
-
 void WebPluginDelegateProxy::OnInvalidateRect(const gfx::Rect& rect) {
   if (!plugin_)
     return;
 
   // Clip the invalidation rect to the plugin bounds; the plugin may have been
   // resized since the invalidate message was sent.
   gfx::Rect clipped_rect =
       gfx::IntersectRects(rect, gfx::Rect(plugin_rect_.size()));
 
   invalidate_pending_ = true;
@@ skipping 177 matching lines @@
         index->mime_type == "application/x-vnd.movenetworks.qm" ||
         index->mime_type == "application/x-vnd.mnplayer.qm") {
       return true;
     }
   }
   return false;
 }
 #endif
 
 }  // namespace content