Import TestRunner library into chromium.

content/test/layout_tests/runner/TestPlugin.cpp

Index: content/test/layout_tests/runner/TestPlugin.cpp
diff --git a/content/test/layout_tests/runner/TestPlugin.cpp b/content/test/layout_tests/runner/TestPlugin.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..df76cc3070e43eb5e1f6a8f8fe92c8e674934e76
--- /dev/null
+++ b/content/test/layout_tests/runner/TestPlugin.cpp
@@ -0,0 +1,585 @@
+// Copyright 2013 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.
+
+/*
+ * Copyright (C) 2011 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "content/test/layout_tests/runner/TestPlugin.h"
+
+#include "content/test/layout_tests/runner/TestCommon.h"
+#include "third_party/WebKit/public/platform/Platform.h"
+#include "third_party/WebKit/public/platform/WebCompositorSupport.h"
+#include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
+#include "content/public/test/layout_tests/WebTestDelegate.h"
+#include "third_party/WebKit/public/web/WebFrame.h"
+#include "third_party/WebKit/public/web/WebInputEvent.h"
+#include "third_party/WebKit/public/web/WebKit.h"
+#include "third_party/WebKit/public/web/WebPluginParams.h"
+#include "third_party/WebKit/public/web/WebTouchPoint.h"
+#include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
+
+using namespace blink;
+using namespace std;
+
+namespace WebTestRunner {
+
+namespace {
+
+// GLenum values copied from gl2.h.
+#define GL_FALSE                  0
+#define GL_TRUE                   1
+#define GL_ONE                    1
+#define GL_TRIANGLES              0x0004
+#define GL_ONE_MINUS_SRC_ALPHA    0x0303
+#define GL_DEPTH_TEST             0x0B71
+#define GL_BLEND                  0x0BE2
+#define GL_SCISSOR_TEST           0x0B90
+#define GL_TEXTURE_2D             0x0DE1
+#define GL_FLOAT                  0x1406
+#define GL_RGBA                   0x1908
+#define GL_UNSIGNED_BYTE          0x1401
+#define GL_TEXTURE_MAG_FILTER     0x2800
+#define GL_TEXTURE_MIN_FILTER     0x2801
+#define GL_TEXTURE_WRAP_S         0x2802
+#define GL_TEXTURE_WRAP_T         0x2803
+#define GL_NEAREST                0x2600
+#define GL_COLOR_BUFFER_BIT       0x4000
+#define GL_CLAMP_TO_EDGE          0x812F
+#define GL_ARRAY_BUFFER           0x8892
+#define GL_STATIC_DRAW            0x88E4
+#define GL_FRAGMENT_SHADER        0x8B30
+#define GL_VERTEX_SHADER          0x8B31
+#define GL_COMPILE_STATUS         0x8B81
+#define GL_LINK_STATUS            0x8B82
+#define GL_COLOR_ATTACHMENT0      0x8CE0
+#define GL_FRAMEBUFFER_COMPLETE   0x8CD5
+#define GL_FRAMEBUFFER            0x8D40
+
+void premultiplyAlpha(const unsigned colorIn[3], float alpha, float colorOut[4])
+{
+    for (int i = 0; i < 3; ++i)
+        colorOut[i] = (colorIn[i] / 255.0f) * alpha;
+
+    colorOut[3] = alpha;
+}
+
+const char* pointState(WebTouchPoint::State state)
+{
+    switch (state) {
+    case WebTouchPoint::StateReleased:
+        return "Released";
+    case WebTouchPoint::StatePressed:
+        return "Pressed";
+    case WebTouchPoint::StateMoved:
+        return "Moved";
+    case WebTouchPoint::StateCancelled:
+        return "Cancelled";
+    default:
+        return "Unknown";
+    }
+
+    BLINK_ASSERT_NOT_REACHED();
+    return 0;
+}
+
+void printTouchList(WebTestDelegate* delegate, const WebTouchPoint* points, int length)
+{
+    for (int i = 0; i < length; ++i) {
+        char buffer[100];
+        snprintf(buffer, sizeof(buffer), "* %d, %d: %s\n", points[i].position.x, points[i].position.y, pointState(points[i].state));
+        delegate->printMessage(buffer);
+    }
+}
+
+void printEventDetails(WebTestDelegate* delegate, const WebInputEvent& event)
+{
+    if (WebInputEvent::isTouchEventType(event.type)) {
+        const WebTouchEvent& touch = static_cast<const WebTouchEvent&>(event);
+        printTouchList(delegate, touch.touches, touch.touchesLength);
+        printTouchList(delegate, touch.changedTouches, touch.changedTouchesLength);
+        printTouchList(delegate, touch.targetTouches, touch.targetTouchesLength);
+    } else if (WebInputEvent::isMouseEventType(event.type) || event.type == WebInputEvent::MouseWheel) {
+        const WebMouseEvent& mouse = static_cast<const WebMouseEvent&>(event);
+        char buffer[100];
+        snprintf(buffer, sizeof(buffer), "* %d, %d\n", mouse.x, mouse.y);
+        delegate->printMessage(buffer);
+    } else if (WebInputEvent::isGestureEventType(event.type)) {
+        const WebGestureEvent& gesture = static_cast<const WebGestureEvent&>(event);
+        char buffer[100];
+        snprintf(buffer, sizeof(buffer), "* %d, %d\n", gesture.x, gesture.y);
+        delegate->printMessage(buffer);
+    }
+}
+
+WebPluginContainer::TouchEventRequestType parseTouchEventRequestType(const WebString& string)
+{
+    if (string == WebString::fromUTF8("raw"))
+        return WebPluginContainer::TouchEventRequestTypeRaw;
+    if (string == WebString::fromUTF8("synthetic"))
+        return WebPluginContainer::TouchEventRequestTypeSynthesizedMouse;
+    return WebPluginContainer::TouchEventRequestTypeNone;
+}
+
+void deferredDelete(void* context)
+{
+    TestPlugin* plugin = static_cast<TestPlugin*>(context);
+    delete plugin;
+}
+
+}
+
+
+TestPlugin::TestPlugin(WebFrame* frame, const WebPluginParams& params, WebTestDelegate* delegate)
+    : m_frame(frame)
+    , m_delegate(delegate)
+    , m_container(0)
+    , m_context(0)
+    , m_colorTexture(0)
+    , m_mailboxChanged(false)
+    , m_framebuffer(0)
+    , m_touchEventRequest(WebPluginContainer::TouchEventRequestTypeNone)
+    , m_reRequestTouchEvents(false)
+    , m_printEventDetails(false)
+    , m_printUserGestureStatus(false)
+    , m_canProcessDrag(false)
+{
+    static const WebString kAttributePrimitive = WebString::fromUTF8("primitive");
+    static const WebString kAttributeBackgroundColor = WebString::fromUTF8("background-color");
+    static const WebString kAttributePrimitiveColor = WebString::fromUTF8("primitive-color");
+    static const WebString kAttributeOpacity = WebString::fromUTF8("opacity");
+    static const WebString kAttributeAcceptsTouch = WebString::fromUTF8("accepts-touch");
+    static const WebString kAttributeReRequestTouchEvents = WebString::fromUTF8("re-request-touch");
+    static const WebString kAttributePrintEventDetails = WebString::fromUTF8("print-event-details");
+    static const WebString kAttributeCanProcessDrag = WebString::fromUTF8("can-process-drag");
+    static const WebString kAttributePrintUserGestureStatus = WebString::fromUTF8("print-user-gesture-status");
+
+    BLINK_ASSERT(params.attributeNames.size() == params.attributeValues.size());
+    size_t size = params.attributeNames.size();
+    for (size_t i = 0; i < size; ++i) {
+        const WebString& attributeName = params.attributeNames[i];
+        const WebString& attributeValue = params.attributeValues[i];
+
+        if (attributeName == kAttributePrimitive)
+            m_scene.primitive = parsePrimitive(attributeValue);
+        else if (attributeName == kAttributeBackgroundColor)
+            parseColor(attributeValue, m_scene.backgroundColor);
+        else if (attributeName == kAttributePrimitiveColor)
+            parseColor(attributeValue, m_scene.primitiveColor);
+        else if (attributeName == kAttributeOpacity)
+            m_scene.opacity = parseOpacity(attributeValue);
+        else if (attributeName == kAttributeAcceptsTouch)
+            m_touchEventRequest = parseTouchEventRequestType(attributeValue);
+        else if (attributeName == kAttributeReRequestTouchEvents)
+            m_reRequestTouchEvents = parseBoolean(attributeValue);
+        else if (attributeName == kAttributePrintEventDetails)
+            m_printEventDetails = parseBoolean(attributeValue);
+        else if (attributeName == kAttributeCanProcessDrag)
+            m_canProcessDrag = parseBoolean(attributeValue);
+        else if (attributeName == kAttributePrintUserGestureStatus)
+            m_printUserGestureStatus = parseBoolean(attributeValue);
+    }
+}
+
+TestPlugin::~TestPlugin()
+{
+}
+
+bool TestPlugin::initialize(WebPluginContainer* container)
+{
+    WebGraphicsContext3D::Attributes attrs;
+    m_context = Platform::current()->createOffscreenGraphicsContext3D(attrs);
+    if (!m_context)
+        return false;
+
+    if (!m_context->makeContextCurrent())
+        return false;
+
+    if (!initScene())
+        return false;
+
+    m_layer = WebScopedPtr<WebExternalTextureLayer>(Platform::current()->compositorSupport()->createExternalTextureLayer(this));
+    m_container = container;
+    m_container->setWebLayer(m_layer->layer());
+    if (m_reRequestTouchEvents) {
+        m_container->requestTouchEventType(WebPluginContainer::TouchEventRequestTypeSynthesizedMouse);
+        m_container->requestTouchEventType(WebPluginContainer::TouchEventRequestTypeRaw);
+    }
+    m_container->requestTouchEventType(m_touchEventRequest);
+    m_container->setWantsWheelEvents(true);
+    return true;
+}
+
+void TestPlugin::destroy()
+{
+    if (m_layer.get())
+        m_layer->clearTexture();
+    if (m_container)
+        m_container->setWebLayer(0);
+    m_layer.reset();
+    destroyScene();
+
+    delete m_context;
+    m_context = 0;
+
+    m_container = 0;
+    m_frame = 0;
+
+    Platform::current()->callOnMainThread(deferredDelete, this);
+}
+
+void TestPlugin::updateGeometry(const WebRect& frameRect, const WebRect& clipRect, const WebVector<WebRect>& cutOutsRects, bool isVisible)
+{
+    if (clipRect == m_rect)
+        return;
+    m_rect = clipRect;
+    if (m_rect.isEmpty())
+        return;
+
+    m_context->reshapeWithScaleFactor(m_rect.width, m_rect.height, 1.f);
+    m_context->viewport(0, 0, m_rect.width, m_rect.height);
+
+    m_context->bindTexture(GL_TEXTURE_2D, m_colorTexture);
+    m_context->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    m_context->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    m_context->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    m_context->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    m_context->texImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_rect.width, m_rect.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+    m_context->bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
+    m_context->framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_colorTexture, 0);
+
+    drawScene();
+
+    m_context->genMailboxCHROMIUM(m_mailbox.name);
+    m_context->produceTextureCHROMIUM(GL_TEXTURE_2D, m_mailbox.name);
+
+    m_context->flush();
+    m_layer->layer()->invalidate();
+    m_mailboxChanged = true;
+}
+
+bool TestPlugin::prepareMailbox(blink::WebExternalTextureMailbox* mailbox, blink::WebExternalBitmap*)
+{
+    if (!m_mailboxChanged)
+        return false;
+    *mailbox = m_mailbox;
+    m_mailboxChanged = false;
+    return true;
+}
+
+void TestPlugin::mailboxReleased(const blink::WebExternalTextureMailbox&)
+{
+}
+
+TestPlugin::Primitive TestPlugin::parsePrimitive(const WebString& string)
+{
+    static const WebString kPrimitiveNone = WebString::fromUTF8("none");
+    static const WebString kPrimitiveTriangle = WebString::fromUTF8("triangle");
+
+    Primitive primitive = PrimitiveNone;
+    if (string == kPrimitiveNone)
+        primitive = PrimitiveNone;
+    else if (string == kPrimitiveTriangle)
+        primitive = PrimitiveTriangle;
+    else
+        BLINK_ASSERT_NOT_REACHED();
+    return primitive;
+}
+
+// FIXME: This method should already exist. Use it.
+// For now just parse primary colors.
+void TestPlugin::parseColor(const WebString& string, unsigned color[3])
+{
+    color[0] = color[1] = color[2] = 0;
+    if (string == "black")
+        return;
+
+    if (string == "red")
+        color[0] = 255;
+    else if (string == "green")
+        color[1] = 255;
+    else if (string == "blue")
+        color[2] = 255;
+    else
+        BLINK_ASSERT_NOT_REACHED();
+}
+
+float TestPlugin::parseOpacity(const WebString& string)
+{
+    return static_cast<float>(atof(string.utf8().data()));
+}
+
+bool TestPlugin::parseBoolean(const WebString& string)
+{
+    static const WebString kPrimitiveTrue = WebString::fromUTF8("true");
+    return string == kPrimitiveTrue;
+}
+
+bool TestPlugin::initScene()
+{
+    float color[4];
+    premultiplyAlpha(m_scene.backgroundColor, m_scene.opacity, color);
+
+    m_colorTexture = m_context->createTexture();
+    m_framebuffer = m_context->createFramebuffer();
+
+    m_context->viewport(0, 0, m_rect.width, m_rect.height);
+    m_context->disable(GL_DEPTH_TEST);
+    m_context->disable(GL_SCISSOR_TEST);
+
+    m_context->clearColor(color[0], color[1], color[2], color[3]);
+
+    m_context->enable(GL_BLEND);
+    m_context->blendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+
+    return m_scene.primitive != PrimitiveNone ? initProgram() && initPrimitive() : true;
+}
+
+void TestPlugin::drawScene()
+{
+    m_context->viewport(0, 0, m_rect.width, m_rect.height);
+    m_context->clear(GL_COLOR_BUFFER_BIT);
+
+    if (m_scene.primitive != PrimitiveNone)
+        drawPrimitive();
+}
+
+void TestPlugin::destroyScene()
+{
+    if (m_scene.program) {
+        m_context->deleteProgram(m_scene.program);
+        m_scene.program = 0;
+    }
+    if (m_scene.vbo) {
+        m_context->deleteBuffer(m_scene.vbo);
+        m_scene.vbo = 0;
+    }
+
+    if (m_framebuffer) {
+        m_context->deleteFramebuffer(m_framebuffer);
+        m_framebuffer = 0;
+    }
+
+    if (m_colorTexture) {
+        m_context->deleteTexture(m_colorTexture);
+        m_colorTexture = 0;
+    }
+}
+
+bool TestPlugin::initProgram()
+{
+    const string vertexSource(
+        "attribute vec4 position;  \n"
+        "void main() {             \n"
+        "  gl_Position = position; \n"
+        "}                         \n"
+    );
+
+    const string fragmentSource(
+        "precision mediump float; \n"
+        "uniform vec4 color;      \n"
+        "void main() {            \n"
+        "  gl_FragColor = color;  \n"
+        "}                        \n"
+    );
+
+    m_scene.program = loadProgram(vertexSource, fragmentSource);
+    if (!m_scene.program)
+        return false;
+
+    m_scene.colorLocation = m_context->getUniformLocation(m_scene.program, "color");
+    m_scene.positionLocation = m_context->getAttribLocation(m_scene.program, "position");
+    return true;
+}
+
+bool TestPlugin::initPrimitive()
+{
+    BLINK_ASSERT(m_scene.primitive == PrimitiveTriangle);
+
+    m_scene.vbo = m_context->createBuffer();
+    if (!m_scene.vbo)
+        return false;
+
+    const float vertices[] = {
+        0.0f,  0.8f, 0.0f,
+        -0.8f, -0.8f, 0.0f,
+        0.8f, -0.8f, 0.0f };
+    m_context->bindBuffer(GL_ARRAY_BUFFER, m_scene.vbo);
+    m_context->bufferData(GL_ARRAY_BUFFER, sizeof(vertices), 0, GL_STATIC_DRAW);
+    m_context->bufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices);
+    return true;
+}
+
+void TestPlugin::drawPrimitive()
+{
+    BLINK_ASSERT(m_scene.primitive == PrimitiveTriangle);
+    BLINK_ASSERT(m_scene.vbo);
+    BLINK_ASSERT(m_scene.program);
+
+    m_context->useProgram(m_scene.program);
+
+    // Bind primitive color.
+    float color[4];
+    premultiplyAlpha(m_scene.primitiveColor, m_scene.opacity, color);
+    m_context->uniform4f(m_scene.colorLocation, color[0], color[1], color[2], color[3]);
+
+    // Bind primitive vertices.
+    m_context->bindBuffer(GL_ARRAY_BUFFER, m_scene.vbo);
+    m_context->enableVertexAttribArray(m_scene.positionLocation);
+    m_context->vertexAttribPointer(m_scene.positionLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
+    m_context->drawArrays(GL_TRIANGLES, 0, 3);
+}
+
+unsigned TestPlugin::loadShader(unsigned type, const string& source)
+{
+    unsigned shader = m_context->createShader(type);
+    if (shader) {
+        m_context->shaderSource(shader, source.data());
+        m_context->compileShader(shader);
+
+        int compiled = 0;
+        m_context->getShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+        if (!compiled) {
+            m_context->deleteShader(shader);
+            shader = 0;
+        }
+    }
+    return shader;
+}
+
+unsigned TestPlugin::loadProgram(const string& vertexSource, const string& fragmentSource)
+{
+    unsigned vertexShader = loadShader(GL_VERTEX_SHADER, vertexSource);
+    unsigned fragmentShader = loadShader(GL_FRAGMENT_SHADER, fragmentSource);
+    unsigned program = m_context->createProgram();
+    if (vertexShader && fragmentShader && program) {
+        m_context->attachShader(program, vertexShader);
+        m_context->attachShader(program, fragmentShader);
+        m_context->linkProgram(program);
+
+        int linked = 0;
+        m_context->getProgramiv(program, GL_LINK_STATUS, &linked);
+        if (!linked) {
+            m_context->deleteProgram(program);
+            program = 0;
+        }
+    }
+    if (vertexShader)
+        m_context->deleteShader(vertexShader);
+    if (fragmentShader)
+        m_context->deleteShader(fragmentShader);
+
+    return program;
+}
+
+bool TestPlugin::handleInputEvent(const WebInputEvent& event, WebCursorInfo& info)
+{
+    const char* eventName = 0;
+    switch (event.type) {
+    case WebInputEvent::Undefined:           eventName = "unknown"; break;
+
+    case WebInputEvent::MouseDown:           eventName = "MouseDown"; break;
+    case WebInputEvent::MouseUp:             eventName = "MouseUp"; break;
+    case WebInputEvent::MouseMove:           eventName = "MouseMove"; break;
+    case WebInputEvent::MouseEnter:          eventName = "MouseEnter"; break;
+    case WebInputEvent::MouseLeave:          eventName = "MouseLeave"; break;
+    case WebInputEvent::ContextMenu:         eventName = "ContextMenu"; break;
+
+    case WebInputEvent::MouseWheel:          eventName = "MouseWheel"; break;
+
+    case WebInputEvent::RawKeyDown:          eventName = "RawKeyDown"; break;
+    case WebInputEvent::KeyDown:             eventName = "KeyDown"; break;
+    case WebInputEvent::KeyUp:               eventName = "KeyUp"; break;
+    case WebInputEvent::Char:                eventName = "Char"; break;
+
+    case WebInputEvent::GestureScrollBegin:  eventName = "GestureScrollBegin"; break;
+    case WebInputEvent::GestureScrollEnd:    eventName = "GestureScrollEnd"; break;
+    case WebInputEvent::GestureScrollUpdateWithoutPropagation:
+    case WebInputEvent::GestureScrollUpdate: eventName = "GestureScrollUpdate"; break;
+    case WebInputEvent::GestureFlingStart:   eventName = "GestureFlingStart"; break;
+    case WebInputEvent::GestureFlingCancel:  eventName = "GestureFlingCancel"; break;
+    case WebInputEvent::GestureTap:          eventName = "GestureTap"; break;
+    case WebInputEvent::GestureTapUnconfirmed:
+                                             eventName = "GestureTapUnconfirmed"; break;
+    case WebInputEvent::GestureTapDown:      eventName = "GestureTapDown"; break;
+    case WebInputEvent::GestureShowPress:    eventName = "GestureShowPress"; break;
+    case WebInputEvent::GestureTapCancel:    eventName = "GestureTapCancel"; break;
+    case WebInputEvent::GestureDoubleTap:    eventName = "GestureDoubleTap"; break;
+    case WebInputEvent::GestureTwoFingerTap: eventName = "GestureTwoFingerTap"; break;
+    case WebInputEvent::GestureLongPress:    eventName = "GestureLongPress"; break;
+    case WebInputEvent::GestureLongTap:      eventName = "GestureLongTap"; break;
+    case WebInputEvent::GesturePinchBegin:   eventName = "GesturePinchBegin"; break;
+    case WebInputEvent::GesturePinchEnd:     eventName = "GesturePinchEnd"; break;
+    case WebInputEvent::GesturePinchUpdate:  eventName = "GesturePinchUpdate"; break;
+
+    case WebInputEvent::TouchStart:          eventName = "TouchStart"; break;
+    case WebInputEvent::TouchMove:           eventName = "TouchMove"; break;
+    case WebInputEvent::TouchEnd:            eventName = "TouchEnd"; break;
+    case WebInputEvent::TouchCancel:         eventName = "TouchCancel"; break;
+    }
+
+    m_delegate->printMessage(std::string("Plugin received event: ") + (eventName ? eventName : "unknown") + "\n");
+    if (m_printEventDetails)
+        printEventDetails(m_delegate, event);
+    if (m_printUserGestureStatus)
+        m_delegate->printMessage(std::string("* ") + (WebUserGestureIndicator::isProcessingUserGesture() ? "" : "not ") + "handling user gesture\n");
+    return false;
+}
+
+bool TestPlugin::handleDragStatusUpdate(WebDragStatus dragStatus, const WebDragData&, WebDragOperationsMask, const WebPoint& position, const WebPoint& screenPosition)
+{
+    const char* dragStatusName = 0;
+    switch (dragStatus) {
+    case WebDragStatusEnter:
+        dragStatusName = "DragEnter";
+        break;
+    case WebDragStatusOver:
+        dragStatusName = "DragOver";
+        break;
+    case WebDragStatusLeave:
+        dragStatusName = "DragLeave";
+        break;
+    case WebDragStatusDrop:
+        dragStatusName = "DragDrop";
+        break;
+    case WebDragStatusUnknown:
+        BLINK_ASSERT_NOT_REACHED();
+    }
+    m_delegate->printMessage(std::string("Plugin received event: ") + dragStatusName + "\n");
+    return false;
+}
+
+TestPlugin* TestPlugin::create(WebFrame* frame, const WebPluginParams& params, WebTestDelegate* delegate)
+{
+    return new TestPlugin(frame, params, delegate);
+}
+
+const WebString& TestPlugin::mimeType()
+{
+    static const WebString kMimeType = WebString::fromUTF8("application/x-webkit-test-webplugin");
+    return kMimeType;
+}
+
+}