BrowserPlugin/WebView - Move plugin lifetime to DOM

Source/testing/runner/TestPlugin.cpp

 /*
  * 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
@@ skipping 12 matching lines @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "TestPlugin.h"
 
 #include "TestCommon.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebGraphicsContext3D.h"
 #include "public/testing/WebTestDelegate.h"
+#include "public/web/WebBindings.h"
 #include "public/web/WebFrame.h"
 #include "public/web/WebInputEvent.h"
 #include "public/web/WebKit.h"
 #include "public/web/WebPluginParams.h"
 #include "public/web/WebTouchPoint.h"
 #include "public/web/WebUserGestureIndicator.h"
 
 using namespace blink;
 using namespace std;
 
@@ skipping 97 matching lines @@
 }
 
 void deferredDelete(void* context)
 {
     TestPlugin* plugin = static_cast<TestPlugin*>(context);
     delete plugin;
 }
 
 }
 
+static int s_instanceCount = 0;
 
 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)
+    , m_npObject(0)
+    , m_instanceId(++s_instanceCount)
+    , m_isPersistent(params.mimeType.utf8().find(pluginPersistsSuffix().utf8()) != std::string::npos)
+    , m_canCreateWithoutRenderer(params.mimeType.utf8().find(canCreateWithoutRendererSuffix().utf8()) != std::string::npos)
 {
     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");
@@ skipping 44 matching lines @@
 
     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);
+    m_container->allowScriptObjects();
     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);
 }
 
+class TestPluginNPObject : public NPObject {
+public:
+    TestPluginNPObject(TestPlugin* plugin): m_plugin(plugin) { }
+    ~TestPluginNPObject() { }
+
+    // This is a raw pointer; we assume this object doesn't outlive the associated
+    // plugin object.
+    TestPlugin* m_plugin;
+};
+
+NPObject* TestPluginBindingsAllocate(NPP npp, NPClass* nppClass)
+{
+    return new TestPluginNPObject(static_cast<TestPlugin*>(npp->pdata));
+}
+
+WebString NPIdentifierToString(const NPIdentifier& npIdentifier)
+{
+    NPUTF8* nputF8 = blink::WebBindings::utf8FromIdentifier(npIdentifier);
+    WebString identifier = WebString::fromUTF8(nputF8);
+    free(nputF8);
+    return identifier;
+}
+
+static const WebString kPropertyInstanceId = WebString::fromUTF8("instanceId");
+static const WebString kPropertyIsPersistent = WebString::fromUTF8("isPersistent");
+static const WebString kPropertyCanCreateWithoutRenderer = WebString::fromUTF8("canCreateWithoutRenderer");
+
+bool TestPluginBindingsHasProperty(NPObject* npObject, NPIdentifier name)
+{
+    WebString nameString = NPIdentifierToString(name);
+    return nameString == kPropertyInstanceId || nameString == kPropertyIsPersistent || nameString == kPropertyCanCreateWithoutRenderer;

[wjmaclean, 2013/12/12 20:30:46]

Sorry about the length of this line, but presubmit wouldn't let me line it up on
multiple lines in any manner that seemed reasonable.

+}
+
+bool TestPluginBindingsGetProperty(NPObject* npObject, NPIdentifier name, NPVariant* result)
+{
+    if (!npObject)
+        return false;
+
+    WebString nameString = NPIdentifierToString(name);
+    if (nameString == kPropertyInstanceId)
+        INT32_TO_NPVARIANT(static_cast<TestPluginNPObject*>(npObject)->m_plugin->instanceId(), *result);
+
+    if (nameString == kPropertyIsPersistent)
+        BOOLEAN_TO_NPVARIANT(static_cast<TestPluginNPObject*>(npObject)->m_plugin->isPersistent(), *result);
+
+    if (nameString == kPropertyCanCreateWithoutRenderer)
+        BOOLEAN_TO_NPVARIANT(static_cast<TestPluginNPObject*>(npObject)->m_plugin->canCreateWithoutRenderer(), *result);
+
+    return true;
+}
+
+bool TestPluginBindingsSetProperty(NPObject* npObject, NPIdentifier, const NPVariant*result)
+{
+    // For now, all properties are read-only.
+    return false;
+}
+
+NPClass testPluginClass = {
+    NP_CLASS_STRUCT_VERSION,
+    &TestPluginBindingsAllocate,
+    0,
+    0,
+    0,
+    0,
+    0,
+    &TestPluginBindingsHasProperty,
+    &TestPluginBindingsGetProperty,
+    &TestPluginBindingsSetProperty,
+    0,
+    0,
+};
+
+NPObject* TestPlugin::scriptableObject()
+{
+    if (!m_npObject) {
+        m_NPP.reset(new NPP_t);
+        m_NPP->pdata = this;
+        m_NPP->ndata = 0;
+        m_npObject = blink::WebBindings::createObject(m_NPP.get(), &testPluginClass);
+        blink::WebBindings::retainObject(m_npObject);
+    }
+    return m_npObject;
+}
+
 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);
@@ skipping 312 matching lines @@
 {
     return new TestPlugin(frame, params, delegate);
 }
 
 const WebString& TestPlugin::mimeType()
 {
     static const WebString kMimeType = WebString::fromUTF8("application/x-webkit-test-webplugin");
     return kMimeType;
 }
 
+const WebString& TestPlugin::canCreateWithoutRendererSuffix()
+{
+    static const WebString kCanCreateWithoutRendererSuffix =  WebString::fromUTF8("-can-create-without-renderer");
+    return kCanCreateWithoutRendererSuffix;
 }
+
+const WebString& TestPlugin::pluginPersistsSuffix()
+{
+    static const WebString kPluginPersistsSuffix = WebString::fromUTF8("-persistent");
+    return kPluginPersistsSuffix;
+}
+
+}