Home | History | Annotate | Download | only in test_runner 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/shell/renderer/test_runner/TestPlugin.h"
      6 
      7 #include "base/basictypes.h"
      8 #include "base/bind.h"
      9 #include "base/logging.h"
     10 #include "base/memory/shared_memory.h"
     11 #include "content/public/renderer/render_thread.h"
     12 #include "content/shell/renderer/test_runner/TestCommon.h"
     13 #include "content/shell/renderer/test_runner/WebTestDelegate.h"
     14 #include "third_party/skia/include/core/SkBitmap.h"
     15 #include "third_party/skia/include/core/SkCanvas.h"
     16 #include "third_party/skia/include/core/SkColor.h"
     17 #include "third_party/WebKit/public/platform/Platform.h"
     18 #include "third_party/WebKit/public/platform/WebCompositorSupport.h"
     19 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
     20 #include "third_party/WebKit/public/web/WebFrame.h"
     21 #include "third_party/WebKit/public/web/WebInputEvent.h"
     22 #include "third_party/WebKit/public/web/WebKit.h"
     23 #include "third_party/WebKit/public/web/WebPluginParams.h"
     24 #include "third_party/WebKit/public/web/WebTouchPoint.h"
     25 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
     26 
     27 using namespace blink;
     28 using namespace std;
     29 
     30 namespace content {
     31 
     32 namespace {
     33 
     34 // GLenum values copied from gl2.h.
     35 #define GL_FALSE                  0
     36 #define GL_TRUE                   1
     37 #define GL_ONE                    1
     38 #define GL_TRIANGLES              0x0004
     39 #define GL_ONE_MINUS_SRC_ALPHA    0x0303
     40 #define GL_DEPTH_TEST             0x0B71
     41 #define GL_BLEND                  0x0BE2
     42 #define GL_SCISSOR_TEST           0x0B90
     43 #define GL_TEXTURE_2D             0x0DE1
     44 #define GL_FLOAT                  0x1406
     45 #define GL_RGBA                   0x1908
     46 #define GL_UNSIGNED_BYTE          0x1401
     47 #define GL_TEXTURE_MAG_FILTER     0x2800
     48 #define GL_TEXTURE_MIN_FILTER     0x2801
     49 #define GL_TEXTURE_WRAP_S         0x2802
     50 #define GL_TEXTURE_WRAP_T         0x2803
     51 #define GL_NEAREST                0x2600
     52 #define GL_COLOR_BUFFER_BIT       0x4000
     53 #define GL_CLAMP_TO_EDGE          0x812F
     54 #define GL_ARRAY_BUFFER           0x8892
     55 #define GL_STATIC_DRAW            0x88E4
     56 #define GL_FRAGMENT_SHADER        0x8B30
     57 #define GL_VERTEX_SHADER          0x8B31
     58 #define GL_COMPILE_STATUS         0x8B81
     59 #define GL_LINK_STATUS            0x8B82
     60 #define GL_COLOR_ATTACHMENT0      0x8CE0
     61 #define GL_FRAMEBUFFER_COMPLETE   0x8CD5
     62 #define GL_FRAMEBUFFER            0x8D40
     63 
     64 void premultiplyAlpha(const unsigned colorIn[3], float alpha, float colorOut[4])
     65 {
     66     for (int i = 0; i < 3; ++i)
     67         colorOut[i] = (colorIn[i] / 255.0f) * alpha;
     68 
     69     colorOut[3] = alpha;
     70 }
     71 
     72 const char* pointState(WebTouchPoint::State state)
     73 {
     74     switch (state) {
     75     case WebTouchPoint::StateReleased:
     76         return "Released";
     77     case WebTouchPoint::StatePressed:
     78         return "Pressed";
     79     case WebTouchPoint::StateMoved:
     80         return "Moved";
     81     case WebTouchPoint::StateCancelled:
     82         return "Cancelled";
     83     default:
     84         return "Unknown";
     85     }
     86 }
     87 
     88 void printTouchList(WebTestDelegate* delegate, const WebTouchPoint* points, int length)
     89 {
     90     for (int i = 0; i < length; ++i) {
     91         char buffer[100];
     92         snprintf(buffer,
     93                  sizeof(buffer),
     94                  "* %.2f, %.2f: %s\n",
     95                  points[i].position.x,
     96                  points[i].position.y,
     97                  pointState(points[i].state));
     98         delegate->printMessage(buffer);
     99     }
    100 }
    101 
    102 void printEventDetails(WebTestDelegate* delegate, const WebInputEvent& event)
    103 {
    104     if (WebInputEvent::isTouchEventType(event.type)) {
    105         const WebTouchEvent& touch = static_cast<const WebTouchEvent&>(event);
    106         printTouchList(delegate, touch.touches, touch.touchesLength);
    107         printTouchList(delegate, touch.changedTouches, touch.changedTouchesLength);
    108         printTouchList(delegate, touch.targetTouches, touch.targetTouchesLength);
    109     } else if (WebInputEvent::isMouseEventType(event.type) || event.type == WebInputEvent::MouseWheel) {
    110         const WebMouseEvent& mouse = static_cast<const WebMouseEvent&>(event);
    111         char buffer[100];
    112         snprintf(buffer, sizeof(buffer), "* %d, %d\n", mouse.x, mouse.y);
    113         delegate->printMessage(buffer);
    114     } else if (WebInputEvent::isGestureEventType(event.type)) {
    115         const WebGestureEvent& gesture = static_cast<const WebGestureEvent&>(event);
    116         char buffer[100];
    117         snprintf(buffer, sizeof(buffer), "* %d, %d\n", gesture.x, gesture.y);
    118         delegate->printMessage(buffer);
    119     }
    120 }
    121 
    122 WebPluginContainer::TouchEventRequestType parseTouchEventRequestType(const WebString& string)
    123 {
    124     if (string == WebString::fromUTF8("raw"))
    125         return WebPluginContainer::TouchEventRequestTypeRaw;
    126     if (string == WebString::fromUTF8("synthetic"))
    127         return WebPluginContainer::TouchEventRequestTypeSynthesizedMouse;
    128     return WebPluginContainer::TouchEventRequestTypeNone;
    129 }
    130 
    131 void deferredDelete(void* context)
    132 {
    133     TestPlugin* plugin = static_cast<TestPlugin*>(context);
    134     delete plugin;
    135 }
    136 
    137 }
    138 
    139 TestPlugin::TestPlugin(WebFrame* frame, const WebPluginParams& params, WebTestDelegate* delegate)
    140     : m_frame(frame)
    141     , m_delegate(delegate)
    142     , m_container(0)
    143     , m_context(0)
    144     , m_colorTexture(0)
    145     , m_mailboxChanged(false)
    146     , m_framebuffer(0)
    147     , m_touchEventRequest(WebPluginContainer::TouchEventRequestTypeNone)
    148     , m_reRequestTouchEvents(false)
    149     , m_printEventDetails(false)
    150     , m_printUserGestureStatus(false)
    151     , m_canProcessDrag(false)
    152     , m_isPersistent(params.mimeType == pluginPersistsMimeType())
    153     , m_canCreateWithoutRenderer(params.mimeType == canCreateWithoutRendererMimeType())
    154 {
    155     const CR_DEFINE_STATIC_LOCAL(WebString, kAttributePrimitive, ("primitive"));
    156     const CR_DEFINE_STATIC_LOCAL(WebString, kAttributeBackgroundColor, ("background-color"));
    157     const CR_DEFINE_STATIC_LOCAL(WebString, kAttributePrimitiveColor, ("primitive-color"));
    158     const CR_DEFINE_STATIC_LOCAL(WebString, kAttributeOpacity, ("opacity"));
    159     const CR_DEFINE_STATIC_LOCAL(WebString, kAttributeAcceptsTouch, ("accepts-touch"));
    160     const CR_DEFINE_STATIC_LOCAL(WebString, kAttributeReRequestTouchEvents, ("re-request-touch"));
    161     const CR_DEFINE_STATIC_LOCAL(WebString, kAttributePrintEventDetails, ("print-event-details"));
    162     const CR_DEFINE_STATIC_LOCAL(WebString, kAttributeCanProcessDrag, ("can-process-drag"));
    163     const CR_DEFINE_STATIC_LOCAL(WebString, kAttributePrintUserGestureStatus, ("print-user-gesture-status"));
    164 
    165     DCHECK_EQ(params.attributeNames.size(), params.attributeValues.size());
    166     size_t size = params.attributeNames.size();
    167     for (size_t i = 0; i < size; ++i) {
    168         const WebString& attributeName = params.attributeNames[i];
    169         const WebString& attributeValue = params.attributeValues[i];
    170 
    171         if (attributeName == kAttributePrimitive)
    172             m_scene.primitive = parsePrimitive(attributeValue);
    173         else if (attributeName == kAttributeBackgroundColor)
    174             parseColor(attributeValue, m_scene.backgroundColor);
    175         else if (attributeName == kAttributePrimitiveColor)
    176             parseColor(attributeValue, m_scene.primitiveColor);
    177         else if (attributeName == kAttributeOpacity)
    178             m_scene.opacity = parseOpacity(attributeValue);
    179         else if (attributeName == kAttributeAcceptsTouch)
    180             m_touchEventRequest = parseTouchEventRequestType(attributeValue);
    181         else if (attributeName == kAttributeReRequestTouchEvents)
    182             m_reRequestTouchEvents = parseBoolean(attributeValue);
    183         else if (attributeName == kAttributePrintEventDetails)
    184             m_printEventDetails = parseBoolean(attributeValue);
    185         else if (attributeName == kAttributeCanProcessDrag)
    186             m_canProcessDrag = parseBoolean(attributeValue);
    187         else if (attributeName == kAttributePrintUserGestureStatus)
    188             m_printUserGestureStatus = parseBoolean(attributeValue);
    189     }
    190     if (m_canCreateWithoutRenderer)
    191         m_delegate->printMessage(std::string("TestPlugin: canCreateWithoutRenderer\n"));
    192 }
    193 
    194 TestPlugin::~TestPlugin()
    195 {
    196 }
    197 
    198 bool TestPlugin::initialize(WebPluginContainer* container)
    199 {
    200     WebGraphicsContext3D::Attributes attrs;
    201     m_context = Platform::current()->createOffscreenGraphicsContext3D(attrs);
    202     if (m_context && !m_context->makeContextCurrent()) {
    203         delete m_context;
    204         m_context = 0;
    205     }
    206 
    207     if (!initScene())
    208         return false;
    209 
    210     m_layer = cc::TextureLayer::CreateForMailbox(this);
    211     m_webLayer = make_scoped_ptr(InstantiateWebLayer(m_layer));
    212     m_container = container;
    213     m_container->setWebLayer(m_webLayer.get());
    214     if (m_reRequestTouchEvents) {
    215         m_container->requestTouchEventType(WebPluginContainer::TouchEventRequestTypeSynthesizedMouse);
    216         m_container->requestTouchEventType(WebPluginContainer::TouchEventRequestTypeRaw);
    217     }
    218     m_container->requestTouchEventType(m_touchEventRequest);
    219     m_container->setWantsWheelEvents(true);
    220     return true;
    221 }
    222 
    223 void TestPlugin::destroy()
    224 {
    225     if (m_layer.get())
    226         m_layer->ClearTexture();
    227     if (m_container)
    228         m_container->setWebLayer(0);
    229     m_webLayer.reset();
    230     m_layer = NULL;
    231     destroyScene();
    232 
    233     delete m_context;
    234     m_context = 0;
    235 
    236     m_container = 0;
    237     m_frame = 0;
    238 
    239     Platform::current()->callOnMainThread(deferredDelete, this);
    240 }
    241 
    242 NPObject* TestPlugin::scriptableObject()
    243 {
    244     return 0;
    245 }
    246 
    247 bool TestPlugin::canProcessDrag() const
    248 {
    249     return m_canProcessDrag;
    250 }
    251 
    252 void TestPlugin::updateGeometry(const WebRect& frameRect, const WebRect& clipRect, const WebVector<WebRect>& cutOutsRects, bool isVisible)
    253 {
    254     if (clipRect == m_rect)
    255         return;
    256     m_rect = clipRect;
    257 
    258     if (m_rect.isEmpty()) {
    259         m_textureMailbox = cc::TextureMailbox();
    260     } else if (m_context) {
    261         m_context->viewport(0, 0, m_rect.width, m_rect.height);
    262 
    263         m_context->bindTexture(GL_TEXTURE_2D, m_colorTexture);
    264         m_context->texParameteri(
    265             GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    266         m_context->texParameteri(
    267             GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    268         m_context->texParameteri(
    269             GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    270         m_context->texParameteri(
    271             GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    272         m_context->texImage2D(GL_TEXTURE_2D,
    273                               0,
    274                               GL_RGBA,
    275                               m_rect.width,
    276                               m_rect.height,
    277                               0,
    278                               GL_RGBA,
    279                               GL_UNSIGNED_BYTE,
    280                               0);
    281         m_context->bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
    282         m_context->framebufferTexture2D(GL_FRAMEBUFFER,
    283                                         GL_COLOR_ATTACHMENT0,
    284                                         GL_TEXTURE_2D,
    285                                         m_colorTexture,
    286                                         0);
    287 
    288         drawSceneGL();
    289 
    290         gpu::Mailbox mailbox;
    291         m_context->genMailboxCHROMIUM(mailbox.name);
    292         m_context->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
    293         m_context->flush();
    294         uint32 syncPoint = m_context->insertSyncPoint();
    295         m_textureMailbox = cc::TextureMailbox(mailbox, GL_TEXTURE_2D, syncPoint);
    296     } else {
    297         size_t bytes = 4 * m_rect.width * m_rect.height;
    298         scoped_ptr<base::SharedMemory> bitmap =
    299             RenderThread::Get()->HostAllocateSharedMemoryBuffer(bytes);
    300         if (!bitmap->Map(bytes)) {
    301             m_textureMailbox = cc::TextureMailbox();
    302         } else {
    303             drawSceneSoftware(bitmap->memory(), bytes);
    304             m_textureMailbox = cc::TextureMailbox(
    305                 bitmap.get(), gfx::Size(m_rect.width, m_rect.height));
    306             m_sharedBitmap = bitmap.Pass();
    307         }
    308     }
    309 
    310     m_mailboxChanged = true;
    311     m_layer->SetNeedsDisplay();
    312 }
    313 
    314 bool TestPlugin::acceptsInputEvents()
    315 {
    316     return true;
    317 }
    318 
    319 bool TestPlugin::isPlaceholder()
    320 {
    321     return false;
    322 }
    323 
    324 static void ignoreReleaseCallback(uint32 sync_point, bool lost) {}
    325 
    326 static void releaseSharedMemory(scoped_ptr<base::SharedMemory> bitmap,
    327                                 uint32 sync_point,
    328                                 bool lost) {}
    329 
    330 bool TestPlugin::PrepareTextureMailbox(
    331     cc::TextureMailbox* mailbox,
    332     scoped_ptr<cc::SingleReleaseCallback>* releaseCallback,
    333     bool useSharedMemory) {
    334     if (!m_mailboxChanged)
    335         return false;
    336     *mailbox = m_textureMailbox;
    337     if (m_textureMailbox.IsTexture()) {
    338       *releaseCallback =
    339           cc::SingleReleaseCallback::Create(base::Bind(&ignoreReleaseCallback));
    340     } else {
    341       *releaseCallback = cc::SingleReleaseCallback::Create(
    342           base::Bind(&releaseSharedMemory, base::Passed(&m_sharedBitmap)));
    343     }
    344     m_mailboxChanged = false;
    345     return true;
    346 }
    347 
    348 TestPlugin::Primitive TestPlugin::parsePrimitive(const WebString& string)
    349 {
    350     const CR_DEFINE_STATIC_LOCAL(WebString, kPrimitiveNone, ("none"));
    351     const CR_DEFINE_STATIC_LOCAL(WebString, kPrimitiveTriangle, ("triangle"));
    352 
    353     Primitive primitive = PrimitiveNone;
    354     if (string == kPrimitiveNone)
    355         primitive = PrimitiveNone;
    356     else if (string == kPrimitiveTriangle)
    357         primitive = PrimitiveTriangle;
    358     else
    359         NOTREACHED();
    360     return primitive;
    361 }
    362 
    363 // FIXME: This method should already exist. Use it.
    364 // For now just parse primary colors.
    365 void TestPlugin::parseColor(const WebString& string, unsigned color[3])
    366 {
    367     color[0] = color[1] = color[2] = 0;
    368     if (string == "black")
    369         return;
    370 
    371     if (string == "red")
    372         color[0] = 255;
    373     else if (string == "green")
    374         color[1] = 255;
    375     else if (string == "blue")
    376         color[2] = 255;
    377     else
    378         NOTREACHED();
    379 }
    380 
    381 float TestPlugin::parseOpacity(const WebString& string)
    382 {
    383     return static_cast<float>(atof(string.utf8().data()));
    384 }
    385 
    386 bool TestPlugin::parseBoolean(const WebString& string)
    387 {
    388     const CR_DEFINE_STATIC_LOCAL(WebString, kPrimitiveTrue, ("true"));
    389     return string == kPrimitiveTrue;
    390 }
    391 
    392 bool TestPlugin::initScene()
    393 {
    394     if (!m_context)
    395         return true;
    396 
    397     float color[4];
    398     premultiplyAlpha(m_scene.backgroundColor, m_scene.opacity, color);
    399 
    400     m_colorTexture = m_context->createTexture();
    401     m_framebuffer = m_context->createFramebuffer();
    402 
    403     m_context->viewport(0, 0, m_rect.width, m_rect.height);
    404     m_context->disable(GL_DEPTH_TEST);
    405     m_context->disable(GL_SCISSOR_TEST);
    406 
    407     m_context->clearColor(color[0], color[1], color[2], color[3]);
    408 
    409     m_context->enable(GL_BLEND);
    410     m_context->blendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
    411 
    412     return m_scene.primitive != PrimitiveNone ? initProgram() && initPrimitive() : true;
    413 }
    414 
    415 void TestPlugin::drawSceneGL() {
    416     m_context->viewport(0, 0, m_rect.width, m_rect.height);
    417     m_context->clear(GL_COLOR_BUFFER_BIT);
    418 
    419     if (m_scene.primitive != PrimitiveNone)
    420         drawPrimitive();
    421 }
    422 
    423 void TestPlugin::drawSceneSoftware(void* memory, size_t bytes) {
    424     DCHECK_EQ(bytes, m_rect.width * m_rect.height * 4u);
    425 
    426     SkColor backgroundColor =
    427             SkColorSetARGB(static_cast<uint8>(m_scene.opacity * 255),
    428                            m_scene.backgroundColor[0],
    429                            m_scene.backgroundColor[1],
    430                            m_scene.backgroundColor[2]);
    431 
    432     SkBitmap bitmap;
    433     bitmap.setConfig(SkBitmap::kARGB_8888_Config, m_rect.width, m_rect.height);
    434     bitmap.setPixels(memory);
    435     SkCanvas canvas(bitmap);
    436     canvas.clear(backgroundColor);
    437 
    438     if (m_scene.primitive != PrimitiveNone) {
    439         DCHECK_EQ(PrimitiveTriangle, m_scene.primitive);
    440         SkColor foregroundColor =
    441                 SkColorSetARGB(static_cast<uint8>(m_scene.opacity * 255),
    442                                m_scene.primitiveColor[0],
    443                                m_scene.primitiveColor[1],
    444                                m_scene.primitiveColor[2]);
    445         SkPath trianglePath;
    446         trianglePath.moveTo(0.5f * m_rect.width, 0.9f * m_rect.height);
    447         trianglePath.lineTo(0.1f * m_rect.width, 0.1f * m_rect.height);
    448         trianglePath.lineTo(0.9f * m_rect.width, 0.1f * m_rect.height);
    449         SkPaint paint;
    450         paint.setColor(foregroundColor);
    451         paint.setStyle(SkPaint::kFill_Style);
    452         canvas.drawPath(trianglePath, paint);
    453     }
    454 }
    455 
    456 void TestPlugin::destroyScene()
    457 {
    458     if (m_scene.program) {
    459         m_context->deleteProgram(m_scene.program);
    460         m_scene.program = 0;
    461     }
    462     if (m_scene.vbo) {
    463         m_context->deleteBuffer(m_scene.vbo);
    464         m_scene.vbo = 0;
    465     }
    466 
    467     if (m_framebuffer) {
    468         m_context->deleteFramebuffer(m_framebuffer);
    469         m_framebuffer = 0;
    470     }
    471 
    472     if (m_colorTexture) {
    473         m_context->deleteTexture(m_colorTexture);
    474         m_colorTexture = 0;
    475     }
    476 }
    477 
    478 bool TestPlugin::initProgram()
    479 {
    480     const string vertexSource(
    481         "attribute vec4 position;  \n"
    482         "void main() {             \n"
    483         "  gl_Position = position; \n"
    484         "}                         \n"
    485     );
    486 
    487     const string fragmentSource(
    488         "precision mediump float; \n"
    489         "uniform vec4 color;      \n"
    490         "void main() {            \n"
    491         "  gl_FragColor = color;  \n"
    492         "}                        \n"
    493     );
    494 
    495     m_scene.program = loadProgram(vertexSource, fragmentSource);
    496     if (!m_scene.program)
    497         return false;
    498 
    499     m_scene.colorLocation = m_context->getUniformLocation(m_scene.program, "color");
    500     m_scene.positionLocation = m_context->getAttribLocation(m_scene.program, "position");
    501     return true;
    502 }
    503 
    504 bool TestPlugin::initPrimitive()
    505 {
    506     DCHECK_EQ(m_scene.primitive, PrimitiveTriangle);
    507 
    508     m_scene.vbo = m_context->createBuffer();
    509     if (!m_scene.vbo)
    510         return false;
    511 
    512     const float vertices[] = {
    513         0.0f,  0.8f, 0.0f,
    514         -0.8f, -0.8f, 0.0f,
    515         0.8f, -0.8f, 0.0f };
    516     m_context->bindBuffer(GL_ARRAY_BUFFER, m_scene.vbo);
    517     m_context->bufferData(GL_ARRAY_BUFFER, sizeof(vertices), 0, GL_STATIC_DRAW);
    518     m_context->bufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices);
    519     return true;
    520 }
    521 
    522 void TestPlugin::drawPrimitive()
    523 {
    524     DCHECK_EQ(m_scene.primitive, PrimitiveTriangle);
    525     DCHECK(m_scene.vbo);
    526     DCHECK(m_scene.program);
    527 
    528     m_context->useProgram(m_scene.program);
    529 
    530     // Bind primitive color.
    531     float color[4];
    532     premultiplyAlpha(m_scene.primitiveColor, m_scene.opacity, color);
    533     m_context->uniform4f(m_scene.colorLocation, color[0], color[1], color[2], color[3]);
    534 
    535     // Bind primitive vertices.
    536     m_context->bindBuffer(GL_ARRAY_BUFFER, m_scene.vbo);
    537     m_context->enableVertexAttribArray(m_scene.positionLocation);
    538     m_context->vertexAttribPointer(m_scene.positionLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
    539     m_context->drawArrays(GL_TRIANGLES, 0, 3);
    540 }
    541 
    542 unsigned TestPlugin::loadShader(unsigned type, const string& source)
    543 {
    544     unsigned shader = m_context->createShader(type);
    545     if (shader) {
    546         m_context->shaderSource(shader, source.data());
    547         m_context->compileShader(shader);
    548 
    549         int compiled = 0;
    550         m_context->getShaderiv(shader, GL_COMPILE_STATUS, &compiled);
    551         if (!compiled) {
    552             m_context->deleteShader(shader);
    553             shader = 0;
    554         }
    555     }
    556     return shader;
    557 }
    558 
    559 unsigned TestPlugin::loadProgram(const string& vertexSource, const string& fragmentSource)
    560 {
    561     unsigned vertexShader = loadShader(GL_VERTEX_SHADER, vertexSource);
    562     unsigned fragmentShader = loadShader(GL_FRAGMENT_SHADER, fragmentSource);
    563     unsigned program = m_context->createProgram();
    564     if (vertexShader && fragmentShader && program) {
    565         m_context->attachShader(program, vertexShader);
    566         m_context->attachShader(program, fragmentShader);
    567         m_context->linkProgram(program);
    568 
    569         int linked = 0;
    570         m_context->getProgramiv(program, GL_LINK_STATUS, &linked);
    571         if (!linked) {
    572             m_context->deleteProgram(program);
    573             program = 0;
    574         }
    575     }
    576     if (vertexShader)
    577         m_context->deleteShader(vertexShader);
    578     if (fragmentShader)
    579         m_context->deleteShader(fragmentShader);
    580 
    581     return program;
    582 }
    583 
    584 bool TestPlugin::handleInputEvent(const WebInputEvent& event, WebCursorInfo& info)
    585 {
    586     const char* eventName = 0;
    587     switch (event.type) {
    588     case WebInputEvent::Undefined:           eventName = "unknown"; break;
    589 
    590     case WebInputEvent::MouseDown:           eventName = "MouseDown"; break;
    591     case WebInputEvent::MouseUp:             eventName = "MouseUp"; break;
    592     case WebInputEvent::MouseMove:           eventName = "MouseMove"; break;
    593     case WebInputEvent::MouseEnter:          eventName = "MouseEnter"; break;
    594     case WebInputEvent::MouseLeave:          eventName = "MouseLeave"; break;
    595     case WebInputEvent::ContextMenu:         eventName = "ContextMenu"; break;
    596 
    597     case WebInputEvent::MouseWheel:          eventName = "MouseWheel"; break;
    598 
    599     case WebInputEvent::RawKeyDown:          eventName = "RawKeyDown"; break;
    600     case WebInputEvent::KeyDown:             eventName = "KeyDown"; break;
    601     case WebInputEvent::KeyUp:               eventName = "KeyUp"; break;
    602     case WebInputEvent::Char:                eventName = "Char"; break;
    603 
    604     case WebInputEvent::GestureScrollBegin:  eventName = "GestureScrollBegin"; break;
    605     case WebInputEvent::GestureScrollEnd:    eventName = "GestureScrollEnd"; break;
    606     case WebInputEvent::GestureScrollUpdateWithoutPropagation:
    607     case WebInputEvent::GestureScrollUpdate: eventName = "GestureScrollUpdate"; break;
    608     case WebInputEvent::GestureFlingStart:   eventName = "GestureFlingStart"; break;
    609     case WebInputEvent::GestureFlingCancel:  eventName = "GestureFlingCancel"; break;
    610     case WebInputEvent::GestureTap:          eventName = "GestureTap"; break;
    611     case WebInputEvent::GestureTapUnconfirmed:
    612                                              eventName = "GestureTapUnconfirmed"; break;
    613     case WebInputEvent::GestureTapDown:      eventName = "GestureTapDown"; break;
    614     case WebInputEvent::GestureShowPress:    eventName = "GestureShowPress"; break;
    615     case WebInputEvent::GestureTapCancel:    eventName = "GestureTapCancel"; break;
    616     case WebInputEvent::GestureDoubleTap:    eventName = "GestureDoubleTap"; break;
    617     case WebInputEvent::GestureTwoFingerTap: eventName = "GestureTwoFingerTap"; break;
    618     case WebInputEvent::GestureLongPress:    eventName = "GestureLongPress"; break;
    619     case WebInputEvent::GestureLongTap:      eventName = "GestureLongTap"; break;
    620     case WebInputEvent::GesturePinchBegin:   eventName = "GesturePinchBegin"; break;
    621     case WebInputEvent::GesturePinchEnd:     eventName = "GesturePinchEnd"; break;
    622     case WebInputEvent::GesturePinchUpdate:  eventName = "GesturePinchUpdate"; break;
    623 
    624     case WebInputEvent::TouchStart:          eventName = "TouchStart"; break;
    625     case WebInputEvent::TouchMove:           eventName = "TouchMove"; break;
    626     case WebInputEvent::TouchEnd:            eventName = "TouchEnd"; break;
    627     case WebInputEvent::TouchCancel:         eventName = "TouchCancel"; break;
    628     }
    629 
    630     m_delegate->printMessage(std::string("Plugin received event: ") + (eventName ? eventName : "unknown") + "\n");
    631     if (m_printEventDetails)
    632         printEventDetails(m_delegate, event);
    633     if (m_printUserGestureStatus)
    634         m_delegate->printMessage(std::string("* ") + (WebUserGestureIndicator::isProcessingUserGesture() ? "" : "not ") + "handling user gesture\n");
    635     if (m_isPersistent)
    636         m_delegate->printMessage(std::string("TestPlugin: isPersistent\n"));
    637     return false;
    638 }
    639 
    640 bool TestPlugin::handleDragStatusUpdate(WebDragStatus dragStatus, const WebDragData&, WebDragOperationsMask, const WebPoint& position, const WebPoint& screenPosition)
    641 {
    642     const char* dragStatusName = 0;
    643     switch (dragStatus) {
    644     case WebDragStatusEnter:
    645         dragStatusName = "DragEnter";
    646         break;
    647     case WebDragStatusOver:
    648         dragStatusName = "DragOver";
    649         break;
    650     case WebDragStatusLeave:
    651         dragStatusName = "DragLeave";
    652         break;
    653     case WebDragStatusDrop:
    654         dragStatusName = "DragDrop";
    655         break;
    656     case WebDragStatusUnknown:
    657         NOTREACHED();
    658     }
    659     m_delegate->printMessage(std::string("Plugin received event: ") + dragStatusName + "\n");
    660     return false;
    661 }
    662 
    663 TestPlugin* TestPlugin::create(WebFrame* frame, const WebPluginParams& params, WebTestDelegate* delegate)
    664 {
    665     return new TestPlugin(frame, params, delegate);
    666 }
    667 
    668 const WebString& TestPlugin::mimeType()
    669 {
    670     const CR_DEFINE_STATIC_LOCAL(WebString, kMimeType, ("application/x-webkit-test-webplugin"));
    671     return kMimeType;
    672 }
    673 
    674 const WebString& TestPlugin::canCreateWithoutRendererMimeType()
    675 {
    676     const CR_DEFINE_STATIC_LOCAL(WebString, kCanCreateWithoutRendererMimeType, ("application/x-webkit-test-webplugin-can-create-without-renderer"));
    677     return kCanCreateWithoutRendererMimeType;
    678 }
    679 
    680 const WebString& TestPlugin::pluginPersistsMimeType()
    681 {
    682     const CR_DEFINE_STATIC_LOCAL(WebString, kPluginPersistsMimeType, ("application/x-webkit-test-webplugin-persistent"));
    683     return kPluginPersistsMimeType;
    684 }
    685 
    686 bool TestPlugin::isSupportedMimeType(const WebString& mimeType)
    687 {
    688     return mimeType == TestPlugin::mimeType()
    689            || mimeType == pluginPersistsMimeType()
    690            || mimeType == canCreateWithoutRendererMimeType();
    691 }
    692 
    693 }  // namespace content
    694