To facilitate apatrick's work on the 3D renderer for Pepper,...

chrome/renderer/webplugin_delegate_pepper.cc

 // Copyright (c) 2009 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.
 
 #define PEPPER_APIS_ENABLED 1
 
 #include "chrome/renderer/webplugin_delegate_pepper.h"
 
 #include <string>
 #include <vector>
 
 #include "app/gfx/blit.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/scoped_ptr.h"
 #include "base/stats_counters.h"
 #include "base/string_util.h"
 #include "webkit/api/public/WebInputEvent.h"
 #include "webkit/glue/glue_util.h"
+#include "webkit/glue/pepper/pepper.h"
 #include "webkit/glue/plugins/plugin_constants_win.h"
 #include "webkit/glue/plugins/plugin_instance.h"
 #include "webkit/glue/plugins/plugin_lib.h"
 #include "webkit/glue/plugins/plugin_list.h"
 #include "webkit/glue/plugins/plugin_stream_url.h"
 #include "webkit/glue/webkit_glue.h"
 
 using webkit_glue::WebPlugin;
 using webkit_glue::WebPluginDelegate;
 using webkit_glue::WebPluginResourceClient;
@@ skipping 242 matching lines @@
 
 void WebPluginDelegatePepper::Print(gfx::NativeDrawingContext context) {
   NOTIMPLEMENTED();
 }
 
 void WebPluginDelegatePepper::InstallMissingPlugin() {
   NOTIMPLEMENTED();
 }
 
 void WebPluginDelegatePepper::SetFocus() {
-  NPEvent npevent;
+  NPPepperEvent npevent;
 
   npevent.type = NPEventType_Focus;
-  npevent.size = sizeof(NPEvent);
+  npevent.size = sizeof(npevent);
   // TODO(sehr): what timestamp should this have?
   npevent.timeStampSeconds = 0.0;
   // Currently this API only supports gaining focus.
   npevent.u.focus.value = 1;
   instance()->NPP_HandleEvent(&npevent);
 }
 
 // Anonymous namespace for functions converting WebInputEvents to NPAPI types.
 namespace {
 NPEventTypes ConvertEventTypes(WebInputEvent::Type wetype) {
@@ skipping 17 matching lines @@
     case WebInputEvent::KeyUp:
       return NPEventType_KeyUp;
     case WebInputEvent::Char:
       return NPEventType_Char;
     case WebInputEvent::Undefined:
     default:
       return NPEventType_Undefined;
   }
 }
 
-void BuildKeyEvent(const WebInputEvent* event, NPEvent* npevent) {
+void BuildKeyEvent(const WebInputEvent* event, NPPepperEvent* npevent) {
   const WebKeyboardEvent* key_event =
       reinterpret_cast<const WebKeyboardEvent*>(event);
   npevent->u.key.modifier = key_event->modifiers;
   npevent->u.key.normalizedKeyCode = key_event->windowsKeyCode;
 }
 
-void BuildCharEvent(const WebInputEvent* event, NPEvent* npevent) {
+void BuildCharEvent(const WebInputEvent* event, NPPepperEvent* npevent) {
   const WebKeyboardEvent* key_event =
       reinterpret_cast<const WebKeyboardEvent*>(event);
   npevent->u.character.modifier = key_event->modifiers;
   // For consistency, check that the sizes of the texts agree.
   DCHECK(sizeof(npevent->u.character.text) == sizeof(key_event->text));
   DCHECK(sizeof(npevent->u.character.unmodifiedText) ==
          sizeof(key_event->unmodifiedText));
   for (size_t i = 0; i < WebKeyboardEvent::textLengthCap; ++i) {
     npevent->u.character.text[i] = key_event->text[i];
     npevent->u.character.unmodifiedText[i] = key_event->unmodifiedText[i];
   }
 }
 
-void BuildMouseEvent(const WebInputEvent* event, NPEvent* npevent) {
+void BuildMouseEvent(const WebInputEvent* event, NPPepperEvent* npevent) {
   const WebMouseEvent* mouse_event =
       reinterpret_cast<const WebMouseEvent*>(event);
   npevent->u.mouse.modifier = mouse_event->modifiers;
   npevent->u.mouse.button = mouse_event->button;
   npevent->u.mouse.x = mouse_event->x;
   npevent->u.mouse.y = mouse_event->y;
   npevent->u.mouse.clickCount = mouse_event->clickCount;
 }
 
-void BuildMouseWheelEvent(const WebInputEvent* event, NPEvent* npevent) {
+void BuildMouseWheelEvent(const WebInputEvent* event, NPPepperEvent* npevent) {
   const WebMouseWheelEvent* mouse_wheel_event =
       reinterpret_cast<const WebMouseWheelEvent*>(event);
   npevent->u.wheel.modifier = mouse_wheel_event->modifiers;
   npevent->u.wheel.deltaX = mouse_wheel_event->deltaX;
   npevent->u.wheel.deltaY = mouse_wheel_event->deltaY;
   npevent->u.wheel.wheelTicksX = mouse_wheel_event->wheelTicksX;
   npevent->u.wheel.wheelTicksY = mouse_wheel_event->wheelTicksY;
   npevent->u.wheel.scrollByPage = mouse_wheel_event->scrollByPage;
 }
 }  // namespace
 
 bool WebPluginDelegatePepper::HandleInputEvent(const WebInputEvent& event,
                                                WebCursorInfo* cursor_info) {
-  NPEvent npevent;
+  NPPepperEvent npevent;
 
   npevent.type = ConvertEventTypes(event.type);
-  npevent.size = sizeof(NPEvent);
+  npevent.size = sizeof(npevent);
   npevent.timeStampSeconds = event.timeStampSeconds;
   switch (npevent.type) {
     case NPEventType_Undefined:
       return false;
     case NPEventType_MouseDown:
     case NPEventType_MouseUp:
     case NPEventType_MouseMove:
     case NPEventType_MouseEnter:
     case NPEventType_MouseLeave:
       BuildMouseEvent(&event, &npevent);
@@ skipping 53 matching lines @@
 NPError WebPluginDelegatePepper::FlushRenderContext(NPRenderContext* context) {
   // TODO(brettw): we should have some kind of swapping of the canvases so we
   // can double buffer while avoiding this deep copy.
   if (!plugin_canvas_->getTopPlatformDevice().accessBitmap(false).copyTo(
           &committed_bitmap_, SkBitmap::kARGB_8888_Config))
     return NPERR_OUT_OF_MEMORY_ERROR;
 
   committed_bitmap_.setIsOpaque(false);
   return NPERR_NO_ERROR;
 }