File webkit2gtk3-restore-npapi.patch of Package webkit2gtk3.25852
diff -urpN webkitgtk-2.36.7.orig/Source/cmake/OptionsGTK.cmake webkitgtk-2.36.7/Source/cmake/OptionsGTK.cmake
--- webkitgtk-2.36.7.orig/Source/cmake/OptionsGTK.cmake 2022-08-24 14:11:17.691218400 -0500
+++ webkitgtk-2.36.7/Source/cmake/OptionsGTK.cmake 2022-08-26 14:18:14.941022124 -0500
@@ -158,7 +158,6 @@ WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_
WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_MEDIA_STREAM PRIVATE ${ENABLE_EXPERIMENTAL_FEATURES})
WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_MHTML PRIVATE ON)
WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_MOUSE_CURSOR_SCALE PRIVATE ON)
-WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_NETSCAPE_PLUGIN_API PRIVATE OFF)
WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_NETWORK_CACHE_SPECULATIVE_REVALIDATION PRIVATE ON)
WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_NETWORK_CACHE_STALE_WHILE_REVALIDATE PRIVATE ON)
WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_OFFSCREEN_CANVAS PRIVATE ${ENABLE_EXPERIMENTAL_FEATURES})
@@ -171,6 +170,10 @@ WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_
WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_WEB_API_STATISTICS PRIVATE ON)
WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_WEB_RTC PRIVATE ${ENABLE_EXPERIMENTAL_FEATURES})
+if (USE_GTK4)
+WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_NETSCAPE_PLUGIN_API PRIVATE OFF)
+endif ()
+
include(GStreamerDependencies)
# Finalize the value for all options. Do not attempt to use an option before
@@ -257,7 +260,16 @@ SET_AND_EXPOSE_TO_BUILD(WTF_PLATFORM_QUA
SET_AND_EXPOSE_TO_BUILD(WTF_PLATFORM_X11 ${ENABLE_X11_TARGET})
SET_AND_EXPOSE_TO_BUILD(WTF_PLATFORM_WAYLAND ${ENABLE_WAYLAND_TARGET})
-SET_AND_EXPOSE_TO_BUILD(ENABLE_PLUGIN_PROCESS FALSE)
+if (ENABLE_NETSCAPE_PLUGIN_API)
+ # MOZ_X11 and XP_UNIX are required by npapi.h. Their value is not checked;
+ # only their definedness is. They should only be defined in the true case.
+ if (ENABLE_X11_TARGET)
+ SET_AND_EXPOSE_TO_BUILD(MOZ_X11 1)
+ endif ()
+ SET_AND_EXPOSE_TO_BUILD(XP_UNIX 1)
+endif ()
+
+SET_AND_EXPOSE_TO_BUILD(ENABLE_PLUGIN_PROCESS ${ENABLE_NETSCAPE_PLUGIN_API})
add_definitions(-DBUILDING_GTK__=1)
add_definitions(-DGETTEXT_PACKAGE="WebKit2GTK-${WEBKITGTK_API_VERSION}")
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/bindings/js/ScriptController.cpp webkitgtk-2.36.7/Source/WebCore/bindings/js/ScriptController.cpp
--- webkitgtk-2.36.7.orig/Source/WebCore/bindings/js/ScriptController.cpp 2022-08-22 08:32:04.540418000 -0500
+++ webkitgtk-2.36.7/Source/WebCore/bindings/js/ScriptController.cpp 2022-08-26 14:18:14.941022124 -0500
@@ -43,6 +43,7 @@
#include "Logging.h"
#include "ModuleFetchFailureKind.h"
#include "ModuleFetchParameters.h"
+#include "NP_jsobject.h"
#include "Page.h"
#include "PageConsoleClient.h"
#include "PageGroup.h"
@@ -58,6 +59,7 @@
#include "UserGestureIndicator.h"
#include "WebCoreJITOperations.h"
#include "WebCoreJSClientData.h"
+#include "npruntime_impl.h"
#include "runtime_root.h"
#include <JavaScriptCore/Debugger.h>
#include <JavaScriptCore/Heap.h>
@@ -95,6 +97,9 @@ ScriptController::ScriptController(Frame
: m_frame(frame)
, m_sourceURL(0)
, m_paused(false)
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ , m_windowScriptNPObject(0)
+#endif
#if PLATFORM(COCOA)
, m_windowScriptObject(0)
#endif
@@ -491,6 +496,29 @@ void ScriptController::collectIsolatedCo
}
}
+#if ENABLE(NETSCAPE_PLUGIN_API)
+NPObject* ScriptController::windowScriptNPObject()
+{
+ if (!m_windowScriptNPObject) {
+ JSLockHolder lock(commonVM());
+ if (canExecuteScripts(NotAboutToExecuteScript)) {
+ // JavaScript is enabled, so there is a JavaScript window object.
+ // Return an NPObject bound to the window object.
+ auto* window = jsWindowProxy(pluginWorld()).window();
+ ASSERT(window);
+ Bindings::RootObject* root = bindingRootObject();
+ m_windowScriptNPObject = _NPN_CreateScriptObject(0, window, root);
+ } else {
+ // JavaScript is not enabled, so we cannot bind the NPObject to the JavaScript window object.
+ // Instead, we create an NPObject of a different class, one which is not bound to a JavaScript object.
+ m_windowScriptNPObject = _NPN_CreateNoScriptObject();
+ }
+ }
+
+ return m_windowScriptNPObject;
+}
+#endif
+
#if !PLATFORM(COCOA)
RefPtr<JSC::Bindings::Instance> ScriptController::createScriptInstanceForWidget(Widget* widget)
{
@@ -554,6 +582,16 @@ void ScriptController::clearScriptObject
m_bindingRootObject->invalidate();
m_bindingRootObject = nullptr;
}
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ if (m_windowScriptNPObject) {
+ // Call _NPN_DeallocateObject() instead of _NPN_ReleaseObject() so that we don't leak if a plugin fails to release the window
+ // script object properly.
+ // This shouldn't cause any problems for plugins since they should have already been stopped and destroyed at this point.
+ _NPN_DeallocateObject(m_windowScriptNPObject);
+ m_windowScriptNPObject = nullptr;
+ }
+#endif
}
JSC::JSValue ScriptController::executeScriptIgnoringException(const String& script, bool forceUserGesture)
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/bindings/js/ScriptController.h webkitgtk-2.36.7/Source/WebCore/bindings/js/ScriptController.h
--- webkitgtk-2.36.7.orig/Source/WebCore/bindings/js/ScriptController.h 2022-06-30 04:49:31.546183300 -0500
+++ webkitgtk-2.36.7/Source/WebCore/bindings/js/ScriptController.h 2022-08-26 14:18:14.941022124 -0500
@@ -39,6 +39,8 @@ OBJC_CLASS JSContext;
OBJC_CLASS WebScriptObject;
#endif
+struct NPObject;
+
namespace JSC {
class CallFrame;
class JSGlobalObject;
@@ -162,6 +164,10 @@ public:
#endif
WEBCORE_EXPORT JSC::JSObject* jsObjectForPluginElement(HTMLPlugInElement*);
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ WEBCORE_EXPORT NPObject* windowScriptNPObject();
+#endif
void initScriptForWindowProxy(JSWindowProxy&);
@@ -194,6 +200,9 @@ private:
// This ensures they are still available when the page is restored.
RefPtr<JSC::Bindings::RootObject> m_cacheableBindingRootObject;
RootObjectMap m_rootObjects;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ NPObject* m_windowScriptNPObject;
+#endif
#if PLATFORM(COCOA)
RetainPtr<WebScriptObject> m_windowScriptObject;
#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/c_class.cpp webkitgtk-2.36.7/Source/WebCore/bridge/c/c_class.cpp
--- webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/c_class.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/bridge/c/c_class.cpp 2022-08-26 14:18:14.945022144 -0500
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2003, 2006 Apple 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 INC. ``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 INC. OR
+ * 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 "config.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "c_class.h"
+
+#include "c_instance.h"
+#include "c_runtime.h"
+#include "npruntime_impl.h"
+#include <JavaScriptCore/Identifier.h>
+#include <JavaScriptCore/JSCJSValueInlines.h>
+#include <JavaScriptCore/JSGlobalObject.h>
+#include <JavaScriptCore/JSObject.h>
+#include <wtf/text/StringHash.h>
+
+namespace JSC { namespace Bindings {
+
+CClass::CClass(NPClass* aClass)
+{
+ m_isa = aClass;
+}
+
+CClass::~CClass()
+{
+ m_methods.clear();
+ m_fields.clear();
+}
+
+typedef HashMap<NPClass*, CClass*> ClassesByIsAMap;
+static ClassesByIsAMap* classesByIsA = 0;
+
+CClass* CClass::classForIsA(NPClass* isa)
+{
+ if (!classesByIsA)
+ classesByIsA = new ClassesByIsAMap;
+
+ CClass* aClass = classesByIsA->get(isa);
+ if (!aClass) {
+ aClass = new CClass(isa);
+ classesByIsA->set(isa, aClass);
+ }
+
+ return aClass;
+}
+
+Method* CClass::methodNamed(PropertyName propertyName, Instance* instance) const
+{
+ String name(propertyName.publicName());
+ if (name.isNull())
+ return nullptr;
+
+ if (Method* method = m_methods.get(name.impl()))
+ return method;
+
+ NPIdentifier ident = _NPN_GetStringIdentifier(name.ascii().data());
+ const CInstance* inst = static_cast<const CInstance*>(instance);
+ NPObject* obj = inst->getObject();
+ if (m_isa->hasMethod && m_isa->hasMethod(obj, ident)) {
+ auto method = makeUnique<CMethod>(ident);
+ CMethod* ret = method.get();
+ m_methods.set(name.impl(), WTFMove(method));
+ return ret;
+ }
+
+ return nullptr;
+}
+
+Field* CClass::fieldNamed(PropertyName propertyName, Instance* instance) const
+{
+ String name(propertyName.publicName());
+ if (name.isNull())
+ return nullptr;
+
+ if (Field* field = m_fields.get(name.impl()))
+ return field;
+
+ NPIdentifier ident = _NPN_GetStringIdentifier(name.ascii().data());
+ const CInstance* inst = static_cast<const CInstance*>(instance);
+ NPObject* obj = inst->getObject();
+ if (m_isa->hasProperty && m_isa->hasProperty(obj, ident)) {
+ auto field = makeUnique<CField>(ident);
+ CField* ret = field.get();
+ m_fields.set(name.impl(), WTFMove(field));
+ return ret;
+ }
+
+ return nullptr;
+}
+
+} } // namespace JSC::Bindings
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/c_class.h webkitgtk-2.36.7/Source/WebCore/bridge/c/c_class.h
--- webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/c_class.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/bridge/c/c_class.h 2022-08-26 14:18:14.945022144 -0500
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2003 Apple 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 INC. ``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 INC. OR
+ * 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.
+ */
+
+#ifndef BINDINGS_C_CLASS_H_
+#define BINDINGS_C_CLASS_H_
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "BridgeJSC.h"
+#include "npruntime_internal.h"
+#include <wtf/HashMap.h>
+
+namespace JSC {
+namespace Bindings {
+
+class CClass : public Class {
+protected:
+ CClass(NPClass*); // Use classForIsA to create a CClass.
+
+public:
+ static CClass* classForIsA(NPClass*);
+ virtual ~CClass();
+
+ Method* methodNamed(PropertyName, Instance*) const override;
+ Field* fieldNamed(PropertyName, Instance*) const override;
+
+private:
+ NPClass* m_isa;
+ mutable HashMap<RefPtr<StringImpl>, std::unique_ptr<Method>> m_methods;
+ mutable HashMap<RefPtr<StringImpl>, std::unique_ptr<Field>> m_fields;
+};
+
+} // namespace Bindings
+} // namespace JSC
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/c_instance.cpp webkitgtk-2.36.7/Source/WebCore/bridge/c/c_instance.cpp
--- webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/c_instance.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/bridge/c/c_instance.cpp 2022-08-26 14:18:14.945022144 -0500
@@ -0,0 +1,385 @@
+/*
+ * Copyright (C) 2003-2019 Apple 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 INC. ``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 INC. OR
+ * 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 "config.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "c_instance.h"
+
+#include "CRuntimeObject.h"
+#include "IdentifierRep.h"
+#include "JSDOMBinding.h"
+#include "c_class.h"
+#include "c_runtime.h"
+#include "c_utility.h"
+#include "npruntime_impl.h"
+#include "runtime_method.h"
+#include "runtime_root.h"
+#include <JavaScriptCore/ArgList.h>
+#include <JavaScriptCore/CallFrame.h>
+#include <JavaScriptCore/Error.h>
+#include <JavaScriptCore/FunctionPrototype.h>
+#include <JavaScriptCore/JSLock.h>
+#include <JavaScriptCore/PropertyNameArray.h>
+#include <wtf/Assertions.h>
+#include <wtf/NeverDestroyed.h>
+#include <wtf/StdLibExtras.h>
+#include <wtf/Vector.h>
+
+using namespace WebCore;
+
+namespace JSC {
+namespace Bindings {
+
+static String& globalExceptionString()
+{
+ static NeverDestroyed<String> exceptionStr;
+ return exceptionStr;
+}
+
+void CInstance::setGlobalException(String exception)
+{
+ globalExceptionString() = exception;
+}
+
+void CInstance::moveGlobalExceptionToExecState(JSGlobalObject* lexicalGlobalObject)
+{
+ if (globalExceptionString().isNull())
+ return;
+
+ {
+ VM& vm = lexicalGlobalObject->vm();
+ JSLockHolder lock(vm);
+ auto scope = DECLARE_THROW_SCOPE(vm);
+ throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, globalExceptionString()));
+ }
+
+ globalExceptionString() = String();
+}
+
+CInstance::CInstance(NPObject* o, RefPtr<RootObject>&& rootObject)
+ : Instance(WTFMove(rootObject))
+{
+ _object = _NPN_RetainObject(o);
+ _class = 0;
+}
+
+CInstance::~CInstance()
+{
+ _NPN_ReleaseObject(_object);
+}
+
+RuntimeObject* CInstance::newRuntimeObject(JSGlobalObject* lexicalGlobalObject)
+{
+ // FIXME: deprecatedGetDOMStructure uses the prototype off of the wrong global object.
+ return CRuntimeObject::create(lexicalGlobalObject->vm(), WebCore::deprecatedGetDOMStructure<CRuntimeObject>(lexicalGlobalObject), this);
+}
+
+Class *CInstance::getClass() const
+{
+ if (!_class)
+ _class = CClass::classForIsA(_object->_class);
+ return _class;
+}
+
+bool CInstance::supportsInvokeDefaultMethod() const
+{
+ return _object->_class->invokeDefault;
+}
+
+class CRuntimeMethod final : public RuntimeMethod {
+public:
+ using Base = RuntimeMethod;
+
+ static CRuntimeMethod* create(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject, const String& name, Bindings::Method* method)
+ {
+ VM& vm = globalObject->vm();
+ // FIXME: deprecatedGetDOMStructure uses the prototype off of the wrong global object
+ // We need to pass in the right global object for "i".
+ Structure* domStructure = WebCore::deprecatedGetDOMStructure<CRuntimeMethod>(lexicalGlobalObject);
+ CRuntimeMethod* runtimeMethod = new (NotNull, allocateCell<CRuntimeMethod>(vm)) CRuntimeMethod(vm, domStructure, method);
+ runtimeMethod->finishCreation(vm, name);
+ return runtimeMethod;
+ }
+
+ static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
+ {
+ return Structure::create(vm, globalObject, prototype, TypeInfo(InternalFunctionType, StructureFlags), info());
+ }
+
+ DECLARE_INFO;
+
+private:
+ CRuntimeMethod(VM& vm, Structure* structure, Bindings::Method* method)
+ : RuntimeMethod(vm, structure, method)
+ {
+ }
+
+ void finishCreation(VM& vm, const String& name)
+ {
+ Base::finishCreation(vm, name);
+ ASSERT(inherits(vm, info()));
+ }
+};
+
+const ClassInfo CRuntimeMethod::s_info = { "CRuntimeMethod", &RuntimeMethod::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(CRuntimeMethod) };
+
+JSValue CInstance::getMethod(JSGlobalObject* lexicalGlobalObject, PropertyName propertyName)
+{
+ Method* method = getClass()->methodNamed(propertyName, this);
+ return CRuntimeMethod::create(lexicalGlobalObject, lexicalGlobalObject, propertyName.publicName(), method);
+}
+
+JSValue CInstance::invokeMethod(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame, RuntimeMethod* runtimeMethod)
+{
+ VM& vm = lexicalGlobalObject->vm();
+ auto scope = DECLARE_THROW_SCOPE(vm);
+
+ if (!asObject(runtimeMethod)->inherits<CRuntimeMethod>(vm))
+ return throwTypeError(lexicalGlobalObject, scope, "Attempt to invoke non-plug-in method on plug-in object."_s);
+
+ CMethod* method = static_cast<CMethod*>(runtimeMethod->method());
+ ASSERT(method);
+
+ NPIdentifier ident = method->identifier();
+ if (!_object->_class->hasMethod(_object, ident))
+ return jsUndefined();
+
+ unsigned count = callFrame->argumentCount();
+ Vector<NPVariant, 8> cArgs(count);
+
+ unsigned i;
+ for (i = 0; i < count; i++)
+ convertValueToNPVariant(lexicalGlobalObject, callFrame->uncheckedArgument(i), &cArgs[i]);
+
+ // Invoke the 'C' method.
+ bool retval = true;
+ NPVariant resultVariant;
+ VOID_TO_NPVARIANT(resultVariant);
+
+ {
+ JSLock::DropAllLocks dropAllLocks(lexicalGlobalObject);
+ ASSERT(globalExceptionString().isNull());
+ retval = _object->_class->invoke(_object, ident, cArgs.data(), count, &resultVariant);
+ moveGlobalExceptionToExecState(lexicalGlobalObject);
+ }
+
+ if (!retval)
+ throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Error calling method on NPObject."_s));
+
+ for (i = 0; i < count; i++)
+ _NPN_ReleaseVariantValue(&cArgs[i]);
+
+ JSValue resultValue = convertNPVariantToValue(lexicalGlobalObject, &resultVariant, m_rootObject.get());
+ _NPN_ReleaseVariantValue(&resultVariant);
+ return resultValue;
+}
+
+
+JSValue CInstance::invokeDefaultMethod(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
+{
+ VM& vm = lexicalGlobalObject->vm();
+ auto scope = DECLARE_THROW_SCOPE(vm);
+
+ if (!_object->_class->invokeDefault)
+ return jsUndefined();
+
+ unsigned count = callFrame->argumentCount();
+ Vector<NPVariant, 8> cArgs(count);
+
+ unsigned i;
+ for (i = 0; i < count; i++)
+ convertValueToNPVariant(lexicalGlobalObject, callFrame->uncheckedArgument(i), &cArgs[i]);
+
+ // Invoke the 'C' method.
+ bool retval = true;
+ NPVariant resultVariant;
+ VOID_TO_NPVARIANT(resultVariant);
+ {
+ JSLock::DropAllLocks dropAllLocks(lexicalGlobalObject);
+ ASSERT(globalExceptionString().isNull());
+ retval = _object->_class->invokeDefault(_object, cArgs.data(), count, &resultVariant);
+ moveGlobalExceptionToExecState(lexicalGlobalObject);
+ }
+
+ if (!retval)
+ throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Error calling method on NPObject."_s));
+
+ for (i = 0; i < count; i++)
+ _NPN_ReleaseVariantValue(&cArgs[i]);
+
+ JSValue resultValue = convertNPVariantToValue(lexicalGlobalObject, &resultVariant, m_rootObject.get());
+ _NPN_ReleaseVariantValue(&resultVariant);
+ return resultValue;
+}
+
+bool CInstance::supportsConstruct() const
+{
+ return _object->_class->construct;
+}
+
+JSValue CInstance::invokeConstruct(JSGlobalObject* lexicalGlobalObject, CallFrame*, const ArgList& args)
+{
+ VM& vm = lexicalGlobalObject->vm();
+ auto scope = DECLARE_THROW_SCOPE(vm);
+
+ if (!_object->_class->construct)
+ return jsUndefined();
+
+ unsigned count = args.size();
+ Vector<NPVariant, 8> cArgs(count);
+
+ unsigned i;
+ for (i = 0; i < count; i++)
+ convertValueToNPVariant(lexicalGlobalObject, args.at(i), &cArgs[i]);
+
+ // Invoke the 'C' method.
+ bool retval = true;
+ NPVariant resultVariant;
+ VOID_TO_NPVARIANT(resultVariant);
+ {
+ JSLock::DropAllLocks dropAllLocks(lexicalGlobalObject);
+ ASSERT(globalExceptionString().isNull());
+ retval = _object->_class->construct(_object, cArgs.data(), count, &resultVariant);
+ moveGlobalExceptionToExecState(lexicalGlobalObject);
+ }
+
+ if (!retval)
+ throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Error calling method on NPObject."_s));
+
+ for (i = 0; i < count; i++)
+ _NPN_ReleaseVariantValue(&cArgs[i]);
+
+ JSValue resultValue = convertNPVariantToValue(lexicalGlobalObject, &resultVariant, m_rootObject.get());
+ _NPN_ReleaseVariantValue(&resultVariant);
+ return resultValue;
+}
+
+JSValue CInstance::defaultValue(JSGlobalObject* lexicalGlobalObject, PreferredPrimitiveType hint) const
+{
+ if (hint == PreferString)
+ return stringValue(lexicalGlobalObject);
+ if (hint == PreferNumber)
+ return numberValue(lexicalGlobalObject);
+ return valueOf(lexicalGlobalObject);
+}
+
+JSValue CInstance::stringValue(JSGlobalObject* lexicalGlobalObject) const
+{
+ JSValue value;
+ if (toJSPrimitive(lexicalGlobalObject, "toString", value))
+ return value;
+
+ // Fallback to default implementation.
+ return jsNontrivialString(lexicalGlobalObject->vm(), "NPObject"_s);
+}
+
+JSValue CInstance::numberValue(JSGlobalObject*) const
+{
+ // FIXME: Implement something sensible.
+ return jsNumber(0);
+}
+
+JSValue CInstance::booleanValue() const
+{
+ // As per ECMA 9.2.
+ return jsBoolean(getObject());
+}
+
+JSValue CInstance::valueOf(JSGlobalObject* lexicalGlobalObject) const
+{
+ JSValue value;
+ if (toJSPrimitive(lexicalGlobalObject, "valueOf", value))
+ return value;
+
+ // Fallback to default implementation.
+ return stringValue(lexicalGlobalObject);
+}
+
+bool CInstance::toJSPrimitive(JSGlobalObject* lexicalGlobalObject, const char* name, JSValue& resultValue) const
+{
+ VM& vm = lexicalGlobalObject->vm();
+ auto scope = DECLARE_THROW_SCOPE(vm);
+
+ NPIdentifier ident = _NPN_GetStringIdentifier(name);
+ if (!_object->_class->hasMethod(_object, ident))
+ return false;
+
+ // Invoke the 'C' method.
+ bool retval = true;
+ NPVariant resultVariant;
+ VOID_TO_NPVARIANT(resultVariant);
+
+ {
+ JSLock::DropAllLocks dropAllLocks(lexicalGlobalObject);
+ ASSERT(globalExceptionString().isNull());
+ retval = _object->_class->invoke(_object, ident, 0, 0, &resultVariant);
+ moveGlobalExceptionToExecState(lexicalGlobalObject);
+ }
+
+ if (!retval)
+ throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Error calling method on NPObject."_s));
+
+ resultValue = convertNPVariantToValue(lexicalGlobalObject, &resultVariant, m_rootObject.get());
+ _NPN_ReleaseVariantValue(&resultVariant);
+ return true;
+}
+
+void CInstance::getPropertyNames(JSGlobalObject* lexicalGlobalObject, PropertyNameArray& nameArray)
+{
+ if (!NP_CLASS_STRUCT_VERSION_HAS_ENUM(_object->_class) || !_object->_class->enumerate)
+ return;
+
+ uint32_t count;
+ NPIdentifier* identifiers;
+
+ {
+ JSLock::DropAllLocks dropAllLocks(lexicalGlobalObject);
+ ASSERT(globalExceptionString().isNull());
+ bool ok = _object->_class->enumerate(_object, &identifiers, &count);
+ moveGlobalExceptionToExecState(lexicalGlobalObject);
+ if (!ok)
+ return;
+ }
+
+ VM& vm = lexicalGlobalObject->vm();
+ for (uint32_t i = 0; i < count; i++) {
+ IdentifierRep* identifier = static_cast<IdentifierRep*>(identifiers[i]);
+
+ if (identifier->isString())
+ nameArray.add(identifierFromNPIdentifier(lexicalGlobalObject, identifier->string()));
+ else
+ nameArray.add(Identifier::from(vm, identifier->number()));
+ }
+
+ // FIXME: This should really call NPN_MemFree but that's in WebKit
+ free(identifiers);
+}
+
+}
+}
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/c_instance.h webkitgtk-2.36.7/Source/WebCore/bridge/c/c_instance.h
--- webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/c_instance.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/bridge/c/c_instance.h 2022-08-26 14:18:14.945022144 -0500
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2003 Apple 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 INC. ``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 INC. OR
+ * 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.
+ */
+
+#ifndef BINDINGS_C_INSTANCE_H_
+#define BINDINGS_C_INSTANCE_H_
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "BridgeJSC.h"
+#include "runtime_root.h"
+#include <wtf/text/WTFString.h>
+
+typedef struct NPObject NPObject;
+
+namespace JSC {
+
+namespace Bindings {
+
+class CClass;
+
+class CInstance : public Instance {
+public:
+ static Ref<CInstance> create(NPObject* object, RefPtr<RootObject>&& rootObject)
+ {
+ return adoptRef(*new CInstance(object, WTFMove(rootObject)));
+ }
+
+ static void setGlobalException(String);
+ static void moveGlobalExceptionToExecState(JSGlobalObject*);
+
+ virtual ~CInstance();
+
+ Class *getClass() const override;
+
+ JSValue valueOf(JSGlobalObject*) const override;
+ JSValue defaultValue(JSGlobalObject*, PreferredPrimitiveType) const override;
+
+ JSValue getMethod(JSGlobalObject*, PropertyName) override;
+ JSValue invokeMethod(JSGlobalObject*, CallFrame*, RuntimeMethod*) override;
+ bool supportsInvokeDefaultMethod() const override;
+ JSValue invokeDefaultMethod(JSGlobalObject*, CallFrame*) override;
+
+ bool supportsConstruct() const override;
+ JSValue invokeConstruct(JSGlobalObject*, CallFrame*, const ArgList&) override;
+
+ void getPropertyNames(JSGlobalObject*, PropertyNameArray&) override;
+
+ JSValue stringValue(JSGlobalObject*) const;
+ JSValue numberValue(JSGlobalObject*) const;
+ JSValue booleanValue() const;
+
+ NPObject *getObject() const { return _object; }
+
+private:
+ CInstance(NPObject*, RefPtr<RootObject>&&);
+
+ RuntimeObject* newRuntimeObject(JSGlobalObject*) override;
+ bool toJSPrimitive(JSGlobalObject*, const char*, JSValue&) const;
+
+
+ mutable CClass *_class;
+ NPObject *_object;
+};
+
+} // namespace Bindings
+
+} // namespace JSC
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/c_runtime.cpp webkitgtk-2.36.7/Source/WebCore/bridge/c/c_runtime.cpp
--- webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/c_runtime.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/bridge/c/c_runtime.cpp 2022-08-26 14:18:14.949022165 -0500
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2004 Apple 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 INC. ``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 INC. OR
+ * 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 "config.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "c_runtime.h"
+
+#include "c_instance.h"
+#include "c_utility.h"
+#include "npruntime_impl.h"
+#include <JavaScriptCore/JSLock.h>
+#include <JavaScriptCore/JSObject.h>
+
+namespace JSC {
+namespace Bindings {
+
+JSValue CField::valueFromInstance(JSGlobalObject* lexicalGlobalObject, const Instance* inst) const
+{
+ const CInstance* instance = static_cast<const CInstance*>(inst);
+ NPObject* obj = instance->getObject();
+ if (obj->_class->getProperty) {
+ NPVariant property;
+ VOID_TO_NPVARIANT(property);
+
+ bool result;
+ {
+ JSLock::DropAllLocks dropAllLocks(lexicalGlobalObject);
+ result = obj->_class->getProperty(obj, _fieldIdentifier, &property);
+ CInstance::moveGlobalExceptionToExecState(lexicalGlobalObject);
+ }
+ if (result) {
+ JSValue result = convertNPVariantToValue(lexicalGlobalObject, &property, instance->rootObject());
+ _NPN_ReleaseVariantValue(&property);
+ return result;
+ }
+ }
+ return jsUndefined();
+}
+
+bool CField::setValueToInstance(JSGlobalObject* lexicalGlobalObject, const Instance *inst, JSValue aValue) const
+{
+ const CInstance* instance = static_cast<const CInstance*>(inst);
+ NPObject* obj = instance->getObject();
+ if (obj->_class->setProperty) {
+ NPVariant variant;
+ convertValueToNPVariant(lexicalGlobalObject, aValue, &variant);
+
+ bool result = false;
+ {
+ JSLock::DropAllLocks dropAllLocks(lexicalGlobalObject);
+ result = obj->_class->setProperty(obj, _fieldIdentifier, &variant);
+ CInstance::moveGlobalExceptionToExecState(lexicalGlobalObject);
+ }
+
+ _NPN_ReleaseVariantValue(&variant);
+ return result;
+ }
+ return false;
+}
+
+} }
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/c_runtime.h webkitgtk-2.36.7/Source/WebCore/bridge/c/c_runtime.h
--- webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/c_runtime.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/bridge/c/c_runtime.h 2022-08-26 14:18:14.949022165 -0500
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2004, 2006 Apple 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 INC. ``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 INC. OR
+ * 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.
+ */
+
+#ifndef BINDINGS_C_RUNTIME_H_
+#define BINDINGS_C_RUNTIME_H_
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "BridgeJSC.h"
+#include "npruntime_internal.h"
+
+namespace JSC {
+namespace Bindings {
+
+class CField : public Field {
+public:
+ CField(NPIdentifier ident) : _fieldIdentifier(ident) { }
+
+ JSValue valueFromInstance(JSGlobalObject*, const Instance*) const override;
+ bool setValueToInstance(JSGlobalObject*, const Instance*, JSValue) const override;
+
+ NPIdentifier identifier() const { return _fieldIdentifier; }
+
+private:
+ NPIdentifier _fieldIdentifier;
+};
+
+
+class CMethod : public Method {
+public:
+ CMethod(NPIdentifier ident) : _methodIdentifier(ident) { }
+
+ NPIdentifier identifier() const { return _methodIdentifier; }
+ int numParameters() const override { return 0; }
+
+private:
+ NPIdentifier _methodIdentifier;
+};
+
+} // namespace Bindings
+} // namespace JSC
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/CRuntimeObject.cpp webkitgtk-2.36.7/Source/WebCore/bridge/c/CRuntimeObject.cpp
--- webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/CRuntimeObject.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/bridge/c/CRuntimeObject.cpp 2022-08-26 14:18:14.949022165 -0500
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. ``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 INC. OR
+ * 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 "config.h"
+#include "CRuntimeObject.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "JSDOMBinding.h"
+#include "c_instance.h"
+#include <JavaScriptCore/ObjectPrototype.h>
+
+namespace JSC {
+namespace Bindings {
+
+const ClassInfo CRuntimeObject::s_info = { "CRuntimeObject", &RuntimeObject::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(CRuntimeObject) };
+
+CRuntimeObject::CRuntimeObject(VM& vm, Structure* structure, RefPtr<CInstance>&& instance)
+ : RuntimeObject(vm, structure, WTFMove(instance))
+{
+}
+
+void CRuntimeObject::finishCreation(VM& vm)
+{
+ Base::finishCreation(vm);
+ ASSERT(inherits(vm, info()));
+}
+
+CInstance* CRuntimeObject::getInternalCInstance() const
+{
+ return static_cast<CInstance*>(getInternalInstance());
+}
+
+}
+}
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/CRuntimeObject.h webkitgtk-2.36.7/Source/WebCore/bridge/c/CRuntimeObject.h
--- webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/CRuntimeObject.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/bridge/c/CRuntimeObject.h 2022-08-26 14:18:14.949022165 -0500
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. ``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 INC. OR
+ * 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.
+ */
+
+#ifndef CRuntimeObject_h
+#define CRuntimeObject_h
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "JSDOMBinding.h"
+#include "runtime_object.h"
+
+namespace WebCore {
+ class JSDOMGlobalObject;
+}
+
+namespace JSC {
+namespace Bindings {
+
+class CInstance;
+
+class CRuntimeObject final : public RuntimeObject {
+public:
+ using Base = RuntimeObject;
+
+ static CRuntimeObject* create(VM& vm, Structure* structure, RefPtr<CInstance>&& instance)
+ {
+ CRuntimeObject* object = new (NotNull, allocateCell<CRuntimeObject>(vm)) CRuntimeObject(vm, structure, WTFMove(instance));
+ object->finishCreation(vm);
+ return object;
+ }
+
+ CInstance* getInternalCInstance() const;
+
+ DECLARE_INFO;
+
+ static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
+ {
+ return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
+ }
+
+private:
+ CRuntimeObject(VM&, Structure*, RefPtr<CInstance>&&);
+ void finishCreation(VM&);
+};
+
+}
+}
+
+#endif
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/c_utility.cpp webkitgtk-2.36.7/Source/WebCore/bridge/c/c_utility.cpp
--- webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/c_utility.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/bridge/c/c_utility.cpp 2022-08-26 14:18:14.949022165 -0500
@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2004-2019 Apple Inc. All rights reserved.
+ * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
+ *
+ * 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 INC. ``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 INC. OR
+ * 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 "config.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "c_utility.h"
+
+#include "CRuntimeObject.h"
+#include "DOMWindow.h"
+#include "JSDOMBinding.h"
+#include "JSDOMWindow.h"
+#include "NP_jsobject.h"
+#include "c_instance.h"
+#include "npruntime_impl.h"
+#include "npruntime_priv.h"
+#include "runtime_object.h"
+#include "runtime_root.h"
+#include <JavaScriptCore/JSGlobalObject.h>
+#include <JavaScriptCore/JSLock.h>
+#include <wtf/Assertions.h>
+#include <wtf/text/WTFString.h>
+
+namespace JSC { namespace Bindings {
+
+static String convertUTF8ToUTF16WithLatin1Fallback(const NPUTF8* UTF8Chars, int UTF8Length)
+{
+ ASSERT(UTF8Chars || UTF8Length == 0);
+
+ if (UTF8Length == -1)
+ UTF8Length = static_cast<int>(strlen(UTF8Chars));
+
+ String result = String::fromUTF8(UTF8Chars, UTF8Length);
+
+ // If we got back a null string indicating an unsuccessful conversion, fall back to latin 1.
+ // Some plugins return invalid UTF-8 in NPVariantType_String, see <http://bugs.webkit.org/show_bug.cgi?id=5163>
+ // There is no "bad data" for latin1. It is unlikely that the plugin was really sending text in this encoding,
+ // but it should have used UTF-8, and now we are simply avoiding a crash.
+ if (result.isNull())
+ result = String(UTF8Chars, UTF8Length);
+
+ return result;
+}
+
+// Variant value must be released with NPReleaseVariantValue()
+void convertValueToNPVariant(JSGlobalObject* exec, JSValue value, NPVariant* result)
+{
+ JSLockHolder lock(exec);
+ VM& vm = exec->vm();
+
+ VOID_TO_NPVARIANT(*result);
+
+ if (value.isString()) {
+ String ustring = value.toWTFString(exec);
+ CString cstring = ustring.utf8();
+ NPString string = { (const NPUTF8*)cstring.data(), static_cast<uint32_t>(cstring.length()) };
+ NPN_InitializeVariantWithStringCopy(result, &string);
+ } else if (value.isNumber()) {
+ DOUBLE_TO_NPVARIANT(value.toNumber(exec), *result);
+ } else if (value.isBoolean()) {
+ BOOLEAN_TO_NPVARIANT(value.toBoolean(exec), *result);
+ } else if (value.isNull()) {
+ NULL_TO_NPVARIANT(*result);
+ } else if (value.isObject()) {
+ JSObject* object = asObject(value);
+ if (object->classInfo(vm) == CRuntimeObject::info()) {
+ CRuntimeObject* runtimeObject = static_cast<CRuntimeObject*>(object);
+ CInstance* instance = runtimeObject->getInternalCInstance();
+ if (instance) {
+ NPObject* obj = instance->getObject();
+ _NPN_RetainObject(obj);
+ OBJECT_TO_NPVARIANT(obj, *result);
+ }
+ } else {
+ JSGlobalObject* globalObject = vm.deprecatedVMEntryGlobalObject(exec);
+
+ RootObject* rootObject = findRootObject(globalObject);
+ if (rootObject) {
+ NPObject* npObject = _NPN_CreateScriptObject(0, object, rootObject);
+ OBJECT_TO_NPVARIANT(npObject, *result);
+ }
+ }
+ }
+}
+
+JSValue convertNPVariantToValue(JSGlobalObject* exec, const NPVariant* variant, RootObject* rootObject)
+{
+ JSLockHolder lock(exec);
+
+ NPVariantType type = variant->type;
+
+ if (type == NPVariantType_Bool)
+ return jsBoolean(NPVARIANT_TO_BOOLEAN(*variant));
+ if (type == NPVariantType_Null)
+ return jsNull();
+ if (type == NPVariantType_Void)
+ return jsUndefined();
+ if (type == NPVariantType_Int32)
+ return jsNumber(NPVARIANT_TO_INT32(*variant));
+ if (type == NPVariantType_Double)
+ return jsNumber(NPVARIANT_TO_DOUBLE(*variant));
+ if (type == NPVariantType_String)
+ return jsStringWithCache(exec->vm(), convertNPStringToUTF16(&variant->value.stringValue));
+ if (type == NPVariantType_Object) {
+ NPObject* obj = variant->value.objectValue;
+
+ if (obj->_class == NPScriptObjectClass)
+ // Get JSObject from NP_JavaScriptObject.
+ return ((JavaScriptObject*)obj)->imp;
+
+ // Wrap NPObject in a CInstance.
+ return CInstance::create(obj, rootObject)->createRuntimeObject(exec);
+ }
+
+ return jsUndefined();
+}
+
+String convertNPStringToUTF16(const NPString* string)
+{
+ return String::fromUTF8WithLatin1Fallback(string->UTF8Characters, string->UTF8Length);
+}
+
+Identifier identifierFromNPIdentifier(JSGlobalObject* exec, const NPUTF8* name)
+{
+ VM& vm = exec->vm();
+ return Identifier::fromString(vm, convertUTF8ToUTF16WithLatin1Fallback(name, -1));
+}
+
+} }
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/c_utility.h webkitgtk-2.36.7/Source/WebCore/bridge/c/c_utility.h
--- webkitgtk-2.36.7.orig/Source/WebCore/bridge/c/c_utility.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/bridge/c/c_utility.h 2022-08-26 14:18:14.949022165 -0500
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2004 Apple 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 INC. ``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 INC. OR
+ * 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.
+ */
+
+#ifndef C_UTILITY_H_
+#define C_UTILITY_H_
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "npruntime_internal.h"
+#include <JavaScriptCore/JSCInlines.h>
+#include <JavaScriptCore/JSCJSValue.h>
+#include <wtf/Forward.h>
+
+namespace JSC {
+
+class CallFrame;
+class Identifier;
+
+namespace Bindings {
+
+class RootObject;
+
+typedef uint16_t NPUTF16;
+
+String convertNPStringToUTF16(const NPString *);
+void convertValueToNPVariant(JSGlobalObject*, JSValue, NPVariant* result);
+JSValue convertNPVariantToValue(JSGlobalObject*, const NPVariant*, RootObject*);
+Identifier identifierFromNPIdentifier(JSGlobalObject*, const NPUTF8* name);
+
+} }
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/bridge/NP_jsobject.cpp webkitgtk-2.36.7/Source/WebCore/bridge/NP_jsobject.cpp
--- webkitgtk-2.36.7.orig/Source/WebCore/bridge/NP_jsobject.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/bridge/NP_jsobject.cpp 2022-08-26 14:18:14.953022187 -0500
@@ -0,0 +1,557 @@
+/*
+ * Copyright (C) 2004-2019 Apple 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 INC. ``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 INC. OR
+ * 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 "config.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "NP_jsobject.h"
+
+#include "IdentifierRep.h"
+#include "JSDOMBinding.h"
+#include "c_instance.h"
+#include "c_utility.h"
+#include "npruntime_priv.h"
+#include "runtime_root.h"
+#include <JavaScriptCore/CatchScope.h>
+#include <JavaScriptCore/Completion.h>
+#include <JavaScriptCore/Error.h>
+#include <JavaScriptCore/JSGlobalObject.h>
+#include <JavaScriptCore/JSLock.h>
+#include <JavaScriptCore/PropertyNameArray.h>
+#include <JavaScriptCore/SourceCode.h>
+#include <wtf/NeverDestroyed.h>
+#include <wtf/text/WTFString.h>
+
+#pragma GCC visibility push(default)
+#include "npruntime_impl.h"
+#pragma GCC visibility pop
+
+namespace JSC {
+using namespace Bindings;
+using namespace WebCore;
+
+class ObjectMap {
+public:
+ NPObject* get(RootObject* rootObject, JSObject* jsObject)
+ {
+ return m_map.get(rootObject).get(jsObject);
+ }
+
+ void add(RootObject* rootObject, JSObject* jsObject, NPObject* npObject)
+ {
+ HashMap<RootObject*, JSToNPObjectMap>::iterator iter = m_map.find(rootObject);
+ if (iter == m_map.end()) {
+ rootObject->addInvalidationCallback(&m_invalidationCallback);
+ iter = m_map.add(rootObject, JSToNPObjectMap()).iterator;
+ }
+
+ ASSERT(iter->value.find(jsObject) == iter->value.end());
+ iter->value.add(jsObject, npObject);
+ }
+
+ void remove(RootObject* rootObject)
+ {
+ ASSERT(m_map.contains(rootObject));
+ m_map.remove(rootObject);
+ }
+
+ void remove(RootObject* rootObject, JSObject* jsObject)
+ {
+ HashMap<RootObject*, JSToNPObjectMap>::iterator iter = m_map.find(rootObject);
+ ASSERT(iter != m_map.end());
+ ASSERT(iter->value.find(jsObject) != iter->value.end());
+
+ iter->value.remove(jsObject);
+ }
+
+private:
+ struct RootObjectInvalidationCallback : public RootObject::InvalidationCallback {
+ void operator()(RootObject*) override;
+ };
+ RootObjectInvalidationCallback m_invalidationCallback;
+
+ // JSObjects are protected by RootObject.
+ typedef HashMap<JSObject*, NPObject*> JSToNPObjectMap;
+ HashMap<RootObject*, JSToNPObjectMap> m_map;
+};
+
+
+static ObjectMap& objectMap()
+{
+ static NeverDestroyed<ObjectMap> map;
+ return map;
+}
+
+void ObjectMap::RootObjectInvalidationCallback::operator()(RootObject* rootObject)
+{
+ objectMap().remove(rootObject);
+}
+
+static void getListFromVariantArgs(JSGlobalObject* lexicalGlobalObject, const NPVariant* args, unsigned argCount, RootObject* rootObject, MarkedArgumentBuffer& aList)
+{
+ for (unsigned i = 0; i < argCount; ++i)
+ aList.append(convertNPVariantToValue(lexicalGlobalObject, &args[i], rootObject));
+}
+
+static NPObject* jsAllocate(NPP, NPClass*)
+{
+ return static_cast<NPObject*>(malloc(sizeof(JavaScriptObject)));
+}
+
+static void jsDeallocate(NPObject* npObj)
+{
+ JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(npObj);
+
+ if (obj->rootObject && obj->rootObject->isValid()) {
+ objectMap().remove(obj->rootObject, obj->imp);
+ obj->rootObject->gcUnprotect(obj->imp);
+ }
+
+ if (obj->rootObject)
+ obj->rootObject->deref();
+
+ free(obj);
+}
+
+static NPClass javascriptClass = { 1, jsAllocate, jsDeallocate, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+static NPClass noScriptClass = { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+extern "C" {
+NPClass* NPScriptObjectClass = &javascriptClass;
+static NPClass* NPNoScriptObjectClass = &noScriptClass;
+
+NPObject* _NPN_CreateScriptObject(NPP npp, JSObject* imp, RefPtr<RootObject>&& rootObject)
+{
+ if (NPObject* object = objectMap().get(rootObject.get(), imp))
+ return _NPN_RetainObject(object);
+
+ JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(_NPN_CreateObject(npp, NPScriptObjectClass));
+
+ obj->rootObject = rootObject.leakRef();
+
+ if (obj->rootObject) {
+ obj->rootObject->gcProtect(imp);
+ objectMap().add(obj->rootObject, imp, reinterpret_cast<NPObject*>(obj));
+ }
+
+ obj->imp = imp;
+
+ return reinterpret_cast<NPObject*>(obj);
+}
+
+NPObject* _NPN_CreateNoScriptObject(void)
+{
+ return _NPN_CreateObject(0, NPNoScriptObjectClass);
+}
+
+bool _NPN_InvokeDefault(NPP, NPObject* o, const NPVariant* args, uint32_t argCount, NPVariant* result)
+{
+ if (o->_class == NPScriptObjectClass) {
+ JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o);
+
+ VOID_TO_NPVARIANT(*result);
+
+ // Lookup the function object.
+ RootObject* rootObject = obj->rootObject;
+ if (!rootObject || !rootObject->isValid())
+ return false;
+
+ auto globalObject = rootObject->globalObject();
+ VM& vm = globalObject->vm();
+ JSLockHolder lock(vm);
+ auto scope = DECLARE_CATCH_SCOPE(vm);
+
+ JSGlobalObject* lexicalGlobalObject = globalObject;
+
+ // Call the function object.
+ JSValue function = obj->imp;
+ auto callData = getCallData(vm, function);
+ if (callData.type == CallData::Type::None)
+ return false;
+
+ MarkedArgumentBuffer argList;
+ getListFromVariantArgs(lexicalGlobalObject, args, argCount, rootObject, argList);
+ RELEASE_ASSERT(!argList.hasOverflowed());
+ JSValue resultV = JSC::call(lexicalGlobalObject, function, callData, function, argList);
+
+ // Convert and return the result of the function call.
+ convertValueToNPVariant(lexicalGlobalObject, resultV, result);
+ scope.clearException();
+ return true;
+ }
+
+ if (o->_class->invokeDefault)
+ return o->_class->invokeDefault(o, args, argCount, result);
+ VOID_TO_NPVARIANT(*result);
+ return true;
+}
+
+bool _NPN_Invoke(NPP npp, NPObject* o, NPIdentifier methodName, const NPVariant* args, uint32_t argCount, NPVariant* result)
+{
+ if (o->_class == NPScriptObjectClass) {
+ JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o);
+
+ IdentifierRep* i = static_cast<IdentifierRep*>(methodName);
+ if (!i->isString())
+ return false;
+
+ // Special case the "eval" method.
+ if (methodName == _NPN_GetStringIdentifier("eval")) {
+ if (argCount != 1)
+ return false;
+ if (args[0].type != NPVariantType_String)
+ return false;
+ return _NPN_Evaluate(npp, o, const_cast<NPString*>(&args[0].value.stringValue), result);
+ }
+
+ // Look up the function object.
+ RootObject* rootObject = obj->rootObject;
+ if (!rootObject || !rootObject->isValid())
+ return false;
+
+ auto globalObject = rootObject->globalObject();
+ VM& vm = globalObject->vm();
+ JSLockHolder lock(vm);
+ auto scope = DECLARE_CATCH_SCOPE(vm);
+
+ JSGlobalObject* lexicalGlobalObject = globalObject;
+ JSValue function = obj->imp->get(lexicalGlobalObject, identifierFromNPIdentifier(lexicalGlobalObject, i->string()));
+ auto callData = getCallData(vm, function);
+ if (callData.type == CallData::Type::None)
+ return false;
+
+ // Call the function object.
+ MarkedArgumentBuffer argList;
+ getListFromVariantArgs(lexicalGlobalObject, args, argCount, rootObject, argList);
+ RELEASE_ASSERT(!argList.hasOverflowed());
+ JSValue resultV = JSC::call(lexicalGlobalObject, function, callData, obj->imp, argList);
+
+ // Convert and return the result of the function call.
+ convertValueToNPVariant(lexicalGlobalObject, resultV, result);
+ scope.clearException();
+ return true;
+ }
+
+ if (o->_class->invoke)
+ return o->_class->invoke(o, methodName, args, argCount, result);
+
+ VOID_TO_NPVARIANT(*result);
+ return true;
+}
+
+bool _NPN_Evaluate(NPP, NPObject* o, NPString* s, NPVariant* variant)
+{
+ if (o->_class == NPScriptObjectClass) {
+ JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o);
+
+ RootObject* rootObject = obj->rootObject;
+ if (!rootObject || !rootObject->isValid())
+ return false;
+
+ auto globalObject = rootObject->globalObject();
+ VM& vm = globalObject->vm();
+ JSLockHolder lock(vm);
+ auto scope = DECLARE_CATCH_SCOPE(vm);
+
+ JSGlobalObject* lexicalGlobalObject = globalObject;
+ String scriptString = convertNPStringToUTF16(s);
+
+ JSValue returnValue = JSC::evaluate(lexicalGlobalObject, JSC::makeSource(scriptString, { }), JSC::JSValue());
+
+ convertValueToNPVariant(lexicalGlobalObject, returnValue, variant);
+ scope.clearException();
+ return true;
+ }
+
+ VOID_TO_NPVARIANT(*variant);
+ return false;
+}
+
+bool _NPN_GetProperty(NPP, NPObject* o, NPIdentifier propertyName, NPVariant* variant)
+{
+ if (o->_class == NPScriptObjectClass) {
+ JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o);
+
+ RootObject* rootObject = obj->rootObject;
+ if (!rootObject || !rootObject->isValid())
+ return false;
+
+ auto globalObject = rootObject->globalObject();
+ VM& vm = globalObject->vm();
+ JSLockHolder lock(vm);
+ auto scope = DECLARE_CATCH_SCOPE(vm);
+
+ JSGlobalObject* lexicalGlobalObject = globalObject;
+ IdentifierRep* i = static_cast<IdentifierRep*>(propertyName);
+
+ JSValue result;
+ if (i->isString())
+ result = obj->imp->get(lexicalGlobalObject, identifierFromNPIdentifier(lexicalGlobalObject, i->string()));
+ else
+ result = obj->imp->get(lexicalGlobalObject, static_cast<uint32_t>(i->number()));
+
+ convertValueToNPVariant(lexicalGlobalObject, result, variant);
+ scope.clearException();
+ return true;
+ }
+
+ if (o->_class->hasProperty && o->_class->getProperty) {
+ if (o->_class->hasProperty(o, propertyName))
+ return o->_class->getProperty(o, propertyName, variant);
+ return false;
+ }
+
+ VOID_TO_NPVARIANT(*variant);
+ return false;
+}
+
+bool _NPN_SetProperty(NPP, NPObject* o, NPIdentifier propertyName, const NPVariant* variant)
+{
+ if (o->_class == NPScriptObjectClass) {
+ JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o);
+
+ RootObject* rootObject = obj->rootObject;
+ if (!rootObject || !rootObject->isValid())
+ return false;
+
+ auto globalObject = rootObject->globalObject();
+ VM& vm = globalObject->vm();
+ JSLockHolder lock(vm);
+ auto scope = DECLARE_CATCH_SCOPE(vm);
+
+ JSGlobalObject* lexicalGlobalObject = globalObject;
+ IdentifierRep* i = static_cast<IdentifierRep*>(propertyName);
+
+ if (i->isString()) {
+ PutPropertySlot slot(obj->imp);
+ obj->imp->methodTable(vm)->put(obj->imp, lexicalGlobalObject, identifierFromNPIdentifier(lexicalGlobalObject, i->string()), convertNPVariantToValue(lexicalGlobalObject, variant, rootObject), slot);
+ } else
+ obj->imp->methodTable(vm)->putByIndex(obj->imp, lexicalGlobalObject, i->number(), convertNPVariantToValue(lexicalGlobalObject, variant, rootObject), false);
+ scope.clearException();
+ return true;
+ }
+
+ if (o->_class->setProperty)
+ return o->_class->setProperty(o, propertyName, variant);
+
+ return false;
+}
+
+bool _NPN_RemoveProperty(NPP, NPObject* o, NPIdentifier propertyName)
+{
+ if (o->_class == NPScriptObjectClass) {
+ JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o);
+
+ RootObject* rootObject = obj->rootObject;
+ if (!rootObject || !rootObject->isValid())
+ return false;
+
+ auto globalObject = rootObject->globalObject();
+ VM& vm = globalObject->vm();
+ JSLockHolder lock(vm);
+ auto scope = DECLARE_CATCH_SCOPE(vm);
+
+ JSGlobalObject* lexicalGlobalObject = globalObject;
+
+ IdentifierRep* i = static_cast<IdentifierRep*>(propertyName);
+ if (i->isString()) {
+ if (!obj->imp->hasProperty(lexicalGlobalObject, identifierFromNPIdentifier(lexicalGlobalObject, i->string()))) {
+ scope.clearException();
+ return false;
+ }
+ } else {
+ if (!obj->imp->hasProperty(lexicalGlobalObject, static_cast<uint32_t>(i->number()))) {
+ scope.clearException();
+ return false;
+ }
+ }
+
+ if (i->isString())
+ JSCell::deleteProperty(obj->imp, lexicalGlobalObject, identifierFromNPIdentifier(lexicalGlobalObject, i->string()));
+ else
+ obj->imp->methodTable(vm)->deletePropertyByIndex(obj->imp, lexicalGlobalObject, i->number());
+
+ scope.clearException();
+ return true;
+ }
+ return false;
+}
+
+bool _NPN_HasProperty(NPP, NPObject* o, NPIdentifier propertyName)
+{
+ if (o->_class == NPScriptObjectClass) {
+ JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o);
+
+ RootObject* rootObject = obj->rootObject;
+ if (!rootObject || !rootObject->isValid())
+ return false;
+
+ auto globalObject = rootObject->globalObject();
+ VM& vm = globalObject->vm();
+ JSLockHolder lock(vm);
+ auto scope = DECLARE_CATCH_SCOPE(vm);
+
+ JSGlobalObject* lexicalGlobalObject = globalObject;
+ IdentifierRep* i = static_cast<IdentifierRep*>(propertyName);
+ if (i->isString()) {
+ bool result = obj->imp->hasProperty(lexicalGlobalObject, identifierFromNPIdentifier(lexicalGlobalObject, i->string()));
+ scope.clearException();
+ return result;
+ }
+
+ bool result = obj->imp->hasProperty(lexicalGlobalObject, static_cast<uint32_t>(i->number()));
+ scope.clearException();
+ return result;
+ }
+
+ if (o->_class->hasProperty)
+ return o->_class->hasProperty(o, propertyName);
+
+ return false;
+}
+
+bool _NPN_HasMethod(NPP, NPObject* o, NPIdentifier methodName)
+{
+ if (o->_class == NPScriptObjectClass) {
+ JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o);
+
+ IdentifierRep* i = static_cast<IdentifierRep*>(methodName);
+ if (!i->isString())
+ return false;
+
+ RootObject* rootObject = obj->rootObject;
+ if (!rootObject || !rootObject->isValid())
+ return false;
+
+ auto globalObject = rootObject->globalObject();
+ VM& vm = globalObject->vm();
+ JSLockHolder lock(vm);
+ auto scope = DECLARE_CATCH_SCOPE(vm);
+
+ JSGlobalObject* lexicalGlobalObject = globalObject;
+ JSValue func = obj->imp->get(lexicalGlobalObject, identifierFromNPIdentifier(lexicalGlobalObject, i->string()));
+ scope.clearException();
+ return !func.isUndefined();
+ }
+
+ if (o->_class->hasMethod)
+ return o->_class->hasMethod(o, methodName);
+
+ return false;
+}
+
+void _NPN_SetException(NPObject*, const NPUTF8* message)
+{
+ // Ignoring the NPObject param is consistent with the Mozilla implementation.
+ String exception(message);
+ CInstance::setGlobalException(exception);
+}
+
+bool _NPN_Enumerate(NPP, NPObject* o, NPIdentifier** identifier, uint32_t* count)
+{
+ if (o->_class == NPScriptObjectClass) {
+ JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o);
+
+ RootObject* rootObject = obj->rootObject;
+ if (!rootObject || !rootObject->isValid())
+ return false;
+
+ auto globalObject = rootObject->globalObject();
+ VM& vm = globalObject->vm();
+ JSLockHolder lock(vm);
+ auto scope = DECLARE_CATCH_SCOPE(vm);
+
+ JSGlobalObject* lexicalGlobalObject = globalObject;
+ PropertyNameArray propertyNames(vm, PropertyNameMode::Strings, PrivateSymbolMode::Exclude);
+
+ obj->imp->getPropertyNames(lexicalGlobalObject, propertyNames, DontEnumPropertiesMode::Exclude);
+ unsigned size = static_cast<unsigned>(propertyNames.size());
+ // FIXME: This should really call NPN_MemAlloc but that's in WebKit
+ NPIdentifier* identifiers = static_cast<NPIdentifier*>(malloc(sizeof(NPIdentifier) * size));
+
+ for (unsigned i = 0; i < size; ++i)
+ identifiers[i] = _NPN_GetStringIdentifier(propertyNames[i].string().utf8().data());
+
+ *identifier = identifiers;
+ *count = size;
+
+ scope.clearException();
+ return true;
+ }
+
+ if (NP_CLASS_STRUCT_VERSION_HAS_ENUM(o->_class) && o->_class->enumerate)
+ return o->_class->enumerate(o, identifier, count);
+
+ return false;
+}
+
+bool _NPN_Construct(NPP, NPObject* o, const NPVariant* args, uint32_t argCount, NPVariant* result)
+{
+ if (o->_class == NPScriptObjectClass) {
+ JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o);
+
+ VOID_TO_NPVARIANT(*result);
+
+ // Lookup the constructor object.
+ RootObject* rootObject = obj->rootObject;
+ if (!rootObject || !rootObject->isValid())
+ return false;
+
+ auto globalObject = rootObject->globalObject();
+ VM& vm = globalObject->vm();
+ JSLockHolder lock(vm);
+ auto scope = DECLARE_CATCH_SCOPE(vm);
+
+ JSGlobalObject* lexicalGlobalObject = globalObject;
+
+ // Call the constructor object.
+ JSValue constructor = obj->imp;
+ auto constructData = getConstructData(vm, constructor);
+ if (constructData.type == CallData::Type::None)
+ return false;
+
+ MarkedArgumentBuffer argList;
+ getListFromVariantArgs(lexicalGlobalObject, args, argCount, rootObject, argList);
+ RELEASE_ASSERT(!argList.hasOverflowed());
+ JSValue resultV = JSC::construct(lexicalGlobalObject, constructor, constructData, argList);
+
+ // Convert and return the result.
+ convertValueToNPVariant(lexicalGlobalObject, resultV, result);
+ scope.clearException();
+ return true;
+ }
+
+ if (NP_CLASS_STRUCT_VERSION_HAS_CTOR(o->_class) && o->_class->construct)
+ return o->_class->construct(o, args, argCount, result);
+
+ return false;
+}
+
+} // extern "C"
+
+} // namespace JSC
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/bridge/NP_jsobject.h webkitgtk-2.36.7/Source/WebCore/bridge/NP_jsobject.h
--- webkitgtk-2.36.7.orig/Source/WebCore/bridge/NP_jsobject.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/bridge/NP_jsobject.h 2022-08-26 14:18:14.953022187 -0500
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2004, 2006 Apple 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 INC. ``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 INC. OR
+ * 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.
+ */
+
+#ifndef NP_JSOBJECT_H
+#define NP_JSOBJECT_H
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "npruntime_internal.h"
+#include <wtf/Forward.h>
+
+namespace JSC {
+class JSObject;
+namespace Bindings {
+class RootObject;
+}
+}
+
+struct JavaScriptObject
+{
+ NPObject object;
+ JSC::JSObject* imp;
+ JSC::Bindings::RootObject* rootObject;
+};
+
+extern "C" {
+extern NPClass* NPScriptObjectClass;
+
+WEBCORE_EXPORT NPObject* _NPN_CreateScriptObject(NPP, JSC::JSObject*, RefPtr<JSC::Bindings::RootObject>&&);
+WEBCORE_EXPORT NPObject* _NPN_CreateNoScriptObject(void);
+}
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/bridge/npruntime.cpp webkitgtk-2.36.7/Source/WebCore/bridge/npruntime.cpp
--- webkitgtk-2.36.7.orig/Source/WebCore/bridge/npruntime.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/bridge/npruntime.cpp 2022-08-26 14:18:14.953022187 -0500
@@ -0,0 +1,166 @@
+/*
+ * Copyright (C) 2004, 2006 Apple 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 INC. ``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 INC. OR
+ * 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 "config.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "IdentifierRep.h"
+#include "npruntime_internal.h"
+#include "npruntime_priv.h"
+
+#include "c_utility.h"
+#include <JavaScriptCore/Identifier.h>
+#include <wtf/Assertions.h>
+
+#pragma GCC visibility push(default)
+#include "npruntime_impl.h"
+#pragma GCC visibility pop
+
+using namespace WebCore;
+
+NPIdentifier _NPN_GetStringIdentifier(const NPUTF8* name)
+{
+ return static_cast<NPIdentifier>(IdentifierRep::get(name));
+}
+
+void _NPN_GetStringIdentifiers(const NPUTF8** names, int32_t nameCount, NPIdentifier* identifiers)
+{
+ ASSERT(names);
+ ASSERT(identifiers);
+
+ if (names && identifiers) {
+ for (int i = 0; i < nameCount; i++)
+ identifiers[i] = _NPN_GetStringIdentifier(names[i]);
+ }
+}
+
+NPIdentifier _NPN_GetIntIdentifier(int32_t intid)
+{
+ return static_cast<NPIdentifier>(IdentifierRep::get(intid));
+}
+
+bool _NPN_IdentifierIsString(NPIdentifier identifier)
+{
+ return static_cast<IdentifierRep*>(identifier)->isString();
+}
+
+NPUTF8 *_NPN_UTF8FromIdentifier(NPIdentifier identifier)
+{
+ const char* string = static_cast<IdentifierRep*>(identifier)->string();
+ if (!string)
+ return 0;
+
+ return strdup(string);
+}
+
+int32_t _NPN_IntFromIdentifier(NPIdentifier identifier)
+{
+ return static_cast<IdentifierRep*>(identifier)->number();
+}
+
+void NPN_InitializeVariantWithStringCopy(NPVariant* variant, const NPString* value)
+{
+ variant->type = NPVariantType_String;
+ variant->value.stringValue.UTF8Length = value->UTF8Length;
+ // Switching to fastMalloc would be better to avoid length check but this is not desirable
+ // as NPN_MemAlloc is using malloc and there might be plugins that mix NPN_MemAlloc and malloc too.
+ variant->value.stringValue.UTF8Characters = (NPUTF8*)malloc(sizeof(NPUTF8) * value->UTF8Length);
+ if (value->UTF8Length && !variant->value.stringValue.UTF8Characters)
+ CRASH();
+ memcpy((void*)variant->value.stringValue.UTF8Characters, value->UTF8Characters, sizeof(NPUTF8) * value->UTF8Length);
+}
+
+void _NPN_ReleaseVariantValue(NPVariant* variant)
+{
+ ASSERT(variant);
+
+ if (variant->type == NPVariantType_Object) {
+ _NPN_ReleaseObject(variant->value.objectValue);
+ variant->value.objectValue = 0;
+ } else if (variant->type == NPVariantType_String) {
+ free((void*)variant->value.stringValue.UTF8Characters);
+ variant->value.stringValue.UTF8Characters = 0;
+ variant->value.stringValue.UTF8Length = 0;
+ }
+
+ variant->type = NPVariantType_Void;
+}
+
+NPObject *_NPN_CreateObject(NPP npp, NPClass* aClass)
+{
+ ASSERT(aClass);
+
+ if (aClass) {
+ NPObject* obj;
+ if (aClass->allocate != NULL)
+ obj = aClass->allocate(npp, aClass);
+ else
+ obj = (NPObject*)malloc(sizeof(NPObject));
+ if (!obj)
+ CRASH();
+ obj->_class = aClass;
+ obj->referenceCount = 1;
+
+ return obj;
+ }
+
+ return 0;
+}
+
+NPObject* _NPN_RetainObject(NPObject* obj)
+{
+ ASSERT(obj);
+
+ if (obj)
+ obj->referenceCount++;
+
+ return obj;
+}
+
+void _NPN_ReleaseObject(NPObject* obj)
+{
+ ASSERT(obj);
+ ASSERT(obj->referenceCount >= 1);
+
+ if (obj && obj->referenceCount >= 1) {
+ if (--obj->referenceCount == 0)
+ _NPN_DeallocateObject(obj);
+ }
+}
+
+void _NPN_DeallocateObject(NPObject *obj)
+{
+ ASSERT(obj);
+
+ if (obj) {
+ if (obj->_class->deallocate)
+ obj->_class->deallocate(obj);
+ else
+ free(obj);
+ }
+}
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/bridge/npruntime_impl.h webkitgtk-2.36.7/Source/WebCore/bridge/npruntime_impl.h
--- webkitgtk-2.36.7.orig/Source/WebCore/bridge/npruntime_impl.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/bridge/npruntime_impl.h 2022-08-26 14:18:14.953022187 -0500
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2004 Apple 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 INC. ``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 INC. OR
+ * 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.
+ */
+
+#ifndef _NP_RUNTIME_IMPL_H_
+#define _NP_RUNTIME_IMPL_H_
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "npruntime_internal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void _NPN_ReleaseVariantValue(NPVariant*);
+extern NPIdentifier _NPN_GetStringIdentifier(const NPUTF8*);
+extern void _NPN_GetStringIdentifiers(const NPUTF8** names, int32_t nameCount, NPIdentifier* identifiers);
+extern NPIdentifier _NPN_GetIntIdentifier(int32_t);
+extern bool _NPN_IdentifierIsString(NPIdentifier);
+extern NPUTF8* _NPN_UTF8FromIdentifier(NPIdentifier);
+extern int32_t _NPN_IntFromIdentifier(NPIdentifier);
+extern NPObject* _NPN_CreateObject(NPP, NPClass*);
+extern NPObject* _NPN_RetainObject(NPObject*);
+extern void _NPN_ReleaseObject(NPObject*);
+extern void _NPN_DeallocateObject(NPObject*);
+extern bool _NPN_Invoke(NPP, NPObject*, NPIdentifier methodName, const NPVariant* args, uint32_t argCount, NPVariant* result);
+extern bool _NPN_InvokeDefault(NPP, NPObject*, const NPVariant* args, uint32_t argCount, NPVariant* result);
+extern bool _NPN_Evaluate(NPP, NPObject*, NPString*, NPVariant* result);
+extern bool _NPN_GetProperty(NPP, NPObject*, NPIdentifier, NPVariant* result);
+extern bool _NPN_SetProperty(NPP, NPObject*, NPIdentifier, const NPVariant*);
+extern bool _NPN_RemoveProperty(NPP, NPObject*, NPIdentifier);
+extern bool _NPN_HasProperty(NPP, NPObject*, NPIdentifier);
+extern bool _NPN_HasMethod(NPP, NPObject*, NPIdentifier);
+extern void _NPN_SetException(NPObject*, const NPUTF8*);
+extern bool _NPN_Enumerate(NPP, NPObject*, NPIdentifier**, uint32_t* count);
+extern bool _NPN_Construct(NPP, NPObject*, const NPVariant* args, uint32_t argCount, NPVariant *result);
+
+#ifdef __cplusplus
+} /* end extern "C" */
+#endif
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/bridge/npruntime_internal.h webkitgtk-2.36.7/Source/WebCore/bridge/npruntime_internal.h
--- webkitgtk-2.36.7.orig/Source/WebCore/bridge/npruntime_internal.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/bridge/npruntime_internal.h 2022-08-26 14:18:14.953022187 -0500
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2007-2008 Collabora Ltd. All rights reserved.
+ * Copyright (C) 2020 Apple Inc. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ * This is a internal include header for npapi.h
+ *
+ * Some of the #defines which are in X11 headers conflict with type and enum
+ * names in JavaScriptCore and WebCore
+ * This header #undefs those defines to fix the conflicts
+ * If you need to include npapi.h or npruntime.h when building on X11,
+ * include this file instead of the actual npapi.h or npruntime.h
+ */
+
+#pragma once
+
+#include "npapi.h"
+#include "npfunctions.h"
+#include "npruntime.h"
+
+#if defined(MOZ_X11)
+ #include <X11/Xresource.h>
+
+ #undef Always
+ #undef None
+ #undef Above
+ #undef Below
+ #undef Auto
+ #undef Complex
+ #undef Status
+ #undef CursorShape
+ #undef FocusIn
+ #undef FocusOut
+ #undef KeyPress
+ #undef KeyRelease
+ #undef Unsorted
+ #undef Bool
+ #undef FontChange
+ #undef GrayScale
+ #undef NormalState
+ #undef True
+ #undef False
+ #undef Success
+ #undef Expose
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/bridge/npruntime_priv.h webkitgtk-2.36.7/Source/WebCore/bridge/npruntime_priv.h
--- webkitgtk-2.36.7.orig/Source/WebCore/bridge/npruntime_priv.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/bridge/npruntime_priv.h 2022-08-26 14:18:14.953022187 -0500
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2003, 2006 Apple 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 INC. ``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 INC. OR
+ * 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.
+ */
+
+#ifndef NP_RUNTIME_PRIV_H_
+#define NP_RUNTIME_PRIV_H_
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "npruntime_internal.h"
+
+/*
+ NPN_InitializeVariantWithStringCopy() will copy string data. The string data
+ will be deallocated by calls to NPReleaseVariantValue().
+*/
+void NPN_InitializeVariantWithStringCopy(NPVariant*, const NPString*);
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+#endif
+
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/Headers.cmake webkitgtk-2.36.7/Source/WebCore/Headers.cmake
--- webkitgtk-2.36.7.orig/Source/WebCore/Headers.cmake 2022-06-30 04:49:31.002850300 -0500
+++ webkitgtk-2.36.7/Source/WebCore/Headers.cmake 2022-08-26 14:18:14.957022207 -0500
@@ -487,10 +487,16 @@ set(WebCore_PRIVATE_FRAMEWORK_HEADERS
bridge/Bridge.h
bridge/IdentifierRep.h
+ bridge/NP_jsobject.h
+ bridge/npruntime_impl.h
+ bridge/npruntime_internal.h
bridge/runtime_method.h
bridge/runtime_object.h
bridge/runtime_root.h
+ bridge/c/c_instance.h
+ bridge/c/c_utility.h
+
bridge/jsc/BridgeJSC.h
contentextensions/CombinedFiltersAlphabet.h
@@ -1757,6 +1763,7 @@ set(WebCore_PRIVATE_FRAMEWORK_HEADERS
platform/network/ProtectionSpace.h
platform/network/ProtectionSpaceBase.h
platform/network/ProtectionSpaceHash.h
+ platform/network/ProxyServer.h
platform/network/ResourceErrorBase.h
platform/network/ResourceHandle.h
platform/network/ResourceHandleClient.h
@@ -1798,6 +1805,10 @@ set(WebCore_PRIVATE_FRAMEWORK_HEADERS
plugins/PluginData.h
plugins/PluginInfoProvider.h
plugins/PluginViewBase.h
+ plugins/npapi.h
+ plugins/npfunctions.h
+ plugins/npruntime.h
+ plugins/nptypes.h
rendering/BreakLines.h
rendering/CSSFilter.h
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/history/BackForwardCache.cpp webkitgtk-2.36.7/Source/WebCore/history/BackForwardCache.cpp
--- webkitgtk-2.36.7.orig/Source/WebCore/history/BackForwardCache.cpp 2022-06-30 04:49:32.659515900 -0500
+++ webkitgtk-2.36.7/Source/WebCore/history/BackForwardCache.cpp 2022-08-26 14:18:14.957022207 -0500
@@ -135,6 +135,10 @@ static bool canCacheFrame(Frame& frame,
logBackForwardCacheFailureDiagnosticMessage(diagnosticLoggingClient, DiagnosticLoggingKeys::isErrorPageKey());
isCacheable = false;
}
+ if (frameLoader.subframeLoader().containsPlugins() && !frame.page()->settings().backForwardCacheSupportsPlugins()) {
+ PCLOG(" -Frame contains plugins");
+ isCacheable = false;
+ }
if (frame.isMainFrame() && frame.document() && frame.document()->url().protocolIs("https") && documentLoader->response().cacheControlContainsNoStore()) {
PCLOG(" -Frame is HTTPS, and cache control prohibits storing");
logBackForwardCacheFailureDiagnosticMessage(diagnosticLoggingClient, DiagnosticLoggingKeys::httpsNoStoreKey());
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/html/HTMLObjectElement.cpp webkitgtk-2.36.7/Source/WebCore/html/HTMLObjectElement.cpp
--- webkitgtk-2.36.7.orig/Source/WebCore/html/HTMLObjectElement.cpp 2022-06-30 04:49:32.746182400 -0500
+++ webkitgtk-2.36.7/Source/WebCore/html/HTMLObjectElement.cpp 2022-08-26 14:18:14.957022207 -0500
@@ -460,6 +460,23 @@ void HTMLObjectElement::didMoveToNewDocu
HTMLPlugInImageElement::didMoveToNewDocument(oldDocument, newDocument);
}
+bool HTMLObjectElement::appendFormData(DOMFormData& formData)
+{
+ if (name().isEmpty())
+ return false;
+
+ // Use PluginLoadingPolicy::DoNotLoad here or it would fire JS events synchronously
+ // which would not be safe here.
+ RefPtr widget = pluginWidget(PluginLoadingPolicy::DoNotLoad);
+ if (!is<PluginViewBase>(widget))
+ return false;
+ String value;
+ if (!downcast<PluginViewBase>(*widget).getFormValue(value))
+ return false;
+ formData.append(name(), value);
+ return true;
+}
+
bool HTMLObjectElement::canContainRangeEndPoint() const
{
// Call through to HTMLElement because HTMLPlugInElement::canContainRangeEndPoint
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/html/HTMLObjectElement.h webkitgtk-2.36.7/Source/WebCore/html/HTMLObjectElement.h
--- webkitgtk-2.36.7.orig/Source/WebCore/html/HTMLObjectElement.h 2022-06-30 04:49:32.746182400 -0500
+++ webkitgtk-2.36.7/Source/WebCore/html/HTMLObjectElement.h 2022-08-26 14:18:14.957022207 -0500
@@ -99,6 +99,7 @@ private:
bool isFormControlElement() const final { return false; }
bool isEnumeratable() const final { return true; }
+ bool appendFormData(DOMFormData&) final;
bool canContainRangeEndPoint() const final;
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/html/HTMLPlugInElement.cpp webkitgtk-2.36.7/Source/WebCore/html/HTMLPlugInElement.cpp
--- webkitgtk-2.36.7.orig/Source/WebCore/html/HTMLPlugInElement.cpp 2022-06-30 04:49:32.749515800 -0500
+++ webkitgtk-2.36.7/Source/WebCore/html/HTMLPlugInElement.cpp 2022-08-26 14:18:14.957022207 -0500
@@ -49,6 +49,10 @@
#include "Widget.h"
#include <wtf/IsoMallocInlines.h>
+#if ENABLE(NETSCAPE_PLUGIN_API)
+#include "npruntime_impl.h"
+#endif
+
namespace WebCore {
WTF_MAKE_ISO_ALLOCATED_IMPL(HTMLPlugInElement);
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/page/Frame.cpp webkitgtk-2.36.7/Source/WebCore/page/Frame.cpp
--- webkitgtk-2.36.7.orig/Source/WebCore/page/Frame.cpp 2022-06-30 04:49:33.469515300 -0500
+++ webkitgtk-2.36.7/Source/WebCore/page/Frame.cpp 2022-08-26 14:18:14.961022229 -0500
@@ -102,6 +102,7 @@
#include "UserTypingGestureIndicator.h"
#include "VisibleUnits.h"
#include "markup.h"
+#include "npruntime_impl.h"
#include "runtime_root.h"
#include <JavaScriptCore/APICast.h>
#include <JavaScriptCore/RegularExpression.h>
@@ -1114,7 +1115,7 @@ TextStream& operator<<(TextStream& ts, c
return ts;
}
-bool Frame::arePluginsEnabled()
+bool Frame::arePluginsEnabled() const
{
return settings().arePluginsEnabled();
}
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/page/Frame.h webkitgtk-2.36.7/Source/WebCore/page/Frame.h
--- webkitgtk-2.36.7.orig/Source/WebCore/page/Frame.h 2022-06-30 04:49:33.469515300 -0500
+++ webkitgtk-2.36.7/Source/WebCore/page/Frame.h 2022-08-26 14:18:14.961022229 -0500
@@ -302,7 +302,7 @@ public:
void selfOnlyRef();
void selfOnlyDeref();
- WEBCORE_EXPORT bool arePluginsEnabled();
+ WEBCORE_EXPORT bool arePluginsEnabled() const;
private:
friend class NavigationDisabler;
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/page/Page.cpp webkitgtk-2.36.7/Source/WebCore/page/Page.cpp
--- webkitgtk-2.36.7.orig/Source/WebCore/page/Page.cpp 2022-08-23 05:34:51.180085400 -0500
+++ webkitgtk-2.36.7/Source/WebCore/page/Page.cpp 2022-08-26 14:18:14.965022251 -0500
@@ -3113,6 +3113,12 @@ void Page::setSessionID(PAL::SessionID s
forEachDocument([&] (Document& document) {
document.privateBrowsingStateDidChange(m_sessionID);
});
+
+ // Collect the PluginViews in to a vector to ensure that action the plug-in takes
+ // from below privateBrowsingStateChanged does not affect their lifetime.
+
+ for (auto& view : pluginViews())
+ view->privateBrowsingStateChanged(sessionID.isEphemeral());
}
#if ENABLE(WIRELESS_PLAYBACK_TARGET)
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/page/RuntimeEnabledFeatures.h webkitgtk-2.36.7/Source/WebCore/page/RuntimeEnabledFeatures.h
--- webkitgtk-2.36.7.orig/Source/WebCore/page/RuntimeEnabledFeatures.h 2022-06-30 04:49:33.526182000 -0500
+++ webkitgtk-2.36.7/Source/WebCore/page/RuntimeEnabledFeatures.h 2022-08-26 14:18:14.965022251 -0500
@@ -101,6 +101,9 @@ public:
void setServerTimingEnabled(bool isEnabled) { m_isServerTimingEnabled = isEnabled; }
bool serverTimingEnabled() const { return m_isServerTimingEnabled; }
+ void setExperimentalPlugInSandboxProfilesEnabled(bool isEnabled) { m_experimentalPlugInSandboxProfilesEnabled = isEnabled; }
+ bool experimentalPlugInSandboxProfilesEnabled() const { return m_experimentalPlugInSandboxProfilesEnabled; }
+
void setAttrStyleEnabled(bool isEnabled) { m_attrStyleEnabled = isEnabled; }
bool attrStyleEnabled() const { return m_attrStyleEnabled; }
@@ -290,6 +293,7 @@ private:
bool m_itpDebugMode { false };
bool m_isRestrictedHTTPResponseAccess { true };
bool m_isServerTimingEnabled { false };
+ bool m_experimentalPlugInSandboxProfilesEnabled { false };
bool m_attrStyleEnabled { false };
bool m_webAPIStatisticsEnabled { false };
bool m_syntheticEditingCommandsEnabled { true };
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/platform/Curl.cmake webkitgtk-2.36.7/Source/WebCore/platform/Curl.cmake
--- webkitgtk-2.36.7.orig/Source/WebCore/platform/Curl.cmake 2022-06-30 04:49:33.662848500 -0500
+++ webkitgtk-2.36.7/Source/WebCore/platform/Curl.cmake 2022-08-26 14:18:14.965022251 -0500
@@ -27,6 +27,7 @@ list(APPEND WebCore_SOURCES
platform/network/curl/NetworkStorageSessionCurl.cpp
platform/network/curl/OpenSSLHelper.cpp
platform/network/curl/ProtectionSpaceCurl.cpp
+ platform/network/curl/ProxyServerCurl.cpp
platform/network/curl/PublicSuffixCurl.cpp
platform/network/curl/ResourceErrorCurl.cpp
platform/network/curl/ResourceHandleCurl.cpp
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/platform/network/cf/ProxyServerCFNet.cpp webkitgtk-2.36.7/Source/WebCore/platform/network/cf/ProxyServerCFNet.cpp
--- webkitgtk-2.36.7.orig/Source/WebCore/platform/network/cf/ProxyServerCFNet.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/platform/network/cf/ProxyServerCFNet.cpp 2022-08-26 14:18:14.965022251 -0500
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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 "config.h"
+#include "ProxyServer.h"
+
+#include <wtf/URL.h>
+#include "Logging.h"
+#include <wtf/RetainPtr.h>
+#include <wtf/cf/TypeCastsCF.h>
+#include <wtf/text/CString.h>
+
+#if PLATFORM(IOS_FAMILY) || PLATFORM(WIN)
+#include <CFNetwork/CFNetwork.h>
+#endif
+
+namespace WebCore {
+
+static void processProxyServers(Vector<ProxyServer>& proxyServers, CFArrayRef proxies, CFURLRef url);
+
+static void proxyAutoConfigurationResultCallback(void *context, CFArrayRef proxies, CFErrorRef error)
+{
+ // We only expect a single result callback per invocation. Stop our runloop to unblock our caller.
+ CFRunLoopStop(CFRunLoopGetCurrent());
+
+ Vector<ProxyServer>* proxyServers = (Vector<ProxyServer>*)context;
+ if (!proxies) {
+ ASSERT(error);
+ RetainPtr<CFStringRef> errorDescriptionCF = adoptCF(CFErrorCopyDescription(error));
+ String errorDescription(errorDescriptionCF.get());
+ LOG(Network, "Failed to process proxy auto-configuration file with error: %s", errorDescription.utf8().data());
+ return;
+ }
+
+ processProxyServers(*proxyServers, proxies, 0);
+}
+
+static void processProxyServers(Vector<ProxyServer>& proxyServers, CFArrayRef proxies, CFURLRef url)
+{
+ CFIndex numProxies = CFArrayGetCount(proxies);
+ for (CFIndex i = 0; i < numProxies; ++i) {
+ CFDictionaryRef proxyDictionary = static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(proxies, i));
+
+ ProxyServer::Type type = ProxyServer::Direct;
+ CFStringRef typeString = static_cast<CFStringRef>(CFDictionaryGetValue(proxyDictionary, kCFProxyTypeKey));
+
+ if (!url) {
+ // If we have no URL then we're processing an auto-configuration response.
+ // It isn't sensible to receive another auto-configured proxy in such a response.
+ ASSERT(!CFEqual(typeString, kCFProxyTypeAutoConfigurationURL));
+ }
+
+ if (CFEqual(typeString, kCFProxyTypeAutoConfigurationURL)) {
+ if (!url)
+ continue;
+
+ // FIXME: We should restructure to allow this to happen asynchronously.
+ auto scriptURL = dynamic_cf_cast<CFURLRef>(CFDictionaryGetValue(proxyDictionary, kCFProxyAutoConfigurationURLKey));
+ if (!scriptURL)
+ continue;
+
+ CFStreamClientContext context = { 0, (void*)&proxyServers, 0, 0, 0 };
+ RetainPtr<CFRunLoopSourceRef> runLoopSource = adoptCF(CFNetworkExecuteProxyAutoConfigurationURL(scriptURL, url, proxyAutoConfigurationResultCallback, &context));
+
+ CFStringRef privateRunLoopMode = CFSTR("com.apple.WebKit.ProxyAutoConfiguration");
+ CFTimeInterval timeout = 5;
+ CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource.get(), privateRunLoopMode);
+ CFRunLoopRunInMode(privateRunLoopMode, timeout, 0);
+ CFRunLoopRemoveSource(CFRunLoopGetCurrent(), runLoopSource.get(), privateRunLoopMode);
+ CFRunLoopSourceInvalidate(runLoopSource.get());
+
+ // The proxyAutoConfigurationResultCallback has added any relevant ProxyServers to proxyServers.
+ continue;
+ }
+
+ if (CFEqual(typeString, kCFProxyTypeNone)) {
+ proxyServers.append(ProxyServer(ProxyServer::Direct, String(), -1));
+ continue;
+ }
+
+ if (CFEqual(typeString, kCFProxyTypeHTTP))
+ type = ProxyServer::HTTP;
+ else if (CFEqual(typeString, kCFProxyTypeHTTPS))
+ type = ProxyServer::HTTPS;
+ else if (CFEqual(typeString, kCFProxyTypeSOCKS))
+ type = ProxyServer::SOCKS;
+ else {
+ // We don't know how to handle this type.
+ continue;
+ }
+
+ CFStringRef host = static_cast<CFStringRef>(CFDictionaryGetValue(proxyDictionary, kCFProxyHostNameKey));
+ CFNumberRef port = static_cast<CFNumberRef>(CFDictionaryGetValue(proxyDictionary, kCFProxyPortNumberKey));
+ SInt32 portValue;
+ CFNumberGetValue(port, kCFNumberSInt32Type, &portValue);
+
+ proxyServers.append(ProxyServer(type, host, portValue));
+ }
+}
+
+static void addProxyServersForURL(Vector<ProxyServer>& proxyServers, const URL& url)
+{
+ RetainPtr<CFDictionaryRef> proxySettings = adoptCF(CFNetworkCopySystemProxySettings());
+ if (!proxySettings)
+ return;
+
+ RetainPtr<CFURLRef> cfURL = url.createCFURL();
+ RetainPtr<CFArrayRef> proxiesForURL = adoptCF(CFNetworkCopyProxiesForURL(cfURL.get(), proxySettings.get()));
+ if (!proxiesForURL)
+ return;
+
+ processProxyServers(proxyServers, proxiesForURL.get(), cfURL.get());
+}
+
+Vector<ProxyServer> proxyServersForURL(const URL& url)
+{
+ Vector<ProxyServer> proxyServers;
+
+ addProxyServersForURL(proxyServers, url);
+ return proxyServers;
+
+}
+
+} // namespace WebCore
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/platform/network/curl/ProxyServerCurl.cpp webkitgtk-2.36.7/Source/WebCore/platform/network/curl/ProxyServerCurl.cpp
--- webkitgtk-2.36.7.orig/Source/WebCore/platform/network/curl/ProxyServerCurl.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/platform/network/curl/ProxyServerCurl.cpp 2022-08-26 14:18:14.965022251 -0500
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2010 Brent Fulgham <bfulgham@webkit.org>. 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 INC. 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 INC. 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 "config.h"
+#include "ProxyServer.h"
+
+#if USE(CURL)
+
+#include <wtf/URL.h>
+
+namespace WebCore {
+
+Vector<ProxyServer> proxyServersForURL(const URL&)
+{
+ // FIXME: Implement.
+ return Vector<ProxyServer>();
+}
+
+} // namespace WebCore
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/platform/network/ProxyServer.cpp webkitgtk-2.36.7/Source/WebCore/platform/network/ProxyServer.cpp
--- webkitgtk-2.36.7.orig/Source/WebCore/platform/network/ProxyServer.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/platform/network/ProxyServer.cpp 2022-08-26 14:18:14.965022251 -0500
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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 "config.h"
+#include "ProxyServer.h"
+
+#include <wtf/text/StringBuilder.h>
+
+namespace WebCore {
+
+static void appendProxyServerString(StringBuilder& builder, const ProxyServer& proxyServer)
+{
+ ASSERT(!proxyServer.hostName().isNull());
+ ASSERT(proxyServer.port() != -1);
+
+ switch (proxyServer.type()) {
+ case ProxyServer::Direct:
+ builder.append("DIRECT");
+ break;
+ case ProxyServer::HTTP:
+ case ProxyServer::HTTPS:
+ builder.append("PROXY ", proxyServer.hostName(), ':', proxyServer.port());
+ break;
+ case ProxyServer::SOCKS:
+ builder.append("SOCKS ", proxyServer.hostName(), ':', proxyServer.port());
+ break;
+ }
+}
+
+String toString(const Vector<ProxyServer>& proxyServers)
+{
+ if (proxyServers.isEmpty())
+ return "DIRECT";
+
+ StringBuilder stringBuilder;
+ for (size_t i = 0; i < proxyServers.size(); ++i) {
+ if (i)
+ stringBuilder.append("; ");
+ appendProxyServerString(stringBuilder, proxyServers[i]);
+ }
+ return stringBuilder.toString();
+}
+
+} // namespace WebCore
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/platform/network/ProxyServer.h webkitgtk-2.36.7/Source/WebCore/platform/network/ProxyServer.h
--- webkitgtk-2.36.7.orig/Source/WebCore/platform/network/ProxyServer.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/platform/network/ProxyServer.h 2022-08-26 14:18:14.965022251 -0500
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+ */
+
+#pragma once
+
+#include <wtf/Vector.h>
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+
+class NetworkingContext;
+
+// Represents a single proxy server.
+class ProxyServer {
+public:
+ enum Type {
+ Direct,
+ HTTP,
+ HTTPS,
+ SOCKS,
+ };
+
+ ProxyServer()
+ : m_type(Direct)
+ , m_port(-1)
+ {
+ }
+
+ ProxyServer(Type type, const String& hostName, int port)
+ : m_type(type)
+ , m_hostName(hostName)
+ , m_port(port)
+ {
+ }
+
+ Type type() const { return m_type; }
+ const String& hostName() const { return m_hostName; }
+ int port() const { return m_port; }
+
+private:
+ Type m_type;
+ String m_hostName;
+ int m_port;
+};
+
+// Return a vector of proxy servers for the given URL.
+WEBCORE_EXPORT Vector<ProxyServer> proxyServersForURL(const URL&);
+
+// Converts the given vector of proxy servers to a PAC string, as described in
+// http://web.archive.org/web/20060424005037/wp.netscape.com/eng/mozilla/2.0/relnotes/demo/proxy-live.html
+WEBCORE_EXPORT String toString(const Vector<ProxyServer>&);
+
+} // namespace WebCore
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/platform/network/soup/ProxyServerSoup.cpp webkitgtk-2.36.7/Source/WebCore/platform/network/soup/ProxyServerSoup.cpp
--- webkitgtk-2.36.7.orig/Source/WebCore/platform/network/soup/ProxyServerSoup.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/platform/network/soup/ProxyServerSoup.cpp 2022-08-26 14:18:14.965022251 -0500
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2010 Brent Fulgham <bfulgham@webkit.org>. 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 INC. 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 INC. 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 "config.h"
+#include "ProxyServer.h"
+
+#if USE(SOUP)
+
+#include <wtf/URL.h>
+
+namespace WebCore {
+
+Vector<ProxyServer> proxyServersForURL(const URL&)
+{
+ // FIXME: Implement.
+ return Vector<ProxyServer>();
+}
+
+} // namespace WebCore
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/platform/SourcesSoup.txt webkitgtk-2.36.7/Source/WebCore/platform/SourcesSoup.txt
--- webkitgtk-2.36.7.orig/Source/WebCore/platform/SourcesSoup.txt 2022-08-08 06:13:37.339459400 -0500
+++ webkitgtk-2.36.7/Source/WebCore/platform/SourcesSoup.txt 2022-08-26 14:18:14.965022251 -0500
@@ -28,6 +28,7 @@ platform/network/soup/CookieStorageSoup.
platform/network/soup/CredentialSoup.cpp
platform/network/soup/CredentialStorageSoup.cpp
platform/network/soup/NetworkStorageSessionSoup.cpp
+platform/network/soup/ProxyServerSoup.cpp
platform/network/soup/ResourceErrorSoup.cpp
platform/network/soup/ResourceHandleSoup.cpp
platform/network/soup/ResourceRequestSoup.cpp
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/plugins/npapi.h webkitgtk-2.36.7/Source/WebCore/plugins/npapi.h
--- webkitgtk-2.36.7.orig/Source/WebCore/plugins/npapi.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/plugins/npapi.h 2022-08-26 14:18:14.969022271 -0500
@@ -0,0 +1,869 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1998
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#ifndef npapi_h_
+#define npapi_h_
+
+#if defined(__OS2__)
+#pragma pack(1)
+#endif
+
+#include "nptypes.h"
+
+#if defined(__OS2__) || defined(OS2)
+#ifndef XP_OS2
+#define XP_OS2 1
+#endif
+#endif
+
+#ifdef INCLUDE_JAVA
+#include "jri.h" /* Java Runtime Interface */
+#else
+#define jref void *
+#define JRIEnv void
+#endif
+
+#ifdef _WIN32
+#include <windows.h>
+#ifndef XP_WIN
+#define XP_WIN 1
+#endif
+#endif
+
+#if defined(__APPLE_CC__) && !defined(XP_UNIX)
+#ifndef XP_MACOSX
+#define XP_MACOSX 1
+#endif
+#endif
+
+#if defined(XP_MACOSX) && defined(__LP64__)
+#define NP_NO_QUICKDRAW
+#define NP_NO_CARBON
+#endif
+
+#if defined(XP_MACOSX)
+#include <CoreGraphics/CoreGraphics.h>
+#include <OpenGL/OpenGL.h>
+#ifndef NP_NO_CARBON
+#include <Carbon/Carbon.h>
+#endif
+#endif
+
+#if defined(XP_UNIX)
+#include <stdio.h>
+#if defined(MOZ_X11)
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#endif
+#endif
+
+/*----------------------------------------------------------------------*/
+/* Plugin Version Constants */
+/*----------------------------------------------------------------------*/
+
+#define NP_VERSION_MAJOR 0
+#define NP_VERSION_MINOR 26
+
+
+/* The OS/2 version of Netscape uses RC_DATA to define the
+ mime types, file extensions, etc that are required.
+ Use a vertical bar to separate types, end types with \0.
+ FileVersion and ProductVersion are 32bit ints, all other
+ entries are strings that MUST be terminated with a \0.
+
+AN EXAMPLE:
+
+RCDATA NP_INFO_ProductVersion { 1,0,0,1,}
+
+RCDATA NP_INFO_MIMEType { "video/x-video|",
+ "video/x-flick\0" }
+RCDATA NP_INFO_FileExtents { "avi|",
+ "flc\0" }
+RCDATA NP_INFO_FileOpenName{ "MMOS2 video player(*.avi)|",
+ "MMOS2 Flc/Fli player(*.flc)\0" }
+
+RCDATA NP_INFO_FileVersion { 1,0,0,1 }
+RCDATA NP_INFO_CompanyName { "Netscape Communications\0" }
+RCDATA NP_INFO_FileDescription { "NPAVI32 Extension DLL\0"
+RCDATA NP_INFO_InternalName { "NPAVI32\0" )
+RCDATA NP_INFO_LegalCopyright { "Copyright Netscape Communications \251 1996\0"
+RCDATA NP_INFO_OriginalFilename { "NVAPI32.DLL" }
+RCDATA NP_INFO_ProductName { "NPAVI32 Dynamic Link Library\0" }
+*/
+/* RC_DATA types for version info - required */
+#define NP_INFO_ProductVersion 1
+#define NP_INFO_MIMEType 2
+#define NP_INFO_FileOpenName 3
+#define NP_INFO_FileExtents 4
+/* RC_DATA types for version info - used if found */
+#define NP_INFO_FileDescription 5
+#define NP_INFO_ProductName 6
+/* RC_DATA types for version info - optional */
+#define NP_INFO_CompanyName 7
+#define NP_INFO_FileVersion 8
+#define NP_INFO_InternalName 9
+#define NP_INFO_LegalCopyright 10
+#define NP_INFO_OriginalFilename 11
+
+#ifndef RC_INVOKED
+
+/*----------------------------------------------------------------------*/
+/* Definition of Basic Types */
+/*----------------------------------------------------------------------*/
+
+#ifndef FALSE
+#define FALSE (0)
+#endif
+#ifndef TRUE
+#define TRUE (1)
+#endif
+#ifndef NULL
+#define NULL (0L)
+#endif
+
+typedef unsigned char NPBool;
+typedef int16_t NPError;
+typedef int16_t NPReason;
+typedef char* NPMIMEType;
+
+/*----------------------------------------------------------------------*/
+/* Structures and definitions */
+/*----------------------------------------------------------------------*/
+
+#if !defined(__LP64__)
+#if defined(XP_MACOSX)
+#pragma options align=mac68k
+#endif
+#endif /* __LP64__ */
+
+/*
+ * NPP is a plug-in's opaque instance handle
+ */
+typedef struct _NPP
+{
+ void* pdata; /* plug-in private data */
+ void* ndata; /* netscape private data */
+} NPP_t;
+
+typedef NPP_t* NPP;
+
+typedef struct _NPStream
+{
+ void* pdata; /* plug-in private data */
+ void* ndata; /* netscape private data */
+ const char* url;
+ uint32_t end;
+ uint32_t lastmodified;
+ void* notifyData;
+ const char* headers; /* Response headers from host.
+ * Exists only for >= NPVERS_HAS_RESPONSE_HEADERS.
+ * Used for HTTP only; NULL for non-HTTP.
+ * Available from NPP_NewStream onwards.
+ * Plugin should copy this data before storing it.
+ * Includes HTTP status line and all headers,
+ * preferably verbatim as received from server,
+ * headers formatted as in HTTP ("Header: Value"),
+ * and newlines (\n, NOT \r\n) separating lines.
+ * Terminated by \n\0 (NOT \n\n\0). */
+} NPStream;
+
+typedef struct _NPByteRange
+{
+ int32_t offset; /* negative offset means from the end */
+ uint32_t length;
+ struct _NPByteRange* next;
+} NPByteRange;
+
+typedef struct _NPSavedData
+{
+ int32_t len;
+ void* buf;
+} NPSavedData;
+
+typedef struct _NPRect
+{
+ uint16_t top;
+ uint16_t left;
+ uint16_t bottom;
+ uint16_t right;
+} NPRect;
+
+typedef struct _NPSize
+{
+ int32_t width;
+ int32_t height;
+} NPSize;
+
+typedef enum {
+ NPFocusNext = 0,
+ NPFocusPrevious = 1
+} NPFocusDirection;
+
+/* Return values for NPP_HandleEvent */
+#define kNPEventNotHandled 0
+#define kNPEventHandled 1
+/* Exact meaning must be spec'd in event model. */
+#define kNPEventStartIME 2
+
+#if defined(XP_UNIX)
+/*
+ * Unix specific structures and definitions
+ */
+
+/*
+ * Callback Structures.
+ *
+ * These are used to pass additional platform specific information.
+ */
+enum {
+ NP_SETWINDOW = 1,
+ NP_PRINT
+};
+
+typedef struct
+{
+ int32_t type;
+} NPAnyCallbackStruct;
+
+typedef struct
+{
+ int32_t type;
+#if defined(MOZ_X11)
+ Display* display;
+ Visual* visual;
+ Colormap colormap;
+ unsigned int depth;
+#endif
+} NPSetWindowCallbackStruct;
+
+typedef struct
+{
+ int32_t type;
+ FILE* fp;
+} NPPrintCallbackStruct;
+
+#endif /* XP_UNIX */
+
+#if defined(XP_MACOSX)
+typedef enum {
+#ifndef NP_NO_QUICKDRAW
+ NPDrawingModelQuickDraw = 0,
+#endif
+ NPDrawingModelCoreGraphics = 1,
+ NPDrawingModelOpenGL = 2, // Note: This is not supported.
+ NPDrawingModelCoreAnimation = 3
+} NPDrawingModel;
+
+typedef enum {
+#ifndef NP_NO_CARBON
+ NPEventModelCarbon = 0,
+#endif
+ NPEventModelCocoa = 1
+} NPEventModel;
+#endif
+
+/*
+ * The following masks are applied on certain platforms to NPNV and
+ * NPPV selectors that pass around pointers to COM interfaces. Newer
+ * compilers on some platforms may generate vtables that are not
+ * compatible with older compilers. To prevent older plugins from
+ * not understanding a new browser's ABI, these masks change the
+ * values of those selectors on those platforms. To remain backwards
+ * compatible with different versions of the browser, plugins can
+ * use these masks to dynamically determine and use the correct C++
+ * ABI that the browser is expecting. This does not apply to Windows
+ * as Microsoft's COM ABI will likely not change.
+ */
+
+#define NP_ABI_GCC3_MASK 0x10000000
+/*
+ * gcc 3.x generated vtables on UNIX and OSX are incompatible with
+ * previous compilers.
+ */
+#if (defined(XP_UNIX) && defined(__GNUC__) && (__GNUC__ >= 3))
+#define _NP_ABI_MIXIN_FOR_GCC3 NP_ABI_GCC3_MASK
+#else
+#define _NP_ABI_MIXIN_FOR_GCC3 0
+#endif
+
+#if defined(XP_MACOSX)
+#define NP_ABI_MACHO_MASK 0x01000000
+#define _NP_ABI_MIXIN_FOR_MACHO NP_ABI_MACHO_MASK
+#else
+#define _NP_ABI_MIXIN_FOR_MACHO 0
+#endif
+
+#define NP_ABI_MASK (_NP_ABI_MIXIN_FOR_GCC3 | _NP_ABI_MIXIN_FOR_MACHO)
+
+/*
+ * List of variable names for which NPP_GetValue shall be implemented
+ */
+typedef enum {
+ NPPVpluginNameString = 1,
+ NPPVpluginDescriptionString,
+ NPPVpluginWindowBool,
+ NPPVpluginTransparentBool,
+ NPPVjavaClass, /* Not implemented in WebKit */
+ NPPVpluginWindowSize, /* Not implemented in WebKit */
+ NPPVpluginTimerInterval, /* Not implemented in WebKit */
+ NPPVpluginScriptableInstance = (10 | NP_ABI_MASK), /* Not implemented in WebKit */
+ NPPVpluginScriptableIID = 11, /* Not implemented in WebKit */
+ NPPVjavascriptPushCallerBool = 12, /* Not implemented in WebKit */
+ NPPVpluginKeepLibraryInMemory = 13, /* Not implemented in WebKit */
+ NPPVpluginNeedsXEmbed = 14, /* Not implemented in WebKit */
+
+ /* Get the NPObject for scripting the plugin. Introduced in NPAPI minor version 14.
+ */
+ NPPVpluginScriptableNPObject = 15,
+
+ /* Get the plugin value (as \0-terminated UTF-8 string data) for
+ * form submission if the plugin is part of a form. Use
+ * NPN_MemAlloc() to allocate memory for the string data. Introduced
+ * in NPAPI minor version 15.
+ */
+ NPPVformValue = 16, /* Not implemented in WebKit */
+
+ NPPVpluginUrlRequestsDisplayedBool = 17, /* Not implemented in WebKit */
+
+ /* Checks if the plugin is interested in receiving the http body of
+ * all http requests (including failed ones, http status != 200).
+ */
+ NPPVpluginWantsAllNetworkStreams = 18,
+
+ /* Browsers can retrieve a native ATK accessibility plug ID via this variable. */
+ NPPVpluginNativeAccessibleAtkPlugId = 19,
+
+ /* Checks to see if the plug-in would like the browser to load the "src" attribute. */
+ NPPVpluginCancelSrcStream = 20
+
+#if defined(XP_MACOSX)
+ /* Used for negotiating drawing models */
+ , NPPVpluginDrawingModel = 1000
+ /* Used for negotiating event models */
+ , NPPVpluginEventModel = 1001
+ /* In the NPDrawingModelCoreAnimation drawing model, the browser asks the plug-in for a Core Animation layer. */
+ , NPPVpluginCoreAnimationLayer = 1003
+#endif
+
+ /* Used for figuring out whether a plug-in is playing audio. */
+ , NPPVpluginIsPlayingAudio = 4000
+
+} NPPVariable;
+
+/*
+ * List of variable names for which NPN_GetValue should be implemented.
+ */
+typedef enum {
+ NPNVxDisplay = 1,
+ NPNVxtAppContext,
+ NPNVnetscapeWindow,
+ NPNVjavascriptEnabledBool,
+ NPNVasdEnabledBool,
+ NPNVisOfflineBool,
+
+ NPNVserviceManager = (10 | NP_ABI_MASK), /* Not implemented in WebKit */
+ NPNVDOMElement = (11 | NP_ABI_MASK), /* Not implemented in WebKit */
+ NPNVDOMWindow = (12 | NP_ABI_MASK), /* Not implemented in WebKit */
+ NPNVToolkit = (13 | NP_ABI_MASK), /* Not implemented in WebKit */
+ NPNVSupportsXEmbedBool = 14, /* Not implemented in WebKit */
+
+ /* Get the NPObject wrapper for the browser window. */
+ NPNVWindowNPObject = 15,
+
+ /* Get the NPObject wrapper for the plugins DOM element. */
+ NPNVPluginElementNPObject = 16,
+
+ NPNVSupportsWindowless = 17,
+
+ NPNVprivateModeBool = 18,
+
+ NPNVsupportsAdvancedKeyHandling = 21
+
+#if defined(XP_MACOSX)
+ /* Used for negotiating drawing models */
+ , NPNVpluginDrawingModel = 1000
+ , NPNVcontentsScaleFactor = 1001
+#ifndef NP_NO_QUICKDRAW
+ , NPNVsupportsQuickDrawBool = 2000
+#endif
+ , NPNVsupportsCoreGraphicsBool = 2001
+ , NPNVsupportsOpenGLBool = 2002
+ , NPNVsupportsCoreAnimationBool = 2003
+#ifndef NP_NO_CARBON
+ , NPNVsupportsCarbonBool = 3000 /* TRUE if the browser supports the Carbon event model */
+#endif
+ , NPNVsupportsCocoaBool = 3001 /* TRUE if the browser supports the Cocoa event model */
+ , NPNVsupportsUpdatedCocoaTextInputBool = 3002 /* TRUE if the browser supports the updated
+ Cocoa text input specification. */
+ , NPNVsupportsCompositingCoreAnimationPluginsBool = 74656 /* TRUE if the browser supports
+ CA model compositing */
+#endif /* XP_MACOSX */
+
+ , NPNVmuteAudioBool = 4000
+
+} NPNVariable;
+
+typedef enum {
+ NPNURLVCookie = 501,
+ NPNURLVProxy
+} NPNURLVariable;
+
+/*
+ * The type of Toolkit the widgets use
+ */
+typedef enum {
+ NPNVGtk12 = 1,
+ NPNVGtk2
+} NPNToolkitType;
+
+/*
+ * The type of a NPWindow - it specifies the type of the data structure
+ * returned in the window field.
+ */
+typedef enum {
+ NPWindowTypeWindow = 1,
+ NPWindowTypeDrawable
+} NPWindowType;
+
+typedef struct _NPWindow
+{
+ void* window; /* Platform specific window handle */
+ /* OS/2: x - Position of bottom left corner */
+ /* OS/2: y - relative to visible netscape window */
+ int32_t x; /* Position of top left corner relative */
+ int32_t y; /* to a netscape page. */
+ uint32_t width; /* Maximum window size */
+ uint32_t height;
+ NPRect clipRect; /* Clipping rectangle in port coordinates */
+#if defined(XP_UNIX)
+ void * ws_info; /* Platform-dependent additonal data */
+#endif /* XP_UNIX */
+ NPWindowType type; /* Is this a window or a drawable? */
+} NPWindow;
+
+typedef struct _NPFullPrint
+{
+ NPBool pluginPrinted;/* Set TRUE if plugin handled fullscreen printing */
+ NPBool printOne; /* TRUE if plugin should print one copy to default
+ printer */
+ void* platformPrint; /* Platform-specific printing info */
+} NPFullPrint;
+
+typedef struct _NPEmbedPrint
+{
+ NPWindow window;
+ void* platformPrint; /* Platform-specific printing info */
+} NPEmbedPrint;
+
+typedef struct _NPPrint
+{
+ uint16_t mode; /* NP_FULL or NP_EMBED */
+ union
+ {
+ NPFullPrint fullPrint; /* if mode is NP_FULL */
+ NPEmbedPrint embedPrint; /* if mode is NP_EMBED */
+ } print;
+} NPPrint;
+
+#if defined(XP_MACOSX)
+#ifndef NP_NO_CARBON
+typedef EventRecord NPEvent;
+#else
+typedef void* NPEvent;
+#endif
+#elif defined(XP_WIN)
+typedef struct _NPEvent
+{
+ uint16_t event;
+ uintptr_t wParam;
+ uintptr_t lParam;
+} NPEvent;
+#elif defined(XP_OS2)
+typedef struct _NPEvent
+{
+ uint32_t event;
+ uint32_t wParam;
+ uint32_t lParam;
+} NPEvent;
+#elif defined(XP_UNIX) && defined(MOZ_X11)
+typedef XEvent NPEvent;
+#else
+typedef void* NPEvent;
+#endif
+
+#if defined(XP_MACOSX)
+typedef void* NPRegion;
+#ifndef NP_NO_QUICKDRAW
+typedef RgnHandle NPQDRegion;
+#endif
+typedef CGPathRef NPCGRegion;
+#elif defined(XP_WIN)
+typedef HRGN NPRegion;
+#elif defined(XP_UNIX) && defined(MOZ_X11)
+typedef Region NPRegion;
+#else
+typedef void *NPRegion;
+#endif
+
+typedef struct _NPNSString NPNSString;
+typedef struct _NPNSWindow NPNSWindow;
+typedef struct _NPNSMenu NPNSMenu;
+
+#if defined(XP_MACOSX)
+typedef NPNSMenu NPMenu;
+#else
+typedef void *NPMenu;
+#endif
+
+typedef enum {
+ NPCoordinateSpacePlugin = 1,
+ NPCoordinateSpaceWindow,
+ NPCoordinateSpaceFlippedWindow,
+ NPCoordinateSpaceScreen,
+ NPCoordinateSpaceFlippedScreen
+} NPCoordinateSpace;
+
+#if defined(XP_MACOSX)
+
+#ifndef NP_NO_QUICKDRAW
+typedef struct NP_Port
+{
+ CGrafPtr port;
+ int32_t portx; /* position inside the topmost window */
+ int32_t porty;
+} NP_Port;
+#endif /* NP_NO_QUICKDRAW */
+
+/*
+ * NP_CGContext is the type of the NPWindow's 'window' when the plugin specifies NPDrawingModelCoreGraphics
+ * as its drawing model.
+ */
+
+typedef struct NP_CGContext
+{
+ CGContextRef context;
+#ifdef NP_NO_CARBON
+ NPNSWindow *window;
+#else
+ void *window; /* A WindowRef or NULL for the Cocoa event model. */
+#endif
+} NP_CGContext;
+
+typedef enum {
+ NPCocoaEventDrawRect = 1,
+ NPCocoaEventMouseDown,
+ NPCocoaEventMouseUp,
+ NPCocoaEventMouseMoved,
+ NPCocoaEventMouseEntered,
+ NPCocoaEventMouseExited,
+ NPCocoaEventMouseDragged,
+ NPCocoaEventKeyDown,
+ NPCocoaEventKeyUp,
+ NPCocoaEventFlagsChanged,
+ NPCocoaEventFocusChanged,
+ NPCocoaEventWindowFocusChanged,
+ NPCocoaEventScrollWheel,
+ NPCocoaEventTextInput
+} NPCocoaEventType;
+
+typedef struct _NPCocoaEvent {
+ NPCocoaEventType type;
+ uint32_t version;
+ union {
+ struct {
+ uint32_t modifierFlags;
+ double pluginX;
+ double pluginY;
+ int32_t buttonNumber;
+ int32_t clickCount;
+ double deltaX;
+ double deltaY;
+ double deltaZ;
+ } mouse;
+ struct {
+ uint32_t modifierFlags;
+ NPNSString *characters;
+ NPNSString *charactersIgnoringModifiers;
+ NPBool isARepeat;
+ uint16_t keyCode;
+ } key;
+ struct {
+ CGContextRef context;
+ double x;
+ double y;
+ double width;
+ double height;
+ } draw;
+ struct {
+ NPBool hasFocus;
+ } focus;
+ struct {
+ NPNSString *text;
+ } text;
+ } data;
+} NPCocoaEvent;
+
+#ifndef NP_NO_CARBON
+/* Non-standard event types that can be passed to HandleEvent */
+enum NPEventType {
+ NPEventType_GetFocusEvent = (osEvt + 16),
+ NPEventType_LoseFocusEvent,
+ NPEventType_AdjustCursorEvent,
+ NPEventType_MenuCommandEvent,
+ NPEventType_ClippingChangedEvent,
+ NPEventType_ScrollingBeginsEvent = 1000,
+ NPEventType_ScrollingEndsEvent
+};
+#endif /* NP_NO_CARBON */
+
+#endif /* XP_MACOSX */
+
+/*
+ * Values for mode passed to NPP_New:
+ */
+#define NP_EMBED 1
+#define NP_FULL 2
+
+/*
+ * Values for stream type passed to NPP_NewStream:
+ */
+#define NP_NORMAL 1
+#define NP_SEEK 2
+#define NP_ASFILE 3
+#define NP_ASFILEONLY 4
+
+#define NP_MAXREADY (((unsigned)(~0)<<1)>>1)
+
+/*
+ * Flags for NPP_ClearSiteData.
+ */
+#define NP_CLEAR_ALL 0
+#define NP_CLEAR_CACHE (1 << 0)
+
+#if !defined(__LP64__)
+#if defined(XP_MACOSX)
+#pragma options align=reset
+#endif
+#endif /* __LP64__ */
+
+/*----------------------------------------------------------------------*/
+/* Error and Reason Code definitions */
+/*----------------------------------------------------------------------*/
+
+/*
+ * Values of type NPError:
+ */
+#define NPERR_BASE 0
+#define NPERR_NO_ERROR (NPERR_BASE + 0)
+#define NPERR_GENERIC_ERROR (NPERR_BASE + 1)
+#define NPERR_INVALID_INSTANCE_ERROR (NPERR_BASE + 2)
+#define NPERR_INVALID_FUNCTABLE_ERROR (NPERR_BASE + 3)
+#define NPERR_MODULE_LOAD_FAILED_ERROR (NPERR_BASE + 4)
+#define NPERR_OUT_OF_MEMORY_ERROR (NPERR_BASE + 5)
+#define NPERR_INVALID_PLUGIN_ERROR (NPERR_BASE + 6)
+#define NPERR_INVALID_PLUGIN_DIR_ERROR (NPERR_BASE + 7)
+#define NPERR_INCOMPATIBLE_VERSION_ERROR (NPERR_BASE + 8)
+#define NPERR_INVALID_PARAM (NPERR_BASE + 9)
+#define NPERR_INVALID_URL (NPERR_BASE + 10)
+#define NPERR_FILE_NOT_FOUND (NPERR_BASE + 11)
+#define NPERR_NO_DATA (NPERR_BASE + 12)
+#define NPERR_STREAM_NOT_SEEKABLE (NPERR_BASE + 13)
+
+/*
+ * Values of type NPReason:
+ */
+#define NPRES_BASE 0
+#define NPRES_DONE (NPRES_BASE + 0)
+#define NPRES_NETWORK_ERR (NPRES_BASE + 1)
+#define NPRES_USER_BREAK (NPRES_BASE + 2)
+
+/*
+ * Don't use these obsolete error codes any more.
+ */
+#define NP_NOERR NP_NOERR_is_obsolete_use_NPERR_NO_ERROR
+#define NP_EINVAL NP_EINVAL_is_obsolete_use_NPERR_GENERIC_ERROR
+#define NP_EABORT NP_EABORT_is_obsolete_use_NPRES_USER_BREAK
+
+/*
+ * Version feature information
+ */
+#define NPVERS_HAS_STREAMOUTPUT 8
+#define NPVERS_HAS_NOTIFICATION 9
+#define NPVERS_HAS_LIVECONNECT 9
+#define NPVERS_WIN16_HAS_LIVECONNECT 9
+#define NPVERS_68K_HAS_LIVECONNECT 11
+#define NPVERS_HAS_WINDOWLESS 11
+#define NPVERS_HAS_XPCONNECT_SCRIPTING 13 /* Not implemented in WebKit */
+#define NPVERS_HAS_NPRUNTIME_SCRIPTING 14
+#define NPVERS_HAS_FORM_VALUES 15 /* Not implemented in WebKit; see bug 13061 */
+#define NPVERS_HAS_POPUPS_ENABLED_STATE 16 /* Not implemented in WebKit */
+#define NPVERS_HAS_RESPONSE_HEADERS 17
+#define NPVERS_HAS_NPOBJECT_ENUM 18
+#define NPVERS_HAS_PLUGIN_THREAD_ASYNC_CALL 19
+#define NPVERS_HAS_ALL_NETWORK_STREAMS 20
+#define NPVERS_HAS_URL_AND_AUTH_INFO 21
+#define NPVERS_HAS_PRIVATE_MODE 22
+#define NPVERS_MACOSX_HAS_EVENT_MODELS 23
+#define NPVERS_HAS_CANCEL_SRC_STREAM 24
+#define NPVERS_HAS_ADVANCED_KEY_HANDLING 25
+#define NPVERS_HAS_URL_REDIRECT_HANDLING 26
+#define NPVERS_HAS_CLEAR_SITE_DATA 27
+
+/*----------------------------------------------------------------------*/
+/* Function Prototypes */
+/*----------------------------------------------------------------------*/
+
+#if defined(__OS2__)
+#define NP_LOADDS _System
+#else
+#define NP_LOADDS
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* NPP_* functions are provided by the plugin and called by the navigator. */
+
+#if defined(XP_UNIX)
+const char* NPP_GetMIMEDescription(void);
+#endif
+
+NPError NP_LOADDS NPP_Initialize(void);
+void NP_LOADDS NPP_Shutdown(void);
+NPError NP_LOADDS NPP_New(NPMIMEType pluginType, NPP instance,
+ uint16_t mode, int16_t argc, char* argn[],
+ char* argv[], NPSavedData* saved);
+NPError NP_LOADDS NPP_Destroy(NPP instance, NPSavedData** save);
+NPError NP_LOADDS NPP_SetWindow(NPP instance, NPWindow* window);
+NPError NP_LOADDS NPP_NewStream(NPP instance, NPMIMEType type,
+ NPStream* stream, NPBool seekable,
+ uint16_t* stype);
+NPError NP_LOADDS NPP_DestroyStream(NPP instance, NPStream* stream,
+ NPReason reason);
+int32_t NP_LOADDS NPP_WriteReady(NPP instance, NPStream* stream);
+int32_t NP_LOADDS NPP_Write(NPP instance, NPStream* stream, int32_t offset,
+ int32_t len, void* buffer);
+void NP_LOADDS NPP_StreamAsFile(NPP instance, NPStream* stream,
+ const char* fname);
+void NP_LOADDS NPP_Print(NPP instance, NPPrint* platformPrint);
+int16_t NP_LOADDS NPP_HandleEvent(NPP instance, void* event);
+void NP_LOADDS NPP_URLNotify(NPP instance, const char* url,
+ NPReason reason, void* notifyData);
+jref NP_LOADDS NPP_GetJavaClass(void);
+NPError NP_LOADDS NPP_GetValue(NPP instance, NPPVariable variable, void *value);
+NPError NP_LOADDS NPP_SetValue(NPP instance, NPNVariable variable, void *value);
+NPBool NP_LOADDS NPP_GotFocus(NPP instance, NPFocusDirection direction);
+void NP_LOADDS NPP_LostFocus(NPP instance);
+void NP_LOADDS NPP_URLRedirectNotify(NPP instance, const char* url, int32_t status, void* notifyData);
+NPError NP_LOADDS NPP_ClearSiteData(const char* site, uint64_t flags, uint64_t maxAge);
+char** NP_LOADDS NPP_GetSitesWithData(void);
+
+/* NPN_* functions are provided by the navigator and called by the plugin. */
+void NP_LOADDS NPN_Version(int* plugin_major, int* plugin_minor,
+ int* netscape_major, int* netscape_minor);
+NPError NP_LOADDS NPN_GetURLNotify(NPP instance, const char* url,
+ const char* target, void* notifyData);
+NPError NP_LOADDS NPN_GetURL(NPP instance, const char* url,
+ const char* target);
+NPError NP_LOADDS NPN_PostURLNotify(NPP instance, const char* url,
+ const char* target, uint32_t len,
+ const char* buf, NPBool file,
+ void* notifyData);
+NPError NP_LOADDS NPN_PostURL(NPP instance, const char* url,
+ const char* target, uint32_t len,
+ const char* buf, NPBool file);
+NPError NP_LOADDS NPN_RequestRead(NPStream* stream, NPByteRange* rangeList);
+NPError NP_LOADDS NPN_NewStream(NPP instance, NPMIMEType type,
+ const char* target, NPStream** stream);
+int32_t NP_LOADDS NPN_Write(NPP instance, NPStream* stream, int32_t len,
+ void* buffer);
+NPError NP_LOADDS NPN_DestroyStream(NPP instance, NPStream* stream,
+ NPReason reason);
+void NP_LOADDS NPN_Status(NPP instance, const char* message);
+const char* NP_LOADDS NPN_UserAgent(NPP instance);
+void* NP_LOADDS NPN_MemAlloc(uint32_t size);
+void NP_LOADDS NPN_MemFree(void* ptr);
+uint32_t NP_LOADDS NPN_MemFlush(uint32_t size);
+void NP_LOADDS NPN_ReloadPlugins(NPBool reloadPages);
+JRIEnv* NP_LOADDS NPN_GetJavaEnv(void);
+jref NP_LOADDS NPN_GetJavaPeer(NPP instance);
+NPError NP_LOADDS NPN_GetValue(NPP instance, NPNVariable variable,
+ void *value);
+NPError NP_LOADDS NPN_SetValue(NPP instance, NPPVariable variable,
+ void *value);
+void NP_LOADDS NPN_InvalidateRect(NPP instance, NPRect *invalidRect);
+void NP_LOADDS NPN_InvalidateRegion(NPP instance,
+ NPRegion invalidRegion);
+void NP_LOADDS NPN_ForceRedraw(NPP instance);
+void NP_LOADDS NPN_PushPopupsEnabledState(NPP instance, NPBool enabled);
+void NP_LOADDS NPN_PopPopupsEnabledState(NPP instance);
+void NP_LOADDS NPN_PluginThreadAsyncCall(NPP instance,
+ void (*func) (void *),
+ void *userData);
+NPError NP_LOADDS NPN_GetValueForURL(NPP instance, NPNURLVariable variable,
+ const char *url, char **value,
+ uint32_t *len);
+NPError NP_LOADDS NPN_SetValueForURL(NPP instance, NPNURLVariable variable,
+ const char *url, const char *value,
+ uint32_t len);
+NPError NP_LOADDS NPN_GetAuthenticationInfo(NPP instance,
+ const char *protocol,
+ const char *host, int32_t port,
+ const char *scheme,
+ const char *realm,
+ char **username, uint32_t *ulen,
+ char **password,
+ uint32_t *plen);
+uint32_t NP_LOADDS NPN_ScheduleTimer(NPP instance, uint32_t interval, NPBool repeat, void (*timerFunc)(NPP npp, uint32_t timerID));
+void NP_LOADDS NPN_UnscheduleTimer(NPP instance, uint32_t timerID);
+NPError NP_LOADDS NPN_PopUpContextMenu(NPP instance, NPMenu* menu);
+NPBool NP_LOADDS NPN_ConvertPoint(NPP instance, double sourceX, double sourceY, NPCoordinateSpace sourceSpace, double *destX, double *destY, NPCoordinateSpace destSpace);
+NPBool NP_LOADDS NPN_HandleEvent(NPP instance, void *event, NPBool handled);
+NPBool NP_LOADDS NPN_UnfocusInstance(NPP instance, NPFocusDirection direction);
+void NP_LOADDS NPN_URLRedirectResponse(NPP instance, void* notifyData, NPBool allow);
+
+#ifdef __cplusplus
+} /* end extern "C" */
+#endif
+
+#endif /* RC_INVOKED */
+#if defined(__OS2__)
+#pragma pack()
+#endif
+
+#endif /* npapi_h_ */
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/plugins/npfunctions.h webkitgtk-2.36.7/Source/WebCore/plugins/npfunctions.h
--- webkitgtk-2.36.7.orig/Source/WebCore/plugins/npfunctions.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/plugins/npfunctions.h 2022-08-26 14:18:14.969022271 -0500
@@ -0,0 +1,229 @@
+/*
+ * Copyright (C) 2007 Apple 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 INC. ``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 INC. OR
+ * 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.
+ */
+#ifndef NPFUNCTIONS_H
+#define NPFUNCTIONS_H
+
+
+#include "npruntime.h"
+#include "npapi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(XP_WIN)
+#define EXPORTED_CALLBACK(_type, _name) _type (__stdcall * _name)
+#else
+#define EXPORTED_CALLBACK(_type, _name) _type (* _name)
+#endif
+
+typedef NPError (*NPN_GetURLNotifyProcPtr)(NPP instance, const char* URL, const char* window, void* notifyData);
+typedef NPError (*NPN_PostURLNotifyProcPtr)(NPP instance, const char* URL, const char* window, uint32_t len, const char* buf, NPBool file, void* notifyData);
+typedef NPError (*NPN_RequestReadProcPtr)(NPStream* stream, NPByteRange* rangeList);
+typedef NPError (*NPN_NewStreamProcPtr)(NPP instance, NPMIMEType type, const char* window, NPStream** stream);
+typedef int32_t (*NPN_WriteProcPtr)(NPP instance, NPStream* stream, int32_t len, void* buffer);
+typedef NPError (*NPN_DestroyStreamProcPtr)(NPP instance, NPStream* stream, NPReason reason);
+typedef void (*NPN_StatusProcPtr)(NPP instance, const char* message);
+typedef const char*(*NPN_UserAgentProcPtr)(NPP instance);
+typedef void* (*NPN_MemAllocProcPtr)(uint32_t size);
+typedef void (*NPN_MemFreeProcPtr)(void* ptr);
+typedef uint32_t (*NPN_MemFlushProcPtr)(uint32_t size);
+typedef void (*NPN_ReloadPluginsProcPtr)(NPBool reloadPages);
+typedef NPError (*NPN_GetValueProcPtr)(NPP instance, NPNVariable variable, void *ret_value);
+typedef NPError (*NPN_SetValueProcPtr)(NPP instance, NPPVariable variable, void *value);
+typedef void (*NPN_InvalidateRectProcPtr)(NPP instance, NPRect *rect);
+typedef void (*NPN_InvalidateRegionProcPtr)(NPP instance, NPRegion region);
+typedef void (*NPN_ForceRedrawProcPtr)(NPP instance);
+typedef NPError (*NPN_GetURLProcPtr)(NPP instance, const char* URL, const char* window);
+typedef NPError (*NPN_PostURLProcPtr)(NPP instance, const char* URL, const char* window, uint32_t len, const char* buf, NPBool file);
+typedef void* (*NPN_GetJavaEnvProcPtr)(void);
+typedef void* (*NPN_GetJavaPeerProcPtr)(NPP instance);
+typedef void (*NPN_PushPopupsEnabledStateProcPtr)(NPP instance, NPBool enabled);
+typedef void (*NPN_PopPopupsEnabledStateProcPtr)(NPP instance);
+typedef void (*NPN_PluginThreadAsyncCallProcPtr)(NPP npp, void (*func)(void *), void *userData);
+typedef NPError (*NPN_GetValueForURLProcPtr)(NPP npp, NPNURLVariable variable, const char* url, char** value, uint32_t* len);
+typedef NPError (*NPN_SetValueForURLProcPtr)(NPP npp, NPNURLVariable variable, const char* url, const char* value, uint32_t len);
+typedef NPError (*NPN_GetAuthenticationInfoProcPtr)(NPP npp, const char* protocol, const char* host, int32_t port, const char* scheme, const char *realm, char** username, uint32_t* ulen, char** password, uint32_t* plen);
+
+typedef uint32_t (*NPN_ScheduleTimerProcPtr)(NPP npp, uint32_t interval, NPBool repeat, void (*timerFunc)(NPP npp, uint32_t timerID));
+typedef void (*NPN_UnscheduleTimerProcPtr)(NPP npp, uint32_t timerID);
+typedef NPError (*NPN_PopUpContextMenuProcPtr)(NPP instance, NPMenu* menu);
+typedef NPBool (*NPN_ConvertPointProcPtr)(NPP npp, double sourceX, double sourceY, NPCoordinateSpace sourceSpace, double *destX, double *destY, NPCoordinateSpace destSpace);
+typedef NPBool (*NPN_HandleEventPtr)(NPP instance, void *event, NPBool handled);
+typedef NPBool (*NPN_UnfocusInstancePtr)(NPP instance, NPFocusDirection direction);
+typedef void (*NPN_URLRedirectResponsePtr)(NPP instance, void* notifyData, NPBool allow);
+
+typedef void (*NPN_ReleaseVariantValueProcPtr) (NPVariant *variant);
+
+typedef NPIdentifier (*NPN_GetStringIdentifierProcPtr) (const NPUTF8 *name);
+typedef void (*NPN_GetStringIdentifiersProcPtr) (const NPUTF8 **names, int32_t nameCount, NPIdentifier *identifiers);
+typedef NPIdentifier (*NPN_GetIntIdentifierProcPtr) (int32_t intid);
+typedef int32_t (*NPN_IntFromIdentifierProcPtr) (NPIdentifier identifier);
+typedef bool (*NPN_IdentifierIsStringProcPtr) (NPIdentifier identifier);
+typedef NPUTF8 *(*NPN_UTF8FromIdentifierProcPtr) (NPIdentifier identifier);
+
+typedef NPObject* (*NPN_CreateObjectProcPtr) (NPP, NPClass *aClass);
+typedef NPObject* (*NPN_RetainObjectProcPtr) (NPObject *obj);
+typedef void (*NPN_ReleaseObjectProcPtr) (NPObject *obj);
+typedef bool (*NPN_InvokeProcPtr) (NPP npp, NPObject *obj, NPIdentifier methodName, const NPVariant *args, unsigned argCount, NPVariant *result);
+typedef bool (*NPN_InvokeDefaultProcPtr) (NPP npp, NPObject *obj, const NPVariant *args, unsigned argCount, NPVariant *result);
+typedef bool (*NPN_EvaluateProcPtr) (NPP npp, NPObject *obj, NPString *script, NPVariant *result);
+typedef bool (*NPN_GetPropertyProcPtr) (NPP npp, NPObject *obj, NPIdentifier propertyName, NPVariant *result);
+typedef bool (*NPN_SetPropertyProcPtr) (NPP npp, NPObject *obj, NPIdentifier propertyName, const NPVariant *value);
+typedef bool (*NPN_HasPropertyProcPtr) (NPP, NPObject *npobj, NPIdentifier propertyName);
+typedef bool (*NPN_HasMethodProcPtr) (NPP npp, NPObject *npobj, NPIdentifier methodName);
+typedef bool (*NPN_RemovePropertyProcPtr) (NPP npp, NPObject *obj, NPIdentifier propertyName);
+typedef void (*NPN_SetExceptionProcPtr) (NPObject *obj, const NPUTF8 *message);
+typedef bool (*NPN_EnumerateProcPtr) (NPP npp, NPObject *npobj, NPIdentifier **identifier, uint32_t *count);
+typedef bool (*NPN_ConstructProcPtr)(NPP npp, NPObject* obj, const NPVariant *args, uint32_t argCount, NPVariant *result);
+
+typedef NPError (*NPP_NewProcPtr)(NPMIMEType pluginType, NPP instance, uint16_t mode, int16_t argc, char* argn[], char* argv[], NPSavedData* saved);
+typedef NPError (*NPP_DestroyProcPtr)(NPP instance, NPSavedData** save);
+typedef NPError (*NPP_SetWindowProcPtr)(NPP instance, NPWindow* window);
+typedef NPError (*NPP_NewStreamProcPtr)(NPP instance, NPMIMEType type, NPStream* stream, NPBool seekable, uint16_t* stype);
+typedef NPError (*NPP_DestroyStreamProcPtr)(NPP instance, NPStream* stream, NPReason reason);
+typedef void (*NPP_StreamAsFileProcPtr)(NPP instance, NPStream* stream, const char* fname);
+typedef int32_t (*NPP_WriteReadyProcPtr)(NPP instance, NPStream* stream);
+typedef int32_t (*NPP_WriteProcPtr)(NPP instance, NPStream* stream, int32_t offset, int32_t len, void* buffer);
+typedef void (*NPP_PrintProcPtr)(NPP instance, NPPrint* platformPrint);
+typedef int16_t (*NPP_HandleEventProcPtr)(NPP instance, void* event);
+typedef void (*NPP_URLNotifyProcPtr)(NPP instance, const char* URL, NPReason reason, void* notifyData);
+typedef NPError (*NPP_GetValueProcPtr)(NPP instance, NPPVariable variable, void *ret_value);
+typedef NPError (*NPP_SetValueProcPtr)(NPP instance, NPNVariable variable, void *value);
+typedef NPBool (*NPP_GotFocusPtr)(NPP instance, NPFocusDirection direction);
+typedef void (*NPP_LostFocusPtr)(NPP instance);
+typedef void (*NPP_URLRedirectNotifyPtr)(NPP instance, const char* url, int32_t status, void* notifyData);
+typedef NPError (*NPP_ClearSiteDataPtr)(const char* site, uint64_t flags, uint64_t maxAge);
+typedef char** (*NPP_GetSitesWithDataPtr)(void);
+
+typedef void *(*NPP_GetJavaClassProcPtr)(void);
+typedef void* JRIGlobalRef; //not using this right now
+
+typedef struct _NPNetscapeFuncs {
+ uint16_t size;
+ uint16_t version;
+
+ NPN_GetURLProcPtr geturl;
+ NPN_PostURLProcPtr posturl;
+ NPN_RequestReadProcPtr requestread;
+ NPN_NewStreamProcPtr newstream;
+ NPN_WriteProcPtr write;
+ NPN_DestroyStreamProcPtr destroystream;
+ NPN_StatusProcPtr status;
+ NPN_UserAgentProcPtr uagent;
+ NPN_MemAllocProcPtr memalloc;
+ NPN_MemFreeProcPtr memfree;
+ NPN_MemFlushProcPtr memflush;
+ NPN_ReloadPluginsProcPtr reloadplugins;
+ NPN_GetJavaEnvProcPtr getJavaEnv;
+ NPN_GetJavaPeerProcPtr getJavaPeer;
+ NPN_GetURLNotifyProcPtr geturlnotify;
+ NPN_PostURLNotifyProcPtr posturlnotify;
+ NPN_GetValueProcPtr getvalue;
+ NPN_SetValueProcPtr setvalue;
+ NPN_InvalidateRectProcPtr invalidaterect;
+ NPN_InvalidateRegionProcPtr invalidateregion;
+ NPN_ForceRedrawProcPtr forceredraw;
+
+ NPN_GetStringIdentifierProcPtr getstringidentifier;
+ NPN_GetStringIdentifiersProcPtr getstringidentifiers;
+ NPN_GetIntIdentifierProcPtr getintidentifier;
+ NPN_IdentifierIsStringProcPtr identifierisstring;
+ NPN_UTF8FromIdentifierProcPtr utf8fromidentifier;
+ NPN_IntFromIdentifierProcPtr intfromidentifier;
+ NPN_CreateObjectProcPtr createobject;
+ NPN_RetainObjectProcPtr retainobject;
+ NPN_ReleaseObjectProcPtr releaseobject;
+ NPN_InvokeProcPtr invoke;
+ NPN_InvokeDefaultProcPtr invokeDefault;
+ NPN_EvaluateProcPtr evaluate;
+ NPN_GetPropertyProcPtr getproperty;
+ NPN_SetPropertyProcPtr setproperty;
+ NPN_RemovePropertyProcPtr removeproperty;
+ NPN_HasPropertyProcPtr hasproperty;
+ NPN_HasMethodProcPtr hasmethod;
+ NPN_ReleaseVariantValueProcPtr releasevariantvalue;
+ NPN_SetExceptionProcPtr setexception;
+ NPN_PushPopupsEnabledStateProcPtr pushpopupsenabledstate;
+ NPN_PopPopupsEnabledStateProcPtr poppopupsenabledstate;
+ NPN_EnumerateProcPtr enumerate;
+ NPN_PluginThreadAsyncCallProcPtr pluginthreadasynccall;
+ NPN_ConstructProcPtr construct;
+ NPN_GetValueForURLProcPtr getvalueforurl;
+ NPN_SetValueForURLProcPtr setvalueforurl;
+ NPN_GetAuthenticationInfoProcPtr getauthenticationinfo;
+ NPN_ScheduleTimerProcPtr scheduletimer;
+ NPN_UnscheduleTimerProcPtr unscheduletimer;
+ NPN_PopUpContextMenuProcPtr popupcontextmenu;
+ NPN_ConvertPointProcPtr convertpoint;
+ NPN_HandleEventPtr handleevent;
+ NPN_UnfocusInstancePtr unfocusinstance;
+ NPN_URLRedirectResponsePtr urlredirectresponse;
+} NPNetscapeFuncs;
+
+typedef struct _NPPluginFuncs {
+ uint16_t size;
+ uint16_t version;
+ NPP_NewProcPtr newp;
+ NPP_DestroyProcPtr destroy;
+ NPP_SetWindowProcPtr setwindow;
+ NPP_NewStreamProcPtr newstream;
+ NPP_DestroyStreamProcPtr destroystream;
+ NPP_StreamAsFileProcPtr asfile;
+ NPP_WriteReadyProcPtr writeready;
+ NPP_WriteProcPtr write;
+ NPP_PrintProcPtr print;
+ NPP_HandleEventProcPtr event;
+ NPP_URLNotifyProcPtr urlnotify;
+ JRIGlobalRef javaClass;
+ NPP_GetValueProcPtr getvalue;
+ NPP_SetValueProcPtr setvalue;
+ NPP_GotFocusPtr gotfocus;
+ NPP_LostFocusPtr lostfocus;
+ NPP_URLRedirectNotifyPtr urlredirectnotify;
+ NPP_ClearSiteDataPtr clearsitedata;
+ NPP_GetSitesWithDataPtr getsiteswithdata;
+} NPPluginFuncs;
+
+typedef EXPORTED_CALLBACK(NPError, NP_GetEntryPointsFuncPtr)(NPPluginFuncs*);
+typedef EXPORTED_CALLBACK(void, NPP_ShutdownProcPtr)(void);
+
+#if defined(XP_MACOSX)
+typedef void (*BP_CreatePluginMIMETypesPreferencesFuncPtr)(void);
+typedef NPError (*MainFuncPtr)(NPNetscapeFuncs*, NPPluginFuncs*, NPP_ShutdownProcPtr*);
+#endif
+
+#if defined(XP_UNIX)
+typedef EXPORTED_CALLBACK(NPError, NP_InitializeFuncPtr)(NPNetscapeFuncs*, NPPluginFuncs*);
+typedef EXPORTED_CALLBACK(const char*, NP_GetMIMEDescriptionFuncPtr)(void);
+#else
+typedef EXPORTED_CALLBACK(NPError, NP_InitializeFuncPtr)(NPNetscapeFuncs*);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/plugins/npruntime.h webkitgtk-2.36.7/Source/WebCore/plugins/npruntime.h
--- webkitgtk-2.36.7.orig/Source/WebCore/plugins/npruntime.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/plugins/npruntime.h 2022-08-26 14:18:14.969022271 -0500
@@ -0,0 +1,393 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Copyright (c) 2004, Apple Inc. and The Mozilla Foundation.
+ * 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.
+ * 3. Neither the names of Apple Inc. ("Apple") or The Mozilla
+ * Foundation ("Mozilla") nor the names of their contributors may be used
+ * to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE, MOZILLA AND THEIR 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, MOZILLA OR
+ * THEIR 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.
+ *
+ */
+#ifndef _NP_RUNTIME_H_
+#define _NP_RUNTIME_H_
+
+#include "npapi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ This API is used to facilitate binding code written in C to script
+ objects. The API in this header does not assume the presence of a
+ user agent. That is, it can be used to bind C code to scripting
+ environments outside of the context of a user agent.
+
+ However, the normal use of the this API is in the context of a
+ scripting environment running in a browser or other user agent.
+ In particular it is used to support the extended Netscape
+ script-ability API for plugins (NP-SAP). NP-SAP is an extension
+ of the Netscape plugin API. As such we have adopted the use of
+ the "NP" prefix for this API.
+
+ The following NP{N|P}Variables were added to the Netscape plugin
+ API (in npapi.h):
+
+ NPNVWindowNPObject
+ NPNVPluginElementNPObject
+ NPPVpluginScriptableNPObject
+
+ These variables are exposed through NPN_GetValue() and
+ NPP_GetValue() (respectively) and are used to establish the
+ initial binding between the user agent and native code. The DOM
+ objects in the user agent can be examined and manipulated using
+ the NPN_ functions that operate on NPObjects described in this
+ header.
+
+ To the extent possible the assumptions about the scripting
+ language used by the scripting environment have been minimized.
+*/
+
+#define NP_BEGIN_MACRO do {
+#define NP_END_MACRO } while (0)
+
+/*
+ Objects (non-primitive data) passed between 'C' and script is
+ always wrapped in an NPObject. The 'interface' of an NPObject is
+ described by an NPClass.
+*/
+typedef struct NPObject NPObject;
+typedef struct NPClass NPClass;
+
+typedef char NPUTF8;
+typedef struct _NPString {
+ const NPUTF8 *UTF8Characters;
+ uint32_t UTF8Length;
+} NPString;
+
+typedef enum {
+ NPVariantType_Void,
+ NPVariantType_Null,
+ NPVariantType_Bool,
+ NPVariantType_Int32,
+ NPVariantType_Double,
+ NPVariantType_String,
+ NPVariantType_Object
+} NPVariantType;
+
+typedef struct _NPVariant {
+ NPVariantType type;
+ union {
+ bool boolValue;
+ int32_t intValue;
+ double doubleValue;
+ NPString stringValue;
+ NPObject *objectValue;
+ } value;
+} NPVariant;
+
+/*
+ NPN_ReleaseVariantValue is called on all 'out' parameters
+ references. Specifically it is to be called on variants that own
+ their value, as is the case with all non-const NPVariant*
+ arguments after a successful call to any methods (except this one)
+ in this API.
+
+ After calling NPN_ReleaseVariantValue, the type of the variant
+ will be NPVariantType_Void.
+*/
+void NPN_ReleaseVariantValue(NPVariant *variant);
+
+#define NPVARIANT_IS_VOID(_v) ((_v).type == NPVariantType_Void)
+#define NPVARIANT_IS_NULL(_v) ((_v).type == NPVariantType_Null)
+#define NPVARIANT_IS_BOOLEAN(_v) ((_v).type == NPVariantType_Bool)
+#define NPVARIANT_IS_INT32(_v) ((_v).type == NPVariantType_Int32)
+#define NPVARIANT_IS_DOUBLE(_v) ((_v).type == NPVariantType_Double)
+#define NPVARIANT_IS_STRING(_v) ((_v).type == NPVariantType_String)
+#define NPVARIANT_IS_OBJECT(_v) ((_v).type == NPVariantType_Object)
+
+#define NPVARIANT_TO_BOOLEAN(_v) ((_v).value.boolValue)
+#define NPVARIANT_TO_INT32(_v) ((_v).value.intValue)
+#define NPVARIANT_TO_DOUBLE(_v) ((_v).value.doubleValue)
+#define NPVARIANT_TO_STRING(_v) ((_v).value.stringValue)
+#define NPVARIANT_TO_OBJECT(_v) ((_v).value.objectValue)
+
+#define VOID_TO_NPVARIANT(_v) \
+NP_BEGIN_MACRO \
+ (_v).type = NPVariantType_Void; \
+ (_v).value.objectValue = NULL; \
+NP_END_MACRO
+
+#define NULL_TO_NPVARIANT(_v) \
+NP_BEGIN_MACRO \
+ (_v).type = NPVariantType_Null; \
+ (_v).value.objectValue = NULL; \
+NP_END_MACRO
+
+#define BOOLEAN_TO_NPVARIANT(_val, _v) \
+NP_BEGIN_MACRO \
+ (_v).type = NPVariantType_Bool; \
+ (_v).value.boolValue = !!(_val); \
+NP_END_MACRO
+
+#define INT32_TO_NPVARIANT(_val, _v) \
+NP_BEGIN_MACRO \
+ (_v).type = NPVariantType_Int32; \
+ (_v).value.intValue = _val; \
+NP_END_MACRO
+
+#define DOUBLE_TO_NPVARIANT(_val, _v) \
+NP_BEGIN_MACRO \
+ (_v).type = NPVariantType_Double; \
+ (_v).value.doubleValue = _val; \
+NP_END_MACRO
+
+#define STRINGZ_TO_NPVARIANT(_val, _v) \
+NP_BEGIN_MACRO \
+ (_v).type = NPVariantType_String; \
+ NPString str = { _val, uint32_t(strlen(_val)) }; \
+ (_v).value.stringValue = str; \
+NP_END_MACRO
+
+#define STRINGN_TO_NPVARIANT(_val, _len, _v) \
+NP_BEGIN_MACRO \
+ (_v).type = NPVariantType_String; \
+ NPString str = { _val, uint32_t(_len) }; \
+ (_v).value.stringValue = str; \
+NP_END_MACRO
+
+#define OBJECT_TO_NPVARIANT(_val, _v) \
+NP_BEGIN_MACRO \
+ (_v).type = NPVariantType_Object; \
+ (_v).value.objectValue = _val; \
+NP_END_MACRO
+
+
+/*
+ Type mappings (JavaScript types have been used for illustration
+ purposes):
+
+ JavaScript to C (NPVariant with type:)
+ undefined NPVariantType_Void
+ null NPVariantType_Null
+ Boolean NPVariantType_Bool
+ Number NPVariantType_Double or NPVariantType_Int32
+ String NPVariantType_String
+ Object NPVariantType_Object
+
+ C (NPVariant with type:) to JavaScript
+ NPVariantType_Void undefined
+ NPVariantType_Null null
+ NPVariantType_Bool Boolean
+ NPVariantType_Int32 Number
+ NPVariantType_Double Number
+ NPVariantType_String String
+ NPVariantType_Object Object
+*/
+
+typedef void *NPIdentifier;
+
+/*
+ NPObjects have methods and properties. Methods and properties are
+ identified with NPIdentifiers. These identifiers may be reflected
+ in script. NPIdentifiers can be either strings or integers, IOW,
+ methods and properties can be identified by either strings or
+ integers (i.e. foo["bar"] vs foo[1]). NPIdentifiers can be
+ compared using ==. In case of any errors, the requested
+ NPIdentifier(s) will be NULL. NPIdentifier lifetime is controlled
+ by the browser. Plugins do not need to worry about memory management
+ with regards to NPIdentifiers.
+*/
+NPIdentifier NPN_GetStringIdentifier(const NPUTF8 *name);
+void NPN_GetStringIdentifiers(const NPUTF8 **names, int32_t nameCount,
+ NPIdentifier *identifiers);
+NPIdentifier NPN_GetIntIdentifier(int32_t intid);
+bool NPN_IdentifierIsString(NPIdentifier identifier);
+
+/*
+ The NPUTF8 returned from NPN_UTF8FromIdentifier SHOULD be freed.
+*/
+NPUTF8 *NPN_UTF8FromIdentifier(NPIdentifier identifier);
+
+/*
+ Get the integer represented by identifier. If identifier is not an
+ integer identifier, the behaviour is undefined.
+*/
+int32_t NPN_IntFromIdentifier(NPIdentifier identifier);
+
+/*
+ NPObject behavior is implemented using the following set of
+ callback functions.
+
+ The NPVariant *result argument of these functions (where
+ applicable) should be released using NPN_ReleaseVariantValue().
+*/
+typedef NPObject *(*NPAllocateFunctionPtr)(NPP npp, NPClass *aClass);
+typedef void (*NPDeallocateFunctionPtr)(NPObject *npobj);
+typedef void (*NPInvalidateFunctionPtr)(NPObject *npobj);
+typedef bool (*NPHasMethodFunctionPtr)(NPObject *npobj, NPIdentifier name);
+typedef bool (*NPInvokeFunctionPtr)(NPObject *npobj, NPIdentifier name,
+ const NPVariant *args, uint32_t argCount,
+ NPVariant *result);
+typedef bool (*NPInvokeDefaultFunctionPtr)(NPObject *npobj,
+ const NPVariant *args,
+ uint32_t argCount,
+ NPVariant *result);
+typedef bool (*NPHasPropertyFunctionPtr)(NPObject *npobj, NPIdentifier name);
+typedef bool (*NPGetPropertyFunctionPtr)(NPObject *npobj, NPIdentifier name,
+ NPVariant *result);
+typedef bool (*NPSetPropertyFunctionPtr)(NPObject *npobj, NPIdentifier name,
+ const NPVariant *value);
+typedef bool (*NPRemovePropertyFunctionPtr)(NPObject *npobj,
+ NPIdentifier name);
+typedef bool (*NPEnumerationFunctionPtr)(NPObject *npobj, NPIdentifier **value,
+ uint32_t *count);
+typedef bool (*NPConstructFunctionPtr)(NPObject *npobj,
+ const NPVariant *args,
+ uint32_t argCount,
+ NPVariant *result);
+
+/*
+ NPObjects returned by create, retain, invoke, and getProperty pass
+ a reference count to the caller. That is, the callee adds a
+ reference count which passes to the caller. It is the caller's
+ responsibility to release the returned object.
+
+ NPInvokeFunctionPtr function may return 0 to indicate a void
+ result.
+
+ NPInvalidateFunctionPtr is called by the scripting environment
+ when the native code is shutdown. Any attempt to message a
+ NPObject instance after the invalidate callback has been
+ called will result in undefined behavior, even if the native code
+ is still retaining those NPObject instances. (The runtime
+ will typically return immediately, with 0 or NULL, from an attempt
+ to dispatch to a NPObject, but this behavior should not be
+ depended upon.)
+
+ The NPEnumerationFunctionPtr function may pass an array of
+ NPIdentifiers back to the caller. The callee allocs the memory of
+ the array using NPN_MemAlloc(), and it's the caller's responsibility
+ to release it using NPN_MemFree().
+*/
+struct NPClass
+{
+ uint32_t structVersion;
+ NPAllocateFunctionPtr allocate;
+ NPDeallocateFunctionPtr deallocate;
+ NPInvalidateFunctionPtr invalidate;
+ NPHasMethodFunctionPtr hasMethod;
+ NPInvokeFunctionPtr invoke;
+ NPInvokeDefaultFunctionPtr invokeDefault;
+ NPHasPropertyFunctionPtr hasProperty;
+ NPGetPropertyFunctionPtr getProperty;
+ NPSetPropertyFunctionPtr setProperty;
+ NPRemovePropertyFunctionPtr removeProperty;
+ NPEnumerationFunctionPtr enumerate;
+ NPConstructFunctionPtr construct;
+};
+
+#define NP_CLASS_STRUCT_VERSION 3
+
+#define NP_CLASS_STRUCT_VERSION_ENUM 2
+#define NP_CLASS_STRUCT_VERSION_CTOR 3
+
+#define NP_CLASS_STRUCT_VERSION_HAS_ENUM(npclass) \
+ ((npclass)->structVersion >= NP_CLASS_STRUCT_VERSION_ENUM)
+
+#define NP_CLASS_STRUCT_VERSION_HAS_CTOR(npclass) \
+ ((npclass)->structVersion >= NP_CLASS_STRUCT_VERSION_CTOR)
+
+struct NPObject {
+ NPClass *_class;
+ uint32_t referenceCount;
+ /*
+ * Additional space may be allocated here by types of NPObjects
+ */
+};
+
+/*
+ If the class has an allocate function, NPN_CreateObject invokes
+ that function, otherwise a NPObject is allocated and
+ returned. This method will initialize the referenceCount member of
+ the NPObject to 1.
+*/
+NPObject *NPN_CreateObject(NPP npp, NPClass *aClass);
+
+/*
+ Increment the NPObject's reference count.
+*/
+NPObject *NPN_RetainObject(NPObject *npobj);
+
+/*
+ Decremented the NPObject's reference count. If the reference
+ count goes to zero, the class's destroy function is invoke if
+ specified, otherwise the object is freed directly.
+*/
+void NPN_ReleaseObject(NPObject *npobj);
+
+/*
+ Functions to access script objects represented by NPObject.
+
+ Calls to script objects are synchronous. If a function returns a
+ value, it will be supplied via the result NPVariant
+ argument. Successful calls will return true, false will be
+ returned in case of an error.
+
+ Calls made from plugin code to script must be made from the thread
+ on which the plugin was initialized.
+*/
+
+bool NPN_Invoke(NPP npp, NPObject *npobj, NPIdentifier methodName,
+ const NPVariant *args, uint32_t argCount, NPVariant *result);
+bool NPN_InvokeDefault(NPP npp, NPObject *npobj, const NPVariant *args,
+ uint32_t argCount, NPVariant *result);
+bool NPN_Evaluate(NPP npp, NPObject *npobj, NPString *script,
+ NPVariant *result);
+bool NPN_GetProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName,
+ NPVariant *result);
+bool NPN_SetProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName,
+ const NPVariant *value);
+bool NPN_RemoveProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName);
+bool NPN_HasProperty(NPP npp, NPObject *npobj, NPIdentifier propertyName);
+bool NPN_HasMethod(NPP npp, NPObject *npobj, NPIdentifier methodName);
+bool NPN_Enumerate(NPP npp, NPObject *npobj, NPIdentifier **identifier,
+ uint32_t *count);
+bool NPN_Construct(NPP npp, NPObject *npobj, const NPVariant *args,
+ uint32_t argCount, NPVariant *result);
+
+/*
+ NPN_SetException may be called to trigger a script exception upon
+ return from entry points into NPObjects. Typical usage:
+
+ NPN_SetException (npobj, message);
+*/
+void NPN_SetException(NPObject *npobj, const NPUTF8 *message);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/plugins/nptypes.h webkitgtk-2.36.7/Source/WebCore/plugins/nptypes.h
--- webkitgtk-2.36.7.orig/Source/WebCore/plugins/nptypes.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebCore/plugins/nptypes.h 2022-08-26 14:18:14.969022271 -0500
@@ -0,0 +1,121 @@
+/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is
+ * mozilla.org.
+ * Portions created by the Initial Developer are Copyright (C) 2004
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Johnny Stenback <jst@mozilla.org> (Original author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#ifndef nptypes_h_
+#define nptypes_h_
+
+/*
+ * Header file for ensuring that C99 types ([u]int32_t, [u]int64_t and bool) and
+ * true/false macros are available.
+ */
+
+#if defined(WIN32) || defined(OS2)
+ /*
+ * Win32 and OS/2 don't know C99, so define [u]int_16/32/64 here. The bool
+ * is predefined tho, both in C and C++.
+ */
+ typedef short int16_t;
+ typedef unsigned short uint16_t;
+ typedef int int32_t;
+ typedef unsigned int uint32_t;
+ typedef long long int64_t;
+ typedef unsigned long long uint64_t;
+#elif defined(_AIX) || defined(__sun) || defined(__osf__) || defined(IRIX) || defined(HPUX)
+ /*
+ * AIX and SunOS ship a inttypes.h header that defines [u]int32_t,
+ * but not bool for C.
+ */
+ #include <inttypes.h>
+
+ #ifndef __cplusplus
+ typedef int bool;
+ #define true 1
+ #define false 0
+ #endif
+#elif defined(bsdi) || defined(FREEBSD) || defined(OPENBSD)
+ /*
+ * BSD/OS, FreeBSD, and OpenBSD ship sys/types.h that define int32_t and
+ * u_int32_t.
+ */
+ #include <sys/types.h>
+
+ /*
+ * BSD/OS ships no header that defines uint32_t, nor bool (for C)
+ */
+ #if defined(bsdi)
+ typedef u_int32_t uint32_t;
+ typedef u_int64_t uint64_t;
+
+ #if !defined(__cplusplus)
+ typedef int bool;
+ #define true 1
+ #define false 0
+ #endif
+ #else
+ /*
+ * FreeBSD and OpenBSD define uint32_t and bool.
+ */
+ #include <inttypes.h>
+ #include <stdbool.h>
+ #endif
+#elif defined(BEOS)
+ #include <inttypes.h>
+#else
+ /*
+ * For those that ship a standard C99 stdint.h header file, include
+ * it. Can't do the same for stdbool.h tho, since some systems ship
+ * with a stdbool.h file that doesn't compile!
+ */
+ #include <stdint.h>
+
+ #ifndef __cplusplus
+ #if !defined(__GNUC__) || (__GNUC__ > 2 || __GNUC_MINOR__ > 95)
+ #include <stdbool.h>
+ #else
+ /*
+ * GCC 2.91 can't deal with a typedef for bool, but a #define
+ * works.
+ */
+ #define bool int
+ #define true 1
+ #define false 0
+ #endif
+ #endif
+#endif
+
+#endif /* nptypes_h_ */
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/plugins/PluginViewBase.h webkitgtk-2.36.7/Source/WebCore/plugins/PluginViewBase.h
--- webkitgtk-2.36.7.orig/Source/WebCore/plugins/PluginViewBase.h 2022-06-30 04:49:36.649513200 -0500
+++ webkitgtk-2.36.7/Source/WebCore/plugins/PluginViewBase.h 2022-08-26 14:18:14.969022271 -0500
@@ -58,6 +58,8 @@ public:
virtual JSC::JSObject* scriptObject(JSC::JSGlobalObject*) { return 0; }
virtual void storageBlockingStateChanged() { }
+ virtual void privateBrowsingStateChanged(bool) { }
+ virtual bool getFormValue(String&) { return false; }
virtual bool scroll(ScrollDirection, ScrollGranularity) { return false; }
// A plug-in can ask WebKit to handle scrollbars for it.
@@ -71,6 +73,7 @@ public:
virtual bool shouldAllowNavigationFromDrags() const { return false; }
bool isPluginViewBase() const override { return true; }
+ virtual bool shouldNotAddLayer() const { return false; }
virtual AudioHardwareActivityType audioHardwareActivity() const { return AudioHardwareActivityType::Unknown; }
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/rendering/RenderLayerBacking.cpp webkitgtk-2.36.7/Source/WebCore/rendering/RenderLayerBacking.cpp
--- webkitgtk-2.36.7.orig/Source/WebCore/rendering/RenderLayerBacking.cpp 2022-06-30 16:02:14.514368800 -0500
+++ webkitgtk-2.36.7/Source/WebCore/rendering/RenderLayerBacking.cpp 2022-08-26 14:18:14.969022271 -0500
@@ -1080,7 +1080,8 @@ bool RenderLayerBacking::updateConfigura
pluginViewBase->attachPluginLayer();
}
#else
- m_graphicsLayer->setContentsToPlatformLayer(pluginViewBase->platformLayer(), GraphicsLayer::ContentsLayerPurpose::Plugin);
+ if (!pluginViewBase->shouldNotAddLayer())
+ m_graphicsLayer->setContentsToPlatformLayer(pluginViewBase->platformLayer(), GraphicsLayer::ContentsLayerPurpose::Plugin);
#endif
}
#if ENABLE(VIDEO)
diff -urpN webkitgtk-2.36.7.orig/Source/WebCore/Sources.txt webkitgtk-2.36.7/Source/WebCore/Sources.txt
--- webkitgtk-2.36.7.orig/Source/WebCore/Sources.txt 2022-06-30 04:49:31.406183500 -0500
+++ webkitgtk-2.36.7/Source/WebCore/Sources.txt 2022-08-26 14:18:14.973022292 -0500
@@ -648,7 +648,14 @@ bindings/js/WebCoreTypedArrayController.
bindings/js/WorkerModuleScriptLoader.cpp
bindings/js/WindowProxy.cpp
bridge/IdentifierRep.cpp
+bridge/NP_jsobject.cpp
+bridge/c/CRuntimeObject.cpp
+bridge/c/c_class.cpp
+bridge/c/c_instance.cpp
+bridge/c/c_runtime.cpp
+bridge/c/c_utility.cpp
bridge/jsc/BridgeJSC.cpp
+bridge/npruntime.cpp
bridge/runtime_array.cpp
bridge/runtime_method.cpp
bridge/runtime_object.cpp
@@ -2241,6 +2248,7 @@ platform/network/ParsedContentRange.cpp
platform/network/ParsedContentType.cpp
platform/network/ParsedRequestRange.cpp
platform/network/ProtectionSpaceBase.cpp
+platform/network/ProxyServer.cpp
platform/network/ResourceErrorBase.cpp
platform/network/ResourceHandle.cpp
platform/network/ResourceHandleClient.cpp
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/CMakeLists.txt webkitgtk-2.36.7/Source/WebKit/CMakeLists.txt
--- webkitgtk-2.36.7.orig/Source/WebKit/CMakeLists.txt 2022-06-30 04:49:37.219513000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/CMakeLists.txt 2022-08-26 14:18:14.973022292 -0500
@@ -218,6 +218,10 @@ set(WebKit_MESSAGES_IN_FILES
NetworkProcess/webrtc/NetworkRTCProvider
NetworkProcess/webrtc/RTCDataChannelRemoteManagerProxy
+ PluginProcess/PluginControllerProxy
+ PluginProcess/PluginProcess
+ PluginProcess/WebProcessConnection
+
Shared/AuxiliaryProcess
Shared/IPCTester
Shared/WebConnection
@@ -226,6 +230,8 @@ set(WebKit_MESSAGES_IN_FILES
Shared/Notifications/NotificationManagerMessageHandler
+ Shared/Plugins/NPObjectMessageReceiver
+
UIProcess/DrawingAreaProxy
UIProcess/Media/RemoteMediaSessionCoordinatorProxy
@@ -253,6 +259,8 @@ set(WebKit_MESSAGES_IN_FILES
UIProcess/Network/NetworkProcessProxy
+ UIProcess/Plugins/PluginProcessProxy
+
UIProcess/UserContent/WebUserContentControllerProxy
UIProcess/XR/PlatformXRSystem
@@ -309,6 +317,10 @@ set(WebKit_MESSAGES_IN_FILES
WebProcess/Notifications/WebNotificationManager
+ WebProcess/Plugins/PluginProcessConnection
+ WebProcess/Plugins/PluginProcessConnectionManager
+ WebProcess/Plugins/PluginProxy
+
WebProcess/Speech/SpeechRecognitionRealtimeMediaSourceManager
WebProcess/Storage/WebSharedWorkerContextManagerConnection
@@ -660,7 +672,7 @@ else ()
set_target_properties(WebKit PROPERTIES VERSION ${WEBKIT_VERSION} SOVERSION ${WEBKIT_VERSION_MAJOR})
- install(TARGETS WebKit WebProcess NetworkProcess
+ install(TARGETS WebKit WebProcess NetworkProcess PluginProcess
LIBRARY DESTINATION "${LIB_INSTALL_DIR}"
RUNTIME DESTINATION "${LIBEXEC_INSTALL_DIR}"
)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/DerivedSources.make webkitgtk-2.36.7/Source/WebKit/DerivedSources.make
--- webkitgtk-2.36.7.orig/Source/WebKit/DerivedSources.make 2022-06-30 04:49:37.412846000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/DerivedSources.make 2022-08-26 14:18:14.973022292 -0500
@@ -38,6 +38,8 @@ VPATH = \
$(WebKit2)/NetworkProcess/ServiceWorker \
$(WebKit2)/NetworkProcess/WebStorage \
$(WebKit2)/NetworkProcess/storage \
+ $(WebKit2)/PluginProcess \
+ $(WebKit2)/PluginProcess/mac \
$(WebKit2)/Resources/SandboxProfiles/ios \
$(WebKit2)/Shared/Plugins \
$(WebKit2)/Shared \
@@ -145,6 +147,7 @@ MESSAGE_RECEIVERS = \
NetworkProcess/webrtc/RTCDataChannelRemoteManagerProxy \
NetworkProcess/Cookies/WebCookieManager \
NetworkProcess/storage/NetworkStorageManager \
+ Shared/Plugins/NPObjectMessageReceiver \
Shared/AuxiliaryProcess \
Shared/API/Cocoa/RemoteObjectRegistry \
Shared/ApplePay/WebPaymentCoordinatorProxy \
@@ -162,6 +165,7 @@ MESSAGE_RECEIVERS = \
UIProcess/Inspector/WebInspectorUIProxy \
UIProcess/Inspector/RemoteWebInspectorUIProxy \
UIProcess/Inspector/WebInspectorUIExtensionControllerProxy \
+ UIProcess/Plugins/PluginProcessProxy \
UIProcess/DrawingAreaProxy \
UIProcess/Network/NetworkProcessProxy \
UIProcess/Network/CustomProtocols/LegacyCustomProtocolManagerProxy \
@@ -214,6 +218,9 @@ MESSAGE_RECEIVERS = \
WebProcess/Inspector/WebInspector \
WebProcess/Inspector/RemoteWebInspectorUI \
WebProcess/MediaSession/RemoteMediaSessionCoordinator \
+ WebProcess/Plugins/PluginProcessConnectionManager \
+ WebProcess/Plugins/PluginProxy \
+ WebProcess/Plugins/PluginProcessConnection \
WebProcess/Network/WebSocketChannel \
WebProcess/Network/NetworkProcessConnection \
WebProcess/Network/WebSocketStream \
@@ -253,6 +260,9 @@ MESSAGE_RECEIVERS = \
WebProcess/WebPage/ViewUpdateDispatcher \
WebProcess/WebAuthentication/WebAuthnProcessConnection \
WebProcess/XR/PlatformXRSystemProxy \
+ PluginProcess/WebProcessConnection \
+ PluginProcess/PluginControllerProxy \
+ PluginProcess/PluginProcess \
GPUProcess/GPUConnectionToWebProcess \
GPUProcess/graphics/RemoteDisplayListRecorder \
GPUProcess/graphics/RemoteRenderingBackend \
@@ -350,6 +360,7 @@ endif
SANDBOX_PROFILES = \
com.apple.WebProcess.sb \
+ com.apple.WebKit.plugin-common.sb \
com.apple.WebKit.NetworkProcess.sb \
com.apple.WebKit.GPUProcess.sb \
com.apple.WebKit.WebAuthnProcess.sb \
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsDatabaseStore.cpp webkitgtk-2.36.7/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsDatabaseStore.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsDatabaseStore.cpp 2022-06-30 04:49:37.452846000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsDatabaseStore.cpp 2022-08-26 14:18:14.973022292 -0500
@@ -30,6 +30,8 @@
#include "Logging.h"
#include "NetworkSession.h"
+#include "PluginProcessManager.h"
+#include "PluginProcessProxy.h"
#include "PrivateClickMeasurementManager.h"
#include "PrivateClickMeasurementManagerProxy.h"
#include "StorageAccessStatus.h"
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsStore.cpp webkitgtk-2.36.7/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsStore.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsStore.cpp 2022-06-30 04:49:37.452846000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsStore.cpp 2022-08-26 14:18:14.973022292 -0500
@@ -31,6 +31,8 @@
#include "Logging.h"
#include "NetworkProcess.h"
#include "NetworkSession.h"
+#include "PluginProcessManager.h"
+#include "PluginProcessProxy.h"
#include "StorageAccessStatus.h"
#include "WebProcessProxy.h"
#include "WebsiteDataStore.h"
@@ -162,6 +164,12 @@ void ResourceLoadStatisticsStore::remove
return;
}
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ m_activePluginTokens.clear();
+ for (const auto& plugin : PluginProcessManager::singleton().pluginProcesses())
+ m_activePluginTokens.add(plugin->pluginProcessToken());
+#endif
+
auto domainsToDeleteOrRestrictWebsiteDataFor = registrableDomainsToDeleteOrRestrictWebsiteDataFor();
if (domainsToDeleteOrRestrictWebsiteDataFor.isEmpty()) {
completionHandler();
@@ -384,6 +392,13 @@ bool ResourceLoadStatisticsStore::should
if (m_dataRecordsBeingRemoved)
return false;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ for (const auto& plugin : PluginProcessManager::singleton().pluginProcesses()) {
+ if (!m_activePluginTokens.contains(plugin->pluginProcessToken()))
+ return true;
+ }
+#endif
+
return !m_lastTimeDataRecordsWereRemoved || MonotonicTime::now() >= (m_lastTimeDataRecordsWereRemoved + m_parameters.minimumTimeBetweenDataRecordsRemoval) || parameters().isRunningTest;
}
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsStore.h webkitgtk-2.36.7/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsStore.h
--- webkitgtk-2.36.7.orig/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsStore.h 2022-06-30 04:49:37.456179400 -0500
+++ webkitgtk-2.36.7/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsStore.h 2022-08-26 14:18:14.973022292 -0500
@@ -273,6 +273,9 @@ private:
#else
ResourceLoadStatisticsClassifier m_resourceLoadStatisticsClassifier;
#endif
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ HashSet<uint64_t> m_activePluginTokens;
+#endif
Parameters m_parameters;
WallTime m_endOfGrandfatheringTimestamp;
RegistrableDomain m_debugManualPrevalentResource;
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp webkitgtk-2.36.7/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp 2022-06-30 04:49:37.456179400 -0500
+++ webkitgtk-2.36.7/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp 2022-08-26 14:18:14.973022292 -0500
@@ -69,6 +69,9 @@ const OptionSet<WebsiteDataType>& WebRes
WebsiteDataType::LocalStorage,
WebsiteDataType::MediaKeys,
WebsiteDataType::OfflineWebApplicationCache,
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ WebsiteDataType::PlugInData,
+#endif
WebsiteDataType::SearchFieldRecentSearches,
WebsiteDataType::SessionStorage,
#if ENABLE(SERVICE_WORKER)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Platform/ExtraPrivateSymbolsForTAPI.h webkitgtk-2.36.7/Source/WebKit/Platform/ExtraPrivateSymbolsForTAPI.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Platform/ExtraPrivateSymbolsForTAPI.h 2022-06-30 04:49:37.512846000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/Platform/ExtraPrivateSymbolsForTAPI.h 2022-08-26 14:18:14.973022292 -0500
@@ -31,6 +31,7 @@ extern "C" {
// FIXME: Remove these after <rdar://problem/30772033> is fixed.
void NetworkServiceInitializer();
+void PluginServiceInitializer();
void WebContentServiceInitializer();
void GPUServiceInitializer();
void WebAuthnServiceInitializer();
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Platform/SharedMemory.h webkitgtk-2.36.7/Source/WebKit/Platform/SharedMemory.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Platform/SharedMemory.h 2022-06-30 04:49:37.526179300 -0500
+++ webkitgtk-2.36.7/Source/WebKit/Platform/SharedMemory.h 2022-08-26 14:18:14.973022292 -0500
@@ -56,6 +56,7 @@ class MachSendRight;
namespace WebKit {
+#undef None
enum class MemoryLedger { None, Default, Network, Media, Graphics, Neural };
class SharedMemory : public ThreadSafeRefCounted<SharedMemory> {
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/PlatformGTK.cmake webkitgtk-2.36.7/Source/WebKit/PlatformGTK.cmake
--- webkitgtk-2.36.7.orig/Source/WebKit/PlatformGTK.cmake 2022-06-30 04:49:37.536179300 -0500
+++ webkitgtk-2.36.7/Source/WebKit/PlatformGTK.cmake 2022-08-26 14:18:14.977022313 -0500
@@ -4,6 +4,7 @@ set(WebKit_OUTPUT_NAME webkit2gtk-${WEBK
set(WebProcess_OUTPUT_NAME WebKitWebProcess)
set(NetworkProcess_OUTPUT_NAME WebKitNetworkProcess)
set(GPUProcess_OUTPUT_NAME WebKitGPUProcess)
+set(PluginProcess_OUTPUT_NAME WebKitPluginProcess)
file(MAKE_DIRECTORY ${WebKit2Gtk_DERIVED_SOURCES_DIR}/webkit)
file(MAKE_DIRECTORY ${WebKit2Gtk_FRAMEWORK_HEADERS_DIR})
@@ -422,6 +423,7 @@ list(APPEND WebKit_INCLUDE_DIRECTORIES
"${WEBKIT_DIR}/Shared/API/glib"
"${WEBKIT_DIR}/Shared/CoordinatedGraphics"
"${WEBKIT_DIR}/Shared/CoordinatedGraphics/threadedcompositor"
+ "${WEBKIT_DIR}/Shared/Plugins/unix"
"${WEBKIT_DIR}/Shared/glib"
"${WEBKIT_DIR}/Shared/gtk"
"${WEBKIT_DIR}/Shared/linux"
@@ -435,6 +437,9 @@ list(APPEND WebKit_INCLUDE_DIRECTORIES
"${WEBKIT_DIR}/UIProcess/CoordinatedGraphics"
"${WEBKIT_DIR}/UIProcess/Inspector/glib"
"${WEBKIT_DIR}/UIProcess/Inspector/gtk"
+ "${WEBKIT_DIR}/WebProcess/Plugins/Netscape/unix"
+ "${WEBKIT_DIR}/WebProcess/Plugins/Netscape/x11"
+ "${WEBKIT_DIR}/UIProcess/Plugins/gtk"
"${WEBKIT_DIR}/UIProcess/geoclue"
"${WEBKIT_DIR}/UIProcess/glib"
"${WEBKIT_DIR}/UIProcess/gstreamer"
@@ -620,6 +625,11 @@ if (ENABLE_WAYLAND_TARGET)
)
endif ()
+# GTK3 PluginProcess
+list(APPEND PluginProcess_SOURCES
+ PluginProcess/EntryPoint/unix/PluginProcessMain.cpp
+)
+
# Commands for building the built-in injected bundle.
add_library(webkit2gtkinjectedbundle MODULE "${WEBKIT_DIR}/WebProcess/InjectedBundle/API/glib/WebKitInjectedBundleMain.cpp")
ADD_WEBKIT_PREFIX_HEADER(webkit2gtkinjectedbundle)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/PluginControllerProxy.cpp webkitgtk-2.36.7/Source/WebKit/PluginProcess/PluginControllerProxy.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/PluginControllerProxy.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/PluginProcess/PluginControllerProxy.cpp 2022-08-26 14:18:14.977022313 -0500
@@ -0,0 +1,675 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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 "config.h"
+#include "PluginControllerProxy.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "NPObjectProxy.h"
+#include "NPRemoteObjectMap.h"
+#include "NPRuntimeUtilities.h"
+#include "NPVariantData.h"
+#include "NetscapePlugin.h"
+#include "PluginCreationParameters.h"
+#include "PluginProcess.h"
+#include "PluginProxyMessages.h"
+#include "ShareableBitmap.h"
+#include "WebCoreArgumentCoders.h"
+#include "WebProcessConnection.h"
+#include "WebProcessConnectionMessages.h"
+#include <WebCore/GraphicsContext.h>
+#include <WebCore/HTTPHeaderMap.h>
+#include <WebCore/IdentifierRep.h>
+#include <WebCore/NotImplemented.h>
+#include <wtf/SetForScope.h>
+#include <wtf/text/WTFString.h>
+
+#if PLATFORM(COCOA)
+#include "LayerHostingContext.h"
+#endif
+
+namespace WebKit {
+using namespace WebCore;
+
+PluginControllerProxy::PluginControllerProxy(WebProcessConnection* connection, const PluginCreationParameters& creationParameters)
+ : m_connection(connection)
+ , m_pluginInstanceID(creationParameters.pluginInstanceID)
+ , m_userAgent(creationParameters.userAgent)
+ , m_isPrivateBrowsingEnabled(creationParameters.isPrivateBrowsingEnabled)
+ , m_isMuted(creationParameters.isMuted)
+ , m_isAcceleratedCompositingEnabled(creationParameters.isAcceleratedCompositingEnabled)
+ , m_isInitializing(false)
+ , m_isVisible(false)
+ , m_isWindowVisible(false)
+ , m_paintTimer(RunLoop::main(), this, &PluginControllerProxy::paint)
+ , m_pluginDestructionProtectCount(0)
+ , m_pluginDestroyTimer(RunLoop::main(), this, &PluginControllerProxy::destroy)
+ , m_waitingForDidUpdate(false)
+ , m_pluginCanceledManualStreamLoad(false)
+#if PLATFORM(COCOA)
+ , m_isComplexTextInputEnabled(false)
+#endif
+ , m_contentsScaleFactor(creationParameters.contentsScaleFactor)
+ , m_windowNPObject(0)
+ , m_pluginElementNPObject(0)
+ , m_visiblityActivity("Plugin is visible.")
+{
+}
+
+PluginControllerProxy::~PluginControllerProxy()
+{
+ ASSERT(!m_plugin);
+
+ if (m_windowNPObject)
+ releaseNPObject(m_windowNPObject);
+
+ if (m_pluginElementNPObject)
+ releaseNPObject(m_pluginElementNPObject);
+}
+
+void PluginControllerProxy::setInitializationReply(Messages::WebProcessConnection::CreatePlugin::DelayedReply&& reply)
+{
+ ASSERT(!m_initializationReply);
+ m_initializationReply = WTFMove(reply);
+}
+
+Messages::WebProcessConnection::CreatePlugin::DelayedReply PluginControllerProxy::takeInitializationReply()
+{
+ return std::exchange(m_initializationReply, nullptr);
+}
+
+bool PluginControllerProxy::initialize(const PluginCreationParameters& creationParameters)
+{
+ ASSERT(!m_plugin);
+
+ ASSERT(!m_isInitializing);
+ m_isInitializing = true; // Cannot use SetForScope here, because this object can be deleted before the function returns.
+
+ m_plugin = NetscapePlugin::create(PluginProcess::singleton().netscapePluginModule());
+ if (!m_plugin) {
+ // This will delete the plug-in controller proxy object.
+ m_connection->removePluginControllerProxy(this, 0);
+ return false;
+ }
+
+ if (creationParameters.windowNPObjectID)
+ m_windowNPObject = m_connection->npRemoteObjectMap()->createNPObjectProxy(creationParameters.windowNPObjectID, m_plugin.get());
+
+ bool returnValue = m_plugin->initialize(*this, creationParameters.parameters);
+
+ if (!returnValue) {
+ // Get the plug-in so we can pass it to removePluginControllerProxy. The pointer is only
+ // used as an identifier so it's OK to just get a weak reference.
+ Plugin* plugin = m_plugin.get();
+
+ m_plugin = nullptr;
+
+ // This will delete the plug-in controller proxy object.
+ m_connection->removePluginControllerProxy(this, plugin);
+ return false;
+ }
+
+ platformInitialize(creationParameters);
+
+ m_isInitializing = false;
+ return true;
+}
+
+void PluginControllerProxy::destroy()
+{
+ ASSERT(m_plugin);
+
+ // FIXME: Consider removing m_pluginDestructionProtectCount and always use inSendSync here.
+ if (m_pluginDestructionProtectCount || m_connection->connection()->inSendSync()) {
+ // We have plug-in code on the stack so we can't destroy it right now.
+ // Destroy it later.
+ m_pluginDestroyTimer.startOneShot(0_s);
+ return;
+ }
+
+ // Get the plug-in so we can pass it to removePluginControllerProxy. The pointer is only
+ // used as an identifier so it's OK to just get a weak reference.
+ Plugin* plugin = m_plugin.get();
+
+ m_plugin->destroyPlugin();
+ m_plugin = nullptr;
+
+ platformDestroy();
+
+ // This will delete the plug-in controller proxy object.
+ m_connection->removePluginControllerProxy(this, plugin);
+}
+
+bool PluginControllerProxy::wantsWheelEvents() const
+{
+ return m_plugin->wantsWheelEvents();
+}
+
+void PluginControllerProxy::paint()
+{
+ ASSERT(!m_dirtyRect.isEmpty());
+ m_paintTimer.stop();
+
+ if (!m_backingStore)
+ return;
+
+ IntRect dirtyRect = m_dirtyRect;
+ m_dirtyRect = IntRect();
+
+ ASSERT(m_plugin);
+
+ // Create a graphics context.
+ auto graphicsContext = m_backingStore->createGraphicsContext();
+ if (!graphicsContext)
+ return;
+
+#if PLATFORM(COCOA)
+ // FIXME: We should really call applyDeviceScaleFactor instead of scale, but that ends up calling into WKSI
+ // which we currently don't have initiated in the plug-in process.
+ graphicsContext->scale(m_contentsScaleFactor);
+#endif
+
+ if (m_plugin->isTransparent())
+ graphicsContext->clearRect(dirtyRect);
+
+ m_plugin->paint(*graphicsContext, dirtyRect);
+
+ m_connection->connection()->send(Messages::PluginProxy::Update(dirtyRect), m_pluginInstanceID);
+}
+
+void PluginControllerProxy::startPaintTimer()
+{
+ // Check if we should start the timer.
+
+ if (m_dirtyRect.isEmpty())
+ return;
+
+ // FIXME: Check clip rect.
+
+ if (m_paintTimer.isActive())
+ return;
+
+ if (m_waitingForDidUpdate)
+ return;
+
+ // Start the timer.
+ m_paintTimer.startOneShot(0_s);
+
+ m_waitingForDidUpdate = true;
+}
+
+void PluginControllerProxy::invalidate(const IntRect& rect)
+{
+ IntRect dirtyRect = rect;
+
+ // Make sure that the dirty rect is not greater than the plug-in itself.
+ dirtyRect.intersect(IntRect(IntPoint(), m_pluginSize));
+ m_dirtyRect.unite(dirtyRect);
+
+ startPaintTimer();
+}
+
+String PluginControllerProxy::userAgent()
+{
+ return m_userAgent;
+}
+
+void PluginControllerProxy::loadURL(uint64_t requestID, const String& method, const String& urlString, const String& target, const HTTPHeaderMap& headerFields, const Vector<uint8_t>& httpBody, bool allowPopups)
+{
+ m_connection->connection()->send(Messages::PluginProxy::LoadURL(requestID, method, urlString, target, headerFields, httpBody, allowPopups), m_pluginInstanceID);
+}
+
+void PluginControllerProxy::continueStreamLoad(uint64_t streamID)
+{
+ m_connection->connection()->send(Messages::PluginProxy::ContinueStreamLoad(streamID), m_pluginInstanceID);
+}
+
+void PluginControllerProxy::cancelStreamLoad(uint64_t streamID)
+{
+ m_connection->connection()->send(Messages::PluginProxy::CancelStreamLoad(streamID), m_pluginInstanceID);
+}
+
+void PluginControllerProxy::cancelManualStreamLoad()
+{
+ m_pluginCanceledManualStreamLoad = true;
+
+ m_connection->connection()->send(Messages::PluginProxy::CancelManualStreamLoad(), m_pluginInstanceID);
+}
+
+NPObject* PluginControllerProxy::windowScriptNPObject()
+{
+ if (!m_windowNPObject)
+ return 0;
+
+ retainNPObject(m_windowNPObject);
+ return m_windowNPObject;
+}
+
+NPObject* PluginControllerProxy::pluginElementNPObject()
+{
+ if (!m_pluginElementNPObject) {
+ uint64_t pluginElementNPObjectID = 0;
+
+ if (!m_connection->connection()->sendSync(Messages::PluginProxy::GetPluginElementNPObject(), Messages::PluginProxy::GetPluginElementNPObject::Reply(pluginElementNPObjectID), m_pluginInstanceID))
+ return 0;
+
+ if (!pluginElementNPObjectID)
+ return 0;
+
+ m_pluginElementNPObject = m_connection->npRemoteObjectMap()->createNPObjectProxy(pluginElementNPObjectID, m_plugin.get());
+ ASSERT(m_pluginElementNPObject);
+ }
+
+ retainNPObject(m_pluginElementNPObject);
+ return m_pluginElementNPObject;
+}
+
+bool PluginControllerProxy::evaluate(NPObject* npObject, const String& scriptString, NPVariant* result, bool allowPopups)
+{
+ PluginDestructionProtector protector(this);
+
+ NPVariant npObjectAsNPVariant;
+ OBJECT_TO_NPVARIANT(npObject, npObjectAsNPVariant);
+
+ // Send the NPObject over as an NPVariantData.
+ NPVariantData npObjectAsNPVariantData = m_connection->npRemoteObjectMap()->npVariantToNPVariantData(npObjectAsNPVariant, m_plugin.get());
+
+ bool returnValue = false;
+ NPVariantData resultData;
+
+ if (!m_connection->connection()->sendSync(Messages::PluginProxy::Evaluate(npObjectAsNPVariantData, scriptString, allowPopups), Messages::PluginProxy::Evaluate::Reply(returnValue, resultData), m_pluginInstanceID))
+ return false;
+
+ if (!returnValue)
+ return false;
+
+ *result = m_connection->npRemoteObjectMap()->npVariantDataToNPVariant(resultData, m_plugin.get());
+ return true;
+}
+
+void PluginControllerProxy::setPluginIsPlayingAudio(bool pluginIsPlayingAudio)
+{
+ m_connection->connection()->send(Messages::PluginProxy::SetPluginIsPlayingAudio(pluginIsPlayingAudio), m_pluginInstanceID);
+}
+
+void PluginControllerProxy::setStatusbarText(const String& statusbarText)
+{
+ m_connection->connection()->send(Messages::PluginProxy::SetStatusbarText(statusbarText), m_pluginInstanceID);
+}
+
+bool PluginControllerProxy::isAcceleratedCompositingEnabled()
+{
+ return m_isAcceleratedCompositingEnabled;
+}
+
+void PluginControllerProxy::pluginProcessCrashed()
+{
+ // This should never be called from here.
+ ASSERT_NOT_REACHED();
+}
+
+void PluginControllerProxy::didInitializePlugin()
+{
+ // This should only be called on the plugin in the web process.
+ ASSERT_NOT_REACHED();
+}
+
+void PluginControllerProxy::didFailToInitializePlugin()
+{
+ // This should only be called on the plugin in the web process.
+ ASSERT_NOT_REACHED();
+}
+
+float PluginControllerProxy::contentsScaleFactor()
+{
+ return m_contentsScaleFactor;
+}
+
+String PluginControllerProxy::proxiesForURL(const String& urlString)
+{
+ String proxyString;
+
+ if (!m_connection->connection()->sendSync(Messages::PluginProxy::ProxiesForURL(urlString), Messages::PluginProxy::ProxiesForURL::Reply(proxyString), m_pluginInstanceID))
+ return String();
+
+ return proxyString;
+}
+
+String PluginControllerProxy::cookiesForURL(const String& urlString)
+{
+ String cookieString;
+
+ if (!m_connection->connection()->sendSync(Messages::PluginProxy::CookiesForURL(urlString), Messages::PluginProxy::CookiesForURL::Reply(cookieString), m_pluginInstanceID))
+ return String();
+
+ return cookieString;
+}
+
+void PluginControllerProxy::setCookiesForURL(const String& urlString, const String& cookieString)
+{
+ m_connection->connection()->send(Messages::PluginProxy::SetCookiesForURL(urlString, cookieString), m_pluginInstanceID);
+}
+
+bool PluginControllerProxy::isPrivateBrowsingEnabled()
+{
+ return m_isPrivateBrowsingEnabled;
+}
+
+bool PluginControllerProxy::getAuthenticationInfo(const ProtectionSpace& protectionSpace, String& username, String& password)
+{
+ bool returnValue;
+ if (!m_connection->connection()->sendSync(Messages::PluginProxy::GetAuthenticationInfo(protectionSpace), Messages::PluginProxy::GetAuthenticationInfo::Reply(returnValue, username, password), m_pluginInstanceID))
+ return false;
+
+ return returnValue;
+}
+
+void PluginControllerProxy::protectPluginFromDestruction()
+{
+ m_pluginDestructionProtectCount++;
+}
+
+void PluginControllerProxy::unprotectPluginFromDestruction()
+{
+ ASSERT(m_pluginDestructionProtectCount);
+
+ m_pluginDestructionProtectCount--;
+}
+
+void PluginControllerProxy::frameDidFinishLoading(uint64_t requestID)
+{
+ m_plugin->frameDidFinishLoading(requestID);
+}
+
+void PluginControllerProxy::frameDidFail(uint64_t requestID, bool wasCancelled)
+{
+ m_plugin->frameDidFail(requestID, wasCancelled);
+}
+
+void PluginControllerProxy::geometryDidChange(const IntSize& pluginSize, const IntRect& clipRect, const AffineTransform& pluginToRootViewTransform, float contentsScaleFactor, const ShareableBitmap::Handle& backingStoreHandle)
+{
+ ASSERT(m_plugin);
+
+ m_pluginSize = pluginSize;
+
+ if (contentsScaleFactor != m_contentsScaleFactor) {
+ m_contentsScaleFactor = contentsScaleFactor;
+ m_plugin->contentsScaleFactorChanged(m_contentsScaleFactor);
+ }
+
+ platformGeometryDidChange();
+
+ if (!backingStoreHandle.isNull()) {
+ // Create a new backing store.
+ m_backingStore = ShareableBitmap::create(backingStoreHandle);
+ }
+
+ m_plugin->geometryDidChange(pluginSize, clipRect, pluginToRootViewTransform);
+}
+
+void PluginControllerProxy::visibilityDidChange(bool isVisible)
+{
+ m_isVisible = isVisible;
+
+ ASSERT(m_plugin);
+ m_plugin->visibilityDidChange(isVisible);
+
+ updateVisibilityActivity();
+}
+
+void PluginControllerProxy::windowFocusChanged(bool hasFocus)
+{
+ ASSERT(m_plugin);
+ m_plugin->windowFocusChanged(hasFocus);
+}
+
+void PluginControllerProxy::windowVisibilityChanged(bool isVisible)
+{
+ m_isWindowVisible = isVisible;
+
+ ASSERT(m_plugin);
+ m_plugin->windowVisibilityChanged(isVisible);
+
+ updateVisibilityActivity();
+}
+
+void PluginControllerProxy::updateVisibilityActivity()
+{
+ if (m_isVisible && m_isWindowVisible)
+ m_visiblityActivity.start();
+ else
+ m_visiblityActivity.stop();
+}
+
+void PluginControllerProxy::didEvaluateJavaScript(uint64_t requestID, const String& result)
+{
+ m_plugin->didEvaluateJavaScript(requestID, result);
+}
+
+void PluginControllerProxy::streamWillSendRequest(uint64_t streamID, const String& requestURLString, const String& redirectResponseURLString, uint32_t redirectResponseStatusCode)
+{
+ m_plugin->streamWillSendRequest(streamID, URL({ }, requestURLString), URL({ }, redirectResponseURLString), redirectResponseStatusCode);
+}
+
+void PluginControllerProxy::streamDidReceiveResponse(uint64_t streamID, const String& responseURLString, uint32_t streamLength, uint32_t lastModifiedTime, const String& mimeType, const String& headers)
+{
+ m_plugin->streamDidReceiveResponse(streamID, URL({ }, responseURLString), streamLength, lastModifiedTime, mimeType, headers, String());
+}
+
+void PluginControllerProxy::streamDidReceiveData(uint64_t streamID, const IPC::DataReference& data)
+{
+ m_plugin->streamDidReceiveData(streamID, SharedBuffer::create(data.data(), data.size()));
+}
+
+void PluginControllerProxy::streamDidFinishLoading(uint64_t streamID)
+{
+ m_plugin->streamDidFinishLoading(streamID);
+}
+
+void PluginControllerProxy::streamDidFail(uint64_t streamID, bool wasCancelled)
+{
+ m_plugin->streamDidFail(streamID, wasCancelled);
+}
+
+void PluginControllerProxy::manualStreamDidReceiveResponse(const String& responseURLString, uint32_t streamLength, uint32_t lastModifiedTime, const String& mimeType, const String& headers)
+{
+ if (m_pluginCanceledManualStreamLoad)
+ return;
+
+ m_plugin->manualStreamDidReceiveResponse(URL({ }, responseURLString), streamLength, lastModifiedTime, mimeType, headers, String());
+}
+
+void PluginControllerProxy::manualStreamDidReceiveData(const IPC::DataReference& data)
+{
+ if (m_pluginCanceledManualStreamLoad)
+ return;
+
+ m_plugin->manualStreamDidReceiveData(SharedBuffer::create(data.data(), data.size()));
+}
+
+void PluginControllerProxy::manualStreamDidFinishLoading()
+{
+ if (m_pluginCanceledManualStreamLoad)
+ return;
+
+ m_plugin->manualStreamDidFinishLoading();
+}
+
+void PluginControllerProxy::manualStreamDidFail(bool wasCancelled)
+{
+ if (m_pluginCanceledManualStreamLoad)
+ return;
+
+ m_plugin->manualStreamDidFail(wasCancelled);
+}
+
+void PluginControllerProxy::handleMouseEvent(const WebMouseEvent& mouseEvent)
+{
+ m_plugin->handleMouseEvent(mouseEvent);
+}
+
+void PluginControllerProxy::handleWheelEvent(const WebWheelEvent& wheelEvent, CompletionHandler<void(bool)>&& completionHandler)
+{
+ completionHandler(m_plugin->handleWheelEvent(wheelEvent));
+}
+
+void PluginControllerProxy::handleMouseEnterEvent(const WebMouseEvent& mouseEnterEvent, CompletionHandler<void(bool)>&& completionHandler)
+{
+ completionHandler(m_plugin->handleMouseEnterEvent(mouseEnterEvent));
+}
+
+void PluginControllerProxy::handleMouseLeaveEvent(const WebMouseEvent& mouseLeaveEvent, CompletionHandler<void(bool)>&& completionHandler)
+{
+ completionHandler(m_plugin->handleMouseLeaveEvent(mouseLeaveEvent));
+}
+
+void PluginControllerProxy::handleKeyboardEvent(const WebKeyboardEvent& keyboardEvent, CompletionHandler<void(bool)>&& completionHandler)
+{
+ completionHandler(m_plugin->handleKeyboardEvent(keyboardEvent));
+}
+
+void PluginControllerProxy::handleEditingCommand(const String& commandName, const String& argument, CompletionHandler<void(bool)>&& completionHandler)
+{
+ completionHandler(m_plugin->handleEditingCommand(commandName, argument));
+}
+
+void PluginControllerProxy::isEditingCommandEnabled(const String& commandName, CompletionHandler<void(bool)>&& completionHandler)
+{
+ completionHandler(m_plugin->isEditingCommandEnabled(commandName));
+}
+
+void PluginControllerProxy::handlesPageScaleFactor(CompletionHandler<void(bool)>&& completionHandler)
+{
+ completionHandler(m_plugin->handlesPageScaleFactor());
+}
+
+void PluginControllerProxy::requiresUnifiedScaleFactor(CompletionHandler<void(bool)>&& completionHandler)
+{
+ completionHandler(m_plugin->requiresUnifiedScaleFactor());
+}
+
+void PluginControllerProxy::paintEntirePlugin(CompletionHandler<void()>&& completionHandler)
+{
+ if (m_pluginSize.isEmpty())
+ return completionHandler();
+
+ m_dirtyRect = IntRect(IntPoint(), m_pluginSize);
+ paint();
+ completionHandler();
+}
+
+void PluginControllerProxy::supportsSnapshotting(CompletionHandler<void(bool)>&& completionHandler)
+{
+ completionHandler(m_plugin->supportsSnapshotting());
+}
+
+void PluginControllerProxy::snapshot(CompletionHandler<void(ShareableBitmap::Handle&&)> completionHandler)
+{
+ ASSERT(m_plugin);
+ RefPtr<ShareableBitmap> bitmap = m_plugin->snapshot();
+ if (!bitmap)
+ return completionHandler({ });
+
+ ShareableBitmap::Handle backingStoreHandle;
+ bitmap->createHandle(backingStoreHandle);
+ completionHandler(WTFMove(backingStoreHandle));
+}
+
+void PluginControllerProxy::setFocus(bool hasFocus)
+{
+ m_plugin->setFocus(hasFocus);
+}
+
+void PluginControllerProxy::didUpdate()
+{
+ m_waitingForDidUpdate = false;
+ startPaintTimer();
+}
+
+void PluginControllerProxy::getPluginScriptableNPObject(CompletionHandler<void(uint64_t)>&& completionHandler)
+{
+ NPObject* pluginScriptableNPObject = m_plugin->pluginScriptableNPObject();
+ if (!pluginScriptableNPObject)
+ return completionHandler(0);
+
+ uint64_t pluginScriptableNPObjectID = m_connection->npRemoteObjectMap()->registerNPObject(pluginScriptableNPObject, m_plugin.get());
+ releaseNPObject(pluginScriptableNPObject);
+ completionHandler(pluginScriptableNPObjectID);
+}
+
+void PluginControllerProxy::storageBlockingStateChanged(bool isStorageBlockingEnabled)
+{
+ if (m_storageBlockingEnabled != isStorageBlockingEnabled) {
+ m_storageBlockingEnabled = isStorageBlockingEnabled;
+ m_plugin->storageBlockingStateChanged(m_storageBlockingEnabled);
+ }
+}
+
+void PluginControllerProxy::privateBrowsingStateChanged(bool isPrivateBrowsingEnabled)
+{
+ m_isPrivateBrowsingEnabled = isPrivateBrowsingEnabled;
+
+ m_plugin->privateBrowsingStateChanged(isPrivateBrowsingEnabled);
+}
+
+void PluginControllerProxy::mutedStateChanged(bool isMuted)
+{
+ if (m_isMuted == isMuted)
+ return;
+
+ m_isMuted = isMuted;
+ m_plugin->mutedStateChanged(isMuted);
+}
+
+void PluginControllerProxy::getFormValue(CompletionHandler<void(bool, String&&)>&& completionHandler)
+{
+ String formValue;
+ bool returnValue = m_plugin->getFormValue(formValue);
+ completionHandler(returnValue, WTFMove(formValue));
+}
+
+#if PLATFORM(X11)
+uint64_t PluginControllerProxy::createPluginContainer()
+{
+ uint64_t windowID = 0;
+ m_connection->connection()->sendSync(Messages::PluginProxy::CreatePluginContainer(), Messages::PluginProxy::CreatePluginContainer::Reply(windowID), m_pluginInstanceID);
+ return windowID;
+}
+
+void PluginControllerProxy::windowedPluginGeometryDidChange(const IntRect& frameRect, const IntRect& clipRect, uint64_t windowID)
+{
+ m_connection->connection()->send(Messages::PluginProxy::WindowedPluginGeometryDidChange(frameRect, clipRect, windowID), m_pluginInstanceID);
+}
+
+void PluginControllerProxy::windowedPluginVisibilityDidChange(bool isVisible, uint64_t windowID)
+{
+ m_connection->connection()->send(Messages::PluginProxy::WindowedPluginVisibilityDidChange(isVisible, windowID), m_pluginInstanceID);
+}
+#endif
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/PluginControllerProxy.h webkitgtk-2.36.7/Source/WebKit/PluginProcess/PluginControllerProxy.h
--- webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/PluginControllerProxy.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/PluginProcess/PluginControllerProxy.h 2022-08-26 14:18:14.977022313 -0500
@@ -0,0 +1,235 @@
+/*
+ * Copyright (C) 2010-2018 Apple 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 INC. 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 INC. 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.
+ */
+
+#pragma once
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "Connection.h"
+#include "DataReference.h"
+#include "Plugin.h"
+#include "PluginController.h"
+#include "ShareableBitmap.h"
+#include "WebProcessConnectionMessagesReplies.h"
+#include <WebCore/SecurityOrigin.h>
+#include <WebCore/UserActivity.h>
+#include <wtf/Noncopyable.h>
+#include <wtf/RunLoop.h>
+
+namespace WebKit {
+
+class LayerHostingContext;
+class ShareableBitmap;
+class WebProcessConnection;
+struct PluginCreationParameters;
+
+class PluginControllerProxy : public PluginController {
+ WTF_MAKE_FAST_ALLOCATED;
+ WTF_MAKE_NONCOPYABLE(PluginControllerProxy);
+
+public:
+ PluginControllerProxy(WebProcessConnection*, const PluginCreationParameters&);
+ ~PluginControllerProxy();
+
+ uint64_t pluginInstanceID() const { return m_pluginInstanceID; }
+
+ bool initialize(const PluginCreationParameters&);
+ void destroy();
+
+ void didReceivePluginControllerProxyMessage(IPC::Connection&, IPC::Decoder&);
+ bool didReceiveSyncPluginControllerProxyMessage(IPC::Connection&, IPC::Decoder&, UniqueRef<IPC::Encoder>&);
+
+ bool wantsWheelEvents() const;
+
+#if PLATFORM(COCOA)
+ uint32_t remoteLayerClientID() const;
+#endif
+
+ PluginController* asPluginController() { return this; }
+
+ bool isInitializing() const { return m_isInitializing; }
+
+ void setInitializationReply(Messages::WebProcessConnection::CreatePluginDelayedReply&&);
+ Messages::WebProcessConnection::CreatePluginDelayedReply takeInitializationReply();
+
+private:
+ void startPaintTimer();
+ void paint();
+
+ // PluginController
+ void invalidate(const WebCore::IntRect&) override;
+ String userAgent() override;
+ void loadURL(uint64_t requestID, const String& method, const String& urlString, const String& target, const WebCore::HTTPHeaderMap& headerFields, const Vector<uint8_t>& httpBody, bool allowPopups) override;
+ void continueStreamLoad(uint64_t streamID) override;
+ void cancelStreamLoad(uint64_t streamID) override;
+ void cancelManualStreamLoad() override;
+ NPObject* windowScriptNPObject() override;
+ NPObject* pluginElementNPObject() override;
+ bool evaluate(NPObject*, const String& scriptString, NPVariant* result, bool allowPopups) override;
+ void setPluginIsPlayingAudio(bool) override;
+ void setStatusbarText(const String&) override;
+ bool isAcceleratedCompositingEnabled() override;
+ void pluginProcessCrashed() override;
+ void didInitializePlugin() override;
+ void didFailToInitializePlugin() override;
+
+#if PLATFORM(COCOA)
+ void pluginFocusOrWindowFocusChanged(bool) override;
+ void setComplexTextInputState(PluginComplexTextInputState) override;
+ const WTF::MachSendRight& compositingRenderServerPort() override;
+#endif
+
+ float contentsScaleFactor() override;
+ String proxiesForURL(const String&) override;
+ String cookiesForURL(const String&) override;
+ void setCookiesForURL(const String& urlString, const String& cookieString) override;
+ bool isPrivateBrowsingEnabled() override;
+ bool isMuted() const override { return m_isMuted; }
+ bool getAuthenticationInfo(const WebCore::ProtectionSpace&, String& username, String& password) override;
+ void protectPluginFromDestruction() override;
+ void unprotectPluginFromDestruction() override;
+#if PLATFORM(X11)
+ uint64_t createPluginContainer() override;
+ void windowedPluginGeometryDidChange(const WebCore::IntRect& frameRect, const WebCore::IntRect& clipRect, uint64_t windowID) override;
+ void windowedPluginVisibilityDidChange(bool isVisible, uint64_t windowID) override;
+#endif
+
+ // Message handlers.
+ void frameDidFinishLoading(uint64_t requestID);
+ void frameDidFail(uint64_t requestID, bool wasCancelled);
+ void geometryDidChange(const WebCore::IntSize& pluginSize, const WebCore::IntRect& clipRect, const WebCore::AffineTransform& pluginToRootViewTransform, float contentsScaleFactor, const ShareableBitmap::Handle& backingStoreHandle);
+ void visibilityDidChange(bool isVisible);
+ void didEvaluateJavaScript(uint64_t requestID, const String& result);
+ void streamWillSendRequest(uint64_t streamID, const String& requestURLString, const String& redirectResponseURLString, uint32_t redirectResponseStatusCode);
+ void streamDidReceiveResponse(uint64_t streamID, const String& responseURLString, uint32_t streamLength, uint32_t lastModifiedTime, const String& mimeType, const String& headers);
+ void streamDidReceiveData(uint64_t streamID, const IPC::DataReference& data);
+ void streamDidFinishLoading(uint64_t streamID);
+ void streamDidFail(uint64_t streamID, bool wasCancelled);
+ void manualStreamDidReceiveResponse(const String& responseURLString, uint32_t streamLength, uint32_t lastModifiedTime, const String& mimeType, const String& headers);
+ void manualStreamDidReceiveData(const IPC::DataReference& data);
+ void manualStreamDidFinishLoading();
+ void manualStreamDidFail(bool wasCancelled);
+ void handleMouseEvent(const WebMouseEvent&);
+ void handleWheelEvent(const WebWheelEvent&, CompletionHandler<void(bool handled)>&&);
+ void handleMouseEnterEvent(const WebMouseEvent&, CompletionHandler<void(bool handled)>&&);
+ void handleMouseLeaveEvent(const WebMouseEvent&, CompletionHandler<void(bool handled)>&&);
+ void handleKeyboardEvent(const WebKeyboardEvent&, CompletionHandler<void(bool handled)>&&);
+ void handleEditingCommand(const String&, const String&, CompletionHandler<void(bool handled)>&&);
+ void isEditingCommandEnabled(const String&, CompletionHandler<void(bool)>&&);
+ void handlesPageScaleFactor(CompletionHandler<void(bool)>&&);
+ void requiresUnifiedScaleFactor(CompletionHandler<void(bool)>&&);
+ void paintEntirePlugin(CompletionHandler<void()>&&);
+ void supportsSnapshotting(CompletionHandler<void(bool)>&&);
+ void snapshot(CompletionHandler<void(ShareableBitmap::Handle&&)>);
+ void setFocus(bool);
+ void didUpdate();
+ void getPluginScriptableNPObject(CompletionHandler<void(uint64_t pluginScriptableNPObjectID)>&&);
+
+ void windowFocusChanged(bool);
+ void windowVisibilityChanged(bool);
+ void updateVisibilityActivity();
+
+#if PLATFORM(COCOA)
+ void windowAndViewFramesChanged(const WebCore::IntRect& windowFrameInScreenCoordinates, const WebCore::IntRect& viewFrameInWindowCoordinates);
+ void sendComplexTextInput(const String& textInput);
+ void setLayerHostingMode(uint32_t);
+
+ void updateLayerHostingContext(LayerHostingMode);
+#endif
+
+ void storageBlockingStateChanged(bool);
+ void privateBrowsingStateChanged(bool);
+ void mutedStateChanged(bool);
+ void getFormValue(CompletionHandler<void(bool returnValue, String&& formValue)>&&);
+
+ void platformInitialize(const PluginCreationParameters&);
+ void platformDestroy();
+ void platformGeometryDidChange();
+
+ WebProcessConnection* m_connection;
+ uint64_t m_pluginInstanceID;
+
+ String m_userAgent;
+ bool m_storageBlockingEnabled;
+ bool m_isPrivateBrowsingEnabled;
+ bool m_isMuted;
+ bool m_isAcceleratedCompositingEnabled;
+ bool m_isInitializing;
+ bool m_isVisible;
+ bool m_isWindowVisible;
+
+ Messages::WebProcessConnection::CreatePluginDelayedReply m_initializationReply;
+
+ RefPtr<Plugin> m_plugin;
+
+ WebCore::IntSize m_pluginSize;
+
+ // The dirty rect in plug-in coordinates.
+ WebCore::IntRect m_dirtyRect;
+
+ // The paint timer, used for coalescing painting.
+ RunLoop::Timer<PluginControllerProxy> m_paintTimer;
+
+ // A counter used to prevent the plug-in from being destroyed.
+ unsigned m_pluginDestructionProtectCount;
+
+ // A timer that we use to prevent destruction of the plug-in while plug-in
+ // code is on the stack.
+ RunLoop::Timer<PluginControllerProxy> m_pluginDestroyTimer;
+
+ // Whether we're waiting for the plug-in proxy in the web process to draw the contents of its
+ // backing store into the web process backing store.
+ bool m_waitingForDidUpdate;
+
+ // Whether the plug-in has canceled the manual stream load.
+ bool m_pluginCanceledManualStreamLoad;
+
+#if PLATFORM(COCOA)
+ // Whether complex text input is enabled for this plug-in.
+ bool m_isComplexTextInputEnabled;
+
+ // For CA plug-ins, this holds the information needed to export the layer hierarchy to the UI process.
+ std::unique_ptr<LayerHostingContext> m_layerHostingContext;
+#endif
+
+ // The contents scale factor of this plug-in.
+ float m_contentsScaleFactor;
+
+ // The backing store that this plug-in draws into.
+ RefPtr<ShareableBitmap> m_backingStore;
+
+ // The window NPObject.
+ NPObject* m_windowNPObject;
+
+ // The plug-in element NPObject.
+ NPObject* m_pluginElementNPObject;
+
+ // Hold an activity when the plugin is visible to prevent throttling.
+ UserActivity m_visiblityActivity;
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/PluginControllerProxy.messages.in webkitgtk-2.36.7/Source/WebKit/PluginProcess/PluginControllerProxy.messages.in
--- webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/PluginControllerProxy.messages.in 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/PluginProcess/PluginControllerProxy.messages.in 2022-08-26 14:18:14.977022313 -0500
@@ -0,0 +1,143 @@
+# Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+messages -> PluginControllerProxy LegacyReceiver NotRefCounted {
+ # Sent when the plug-in geometry changes.
+ GeometryDidChange(WebCore::IntSize pluginSize, WebCore::IntRect clipRect, WebCore::AffineTransform pluginToRootViewTransform, float scaleFactor, WebKit::ShareableBitmap::Handle backingStoreHandle)
+
+ # Sent when the plug-in visibility changes.
+ VisibilityDidChange(bool isVisible)
+
+ # Sent when a frame has finished loading.
+ FrameDidFinishLoading(uint64_t requestID)
+
+ # Sent when a frame dfailed to load.
+ FrameDidFail(uint64_t requestID, bool wasCancelled)
+
+ # Sent when JavaScript that the plug-in asked to be evaluated has been evaluated.
+ DidEvaluateJavaScript(uint64_t requestID, String result)
+
+ # Sent when the plug-in receives will send a request for a stream.
+ StreamWillSendRequest(uint64_t streamID, String requestURLString, String redirectResponseURLString, uint32_t redirectResponseStatusCode)
+
+ # Sent when the plug-in receives a response for a stream.
+ StreamDidReceiveResponse(uint64_t streamID, String responseURLString, uint32_t streamLength, uint32_t lastModifiedTime, String mimeType, String headers)
+
+ # Sent when the plug-in receives data for a stream.
+ StreamDidReceiveData(uint64_t streamID, IPC::DataReference data)
+
+ # Sent when a plug-in stream has finishes loading.
+ StreamDidFinishLoading(uint64_t streamID)
+
+ # Sent when a plug-in stream has failed to load.
+ StreamDidFail(uint64_t streamID, bool wasCancelled)
+
+ # Sent when the plug-in receives a response for the manual stream.
+ ManualStreamDidReceiveResponse(String responseURLString, uint32_t streamLength, uint32_t lastModifiedTime, String mimeType, String headers)
+
+ # Sent when the plug-in receives data for the manual stream.
+ ManualStreamDidReceiveData(IPC::DataReference data)
+
+ # Sent when the plug-in manual stream has finishes loading.
+ ManualStreamDidFinishLoading()
+
+ # Sent when the plug-in manual stream has failed to load.
+ ManualStreamDidFail(bool wasCancelled)
+
+ # Sent when a mouse event (that isn't a mouse enter/leave event or a wheel event) should be processed.
+ HandleMouseEvent(WebKit::WebMouseEvent mouseEvent)
+
+ # Sent when a mouse wheel event should be processed.
+ HandleWheelEvent(WebKit::WebWheelEvent wheelEvent) -> (bool handled) Synchronous
+
+ # Sent when a mouse enter event should be processed.
+ HandleMouseEnterEvent(WebKit::WebMouseEvent mouseEvent) -> (bool handled) Synchronous
+
+ # Sent when a mouse leave event should be processed.
+ HandleMouseLeaveEvent(WebKit::WebMouseEvent mouseEvent) -> (bool handled) Synchronous
+
+ # Sent when a keyboard should be processed.
+ HandleKeyboardEvent(WebKit::WebKeyboardEvent keyboardEvent) -> (bool handled) Synchronous
+
+ # Sent when an editing command should be processed.
+ HandleEditingCommand(String commandName, String argument) -> (bool handled) Synchronous
+
+ # Return whether or not a plugin wants to enable the given editing command.
+ IsEditingCommandEnabled(String commandName) -> (bool enabled) Synchronous
+
+ # Return whether or not a plugin wants to handle page scale factor itself.
+ HandlesPageScaleFactor() -> (bool enabled) Synchronous
+
+ # Return whether or not a plugin wants page scale, page zoom, and text zoom all to affect page scale.
+ RequiresUnifiedScaleFactor() -> (bool required) Synchronous
+
+ # Sent when the plug-in focus changes.
+ SetFocus(bool isFocused)
+
+ # Sent when the update requested by Update has been painted.
+ DidUpdate()
+
+ # Paint the entire plug-in.
+ PaintEntirePlugin() -> () Synchronous
+
+ # Get a reference to the plug-in's scriptable NPObject.
+ GetPluginScriptableNPObject() -> (uint64_t pluginScriptableNPObjectID) Synchronous
+
+ # Sent when the containing NSWindow's focus changes
+ WindowFocusChanged(bool hasFocus)
+
+ # Sent when the containing NSWindow's visibility changes
+ WindowVisibilityChanged(bool isVisible)
+
+#if PLATFORM(COCOA)
+ # Send the complex text input to the plug-in.
+ SendComplexTextInput(String textInput)
+
+ # Sent when the containing NSWindow or NSView frame changes
+ WindowAndViewFramesChanged(WebCore::IntRect windowFrameInScreenCoordinates, WebCore::IntRect viewFrameInWindowCoordinates)
+
+ # Sent when the containing window's layer hosting mode changes
+ SetLayerHostingMode(uint32_t layerHostingMode)
+#endif
+
+ # Does the plugin support snapshotting?
+ SupportsSnapshotting() -> (bool isSupported) Synchronous
+
+ # Return a snapshot of the plugin.
+ Snapshot() -> (WebKit::ShareableBitmap::Handle backingStoreHandle) Synchronous
+
+ # Sent when storage blocking policy changes
+ StorageBlockingStateChanged(bool storageBlockingEnabled)
+
+ # Sent when private browsing is enabled or disabled
+ PrivateBrowsingStateChanged(bool isPrivateBrowsingEnabled)
+
+ # Gets the string representating the form value of the plug-in
+ GetFormValue() -> (bool returnValue, String formValue) Synchronous
+
+ # Sent when the browser wants to mute or unmute the plugin.
+ MutedStateChanged(bool muted)
+}
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/PluginCreationParameters.cpp webkitgtk-2.36.7/Source/WebKit/PluginProcess/PluginCreationParameters.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/PluginCreationParameters.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/PluginProcess/PluginCreationParameters.cpp 2022-08-26 14:18:14.977022313 -0500
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2011 Apple 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 INC. 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 INC. 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 "config.h"
+#include "PluginCreationParameters.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "ArgumentCoders.h"
+
+namespace WebKit {
+
+PluginCreationParameters::PluginCreationParameters()
+ : pluginInstanceID(0)
+ , windowNPObjectID(0)
+ , contentsScaleFactor(1)
+ , isPrivateBrowsingEnabled(false)
+ , isMuted(false)
+ , asynchronousCreationIncomplete(false)
+ , artificialPluginInitializationDelayEnabled(false)
+ , isAcceleratedCompositingEnabled(false)
+{
+}
+
+void PluginCreationParameters::encode(IPC::Encoder& encoder) const
+{
+ encoder << pluginInstanceID;
+ encoder << windowNPObjectID;
+ encoder << parameters;
+ encoder << userAgent;
+ encoder << contentsScaleFactor;
+ encoder << isPrivateBrowsingEnabled;
+ encoder << isMuted;
+ encoder << asynchronousCreationIncomplete;
+ encoder << artificialPluginInitializationDelayEnabled;
+ encoder << isAcceleratedCompositingEnabled;
+}
+
+bool PluginCreationParameters::decode(IPC::Decoder& decoder, PluginCreationParameters& result)
+{
+ if (!decoder.decode(result.pluginInstanceID) || !result.pluginInstanceID)
+ return false;
+
+ if (!decoder.decode(result.windowNPObjectID))
+ return false;
+
+ if (!decoder.decode(result.parameters))
+ return false;
+
+ if (!decoder.decode(result.userAgent))
+ return false;
+
+ if (!decoder.decode(result.contentsScaleFactor))
+ return false;
+
+ if (!decoder.decode(result.isPrivateBrowsingEnabled))
+ return false;
+
+ if (!decoder.decode(result.isMuted))
+ return false;
+
+ if (!decoder.decode(result.asynchronousCreationIncomplete))
+ return false;
+
+ if (!decoder.decode(result.artificialPluginInitializationDelayEnabled))
+ return false;
+
+ if (!decoder.decode(result.isAcceleratedCompositingEnabled))
+ return false;
+
+ return true;
+}
+
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/PluginCreationParameters.h webkitgtk-2.36.7/Source/WebKit/PluginProcess/PluginCreationParameters.h
--- webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/PluginCreationParameters.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/PluginProcess/PluginCreationParameters.h 2022-08-26 14:18:14.977022313 -0500
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2011 Apple 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 INC. 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 INC. 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.
+ */
+
+#ifndef PluginCreationParameters_h
+#define PluginCreationParameters_h
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "Plugin.h"
+
+namespace IPC {
+class Decoder;
+class Encoder;
+}
+
+namespace WebKit {
+
+struct PluginCreationParameters {
+ WTF_MAKE_FAST_ALLOCATED;
+public:
+ PluginCreationParameters();
+
+ void encode(IPC::Encoder&) const;
+ static WARN_UNUSED_RETURN bool decode(IPC::Decoder&, PluginCreationParameters&);
+
+ // The unique ID of this plug-in instance.
+ uint64_t pluginInstanceID;
+
+ // The ID of the window NPObject.
+ uint64_t windowNPObjectID;
+
+ // The parameters passed to the plug-in.
+ Plugin::Parameters parameters;
+
+ // The browser user agent.
+ String userAgent;
+
+ // The current contents scale factor that this plug-in should have.
+ float contentsScaleFactor;
+
+ // Whether private browsing is enabled at the time of instantiation.
+ bool isPrivateBrowsingEnabled;
+
+ // Whether the plugin should be muted.
+ bool isMuted;
+
+ // If requesting synchronous initialization, whether this plugin had previously been requested asynchronously
+ bool asynchronousCreationIncomplete;
+
+ // Simulated initialization delay test asynchronous plugin initialization
+ bool artificialPluginInitializationDelayEnabled;
+
+ // Whether accelerated compositing is enabled.
+ bool isAcceleratedCompositingEnabled;
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif // PluginCreationParameters_h
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/PluginProcess.cpp webkitgtk-2.36.7/Source/WebKit/PluginProcess/PluginProcess.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/PluginProcess.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/PluginProcess/PluginProcess.cpp 2022-08-26 14:18:14.977022313 -0500
@@ -0,0 +1,270 @@
+/*
+ * Copyright (C) 2010-2018 Apple 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 INC. 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 INC. 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 "config.h"
+#include "PluginProcess.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "ArgumentCoders.h"
+#include "Attachment.h"
+#include "AuxiliaryProcessMessages.h"
+#include "NetscapePlugin.h"
+#include "NetscapePluginModule.h"
+#include "PluginProcessConnectionMessages.h"
+#include "PluginProcessCreationParameters.h"
+#include "PluginProcessProxyMessages.h"
+#include "WebProcessConnection.h"
+#include <WebCore/NetworkStorageSession.h>
+#include <WebCore/NotImplemented.h>
+#include <unistd.h>
+#include <wtf/MemoryPressureHandler.h>
+#include <wtf/NeverDestroyed.h>
+#include <wtf/ProcessPrivilege.h>
+#include <wtf/RunLoop.h>
+
+#if PLATFORM(MAC)
+#include <crt_externs.h>
+#endif
+
+namespace WebKit {
+
+using namespace WebCore;
+
+NO_RETURN static void callExit(IPC::Connection*)
+{
+ _exit(EXIT_SUCCESS);
+}
+
+PluginProcess& PluginProcess::singleton()
+{
+ static NeverDestroyed<PluginProcess> pluginProcess;
+ return pluginProcess;
+}
+
+PluginProcess::PluginProcess()
+ : m_supportsAsynchronousPluginInitialization(false)
+ , m_minimumLifetimeTimer(RunLoop::main(), this, &PluginProcess::minimumLifetimeTimerFired)
+ , m_connectionActivity("PluginProcess connection activity.")
+{
+ NetscapePlugin::setSetExceptionFunction(WebProcessConnection::setGlobalException);
+}
+
+PluginProcess::~PluginProcess()
+{
+}
+
+void PluginProcess::initializeProcess(const AuxiliaryProcessInitializationParameters& parameters)
+{
+ WTF::setProcessPrivileges(allPrivileges());
+ WebCore::NetworkStorageSession::permitProcessToUseCookieAPI(true);
+ m_pluginPath = parameters.extraInitializationData.get("plugin-path");
+ platformInitializeProcess(parameters);
+}
+
+void PluginProcess::initializeConnection(IPC::Connection* connection)
+{
+ AuxiliaryProcess::initializeConnection(connection);
+
+ // We call _exit() directly from the background queue in case the main thread is unresponsive
+ // and AuxiliaryProcess::didClose() does not get called.
+ connection->setDidCloseOnConnectionWorkQueueCallback(callExit);
+}
+
+void PluginProcess::removeWebProcessConnection(WebProcessConnection* webProcessConnection)
+{
+ size_t vectorIndex = m_webProcessConnections.find(webProcessConnection);
+ ASSERT(vectorIndex != notFound);
+
+ m_webProcessConnections.remove(vectorIndex);
+
+ if (m_webProcessConnections.isEmpty() && m_pluginModule) {
+ // Decrement the load count. This is balanced by a call to incrementLoadCount in createWebProcessConnection.
+ m_pluginModule->decrementLoadCount();
+ }
+
+ enableTermination();
+}
+
+NetscapePluginModule* PluginProcess::netscapePluginModule()
+{
+ if (!m_pluginModule) {
+ ASSERT(!m_pluginPath.isNull());
+ m_pluginModule = NetscapePluginModule::getOrCreate(m_pluginPath);
+
+#if PLATFORM(MAC)
+ if (m_pluginModule) {
+ if (m_pluginModule->pluginQuirks().contains(PluginQuirks::PrognameShouldBeWebKitPluginHost))
+ *const_cast<const char**>(_NSGetProgname()) = "WebKitPluginHost";
+ }
+#endif
+ }
+
+ return m_pluginModule.get();
+}
+
+bool PluginProcess::shouldTerminate()
+{
+ return m_webProcessConnections.isEmpty();
+}
+
+void PluginProcess::didReceiveMessage(IPC::Connection& connection, IPC::Decoder& decoder)
+{
+#if OS(LINUX)
+ if (decoder.messageReceiverName() == Messages::AuxiliaryProcess::messageReceiverName()) {
+ AuxiliaryProcess::didReceiveMessage(connection, decoder);
+ return;
+ }
+#endif
+
+ didReceivePluginProcessMessage(connection, decoder);
+}
+
+void PluginProcess::initializePluginProcess(PluginProcessCreationParameters&& parameters)
+{
+ ASSERT(!m_pluginModule);
+
+ auto& memoryPressureHandler = MemoryPressureHandler::singleton();
+ memoryPressureHandler.setLowMemoryHandler([this] (Critical, Synchronous) {
+ if (shouldTerminate())
+ terminate();
+ });
+ memoryPressureHandler.install();
+
+ m_supportsAsynchronousPluginInitialization = parameters.supportsAsynchronousPluginInitialization;
+ setMinimumLifetime(parameters.minimumLifetime);
+ setTerminationTimeout(parameters.terminationTimeout);
+
+ platformInitializePluginProcess(WTFMove(parameters));
+}
+
+void PluginProcess::createWebProcessConnection()
+{
+ // FIXME: Merge this with AuxiliaryProcess::createIPCConnectionPair().
+
+ bool didHaveAnyWebProcessConnections = !m_webProcessConnections.isEmpty();
+
+#if USE(UNIX_DOMAIN_SOCKETS)
+ IPC::Connection::SocketPair socketPair = IPC::Connection::createPlatformConnection();
+
+ auto connection = WebProcessConnection::create(socketPair.server);
+ m_webProcessConnections.append(WTFMove(connection));
+
+ IPC::Attachment clientSocket(socketPair.client);
+ parentProcessConnection()->send(Messages::PluginProcessProxy::DidCreateWebProcessConnection(clientSocket, m_supportsAsynchronousPluginInitialization), 0);
+#elif OS(DARWIN)
+ // Create the listening port.
+ mach_port_t listeningPort = MACH_PORT_NULL;
+ auto kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &listeningPort);
+ if (kr != KERN_SUCCESS) {
+ LOG_ERROR("Could not allocate mach port, error %x", kr);
+ CRASH();
+ }
+
+ // Create a listening connection.
+ auto connection = WebProcessConnection::create(IPC::Connection::Identifier(listeningPort));
+
+ m_webProcessConnections.append(WTFMove(connection));
+
+ IPC::Attachment clientPort(listeningPort, MACH_MSG_TYPE_MAKE_SEND);
+ parentProcessConnection()->send(Messages::PluginProcessProxy::DidCreateWebProcessConnection(clientPort, m_supportsAsynchronousPluginInitialization), 0);
+#else
+ notImplemented();
+#endif
+
+ if (NetscapePluginModule* module = netscapePluginModule()) {
+ if (!didHaveAnyWebProcessConnections) {
+ // Increment the load count. This is matched by a call to decrementLoadCount in removeWebProcessConnection.
+ // We do this so that the plug-in module's NP_Shutdown won't be called until right before exiting.
+ module->incrementLoadCount();
+ }
+ }
+
+ disableTermination();
+}
+
+void PluginProcess::getSitesWithData(uint64_t callbackID)
+{
+ Vector<String> sites;
+ if (NetscapePluginModule* module = netscapePluginModule())
+ sites = module->sitesWithData();
+
+ parentProcessConnection()->send(Messages::PluginProcessProxy::DidGetSitesWithData(sites, callbackID), 0);
+}
+
+void PluginProcess::deleteWebsiteData(WallTime modifiedSince, uint64_t callbackID)
+{
+ if (auto* module = netscapePluginModule()) {
+ auto currentTime = WallTime::now();
+
+ if (currentTime > modifiedSince) {
+ uint64_t maximumAge = (currentTime - modifiedSince).secondsAs<uint64_t>();
+
+ module->clearSiteData(String(), NP_CLEAR_ALL, maximumAge);
+ }
+ }
+
+ parentProcessConnection()->send(Messages::PluginProcessProxy::DidDeleteWebsiteData(callbackID), 0);
+}
+
+void PluginProcess::deleteWebsiteDataForHostNames(const Vector<String>& hostNames, uint64_t callbackID)
+{
+ if (auto* module = netscapePluginModule()) {
+ for (auto& hostName : hostNames)
+ module->clearSiteData(hostName, NP_CLEAR_ALL, std::numeric_limits<uint64_t>::max());
+ }
+
+ parentProcessConnection()->send(Messages::PluginProcessProxy::DidDeleteWebsiteDataForHostNames(callbackID), 0);
+}
+
+void PluginProcess::setMinimumLifetime(Seconds lifetime)
+{
+ if (lifetime <= 0_s)
+ return;
+
+ disableTermination();
+
+ m_minimumLifetimeTimer.startOneShot(lifetime);
+}
+
+void PluginProcess::minimumLifetimeTimerFired()
+{
+ enableTermination();
+}
+
+#if !PLATFORM(COCOA)
+void PluginProcess::initializeProcessName(const AuxiliaryProcessInitializationParameters&)
+{
+}
+
+void PluginProcess::initializeSandbox(const AuxiliaryProcessInitializationParameters&, SandboxInitializationParameters&)
+{
+}
+#endif
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/PluginProcess.h webkitgtk-2.36.7/Source/WebKit/PluginProcess/PluginProcess.h
--- webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/PluginProcess.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/PluginProcess/PluginProcess.h 2022-08-26 14:18:14.977022313 -0500
@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2010-2018 Apple 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 INC. 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 INC. 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.
+ */
+
+#pragma once
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "AuxiliaryProcess.h"
+#include <WebCore/CountedUserActivity.h>
+#include <wtf/Forward.h>
+#include <wtf/text/WTFString.h>
+
+#if PLATFORM(COCOA)
+#include <wtf/MachSendRight.h>
+#endif
+
+namespace WebKit {
+
+class NetscapePluginModule;
+class WebProcessConnection;
+struct PluginProcessCreationParameters;
+
+class PluginProcess : public AuxiliaryProcess
+{
+ WTF_MAKE_NONCOPYABLE(PluginProcess);
+ friend NeverDestroyed<PluginProcess>;
+
+public:
+ static PluginProcess& singleton();
+ static constexpr WebCore::AuxiliaryProcessType processType = WebCore::AuxiliaryProcessType::Plugin;
+
+ void removeWebProcessConnection(WebProcessConnection*);
+
+ NetscapePluginModule* netscapePluginModule();
+
+ const String& pluginPath() const { return m_pluginPath; }
+
+#if PLATFORM(COCOA)
+ void setModalWindowIsShowing(bool);
+ void setFullscreenWindowIsShowing(bool);
+
+ const WTF::MachSendRight& compositingRenderServerPort() const { return m_compositingRenderServerPort; }
+
+ bool launchProcess(const String& launchPath, const Vector<String>& arguments);
+ bool launchApplicationAtURL(const String& urlString, const Vector<String>& arguments);
+ bool openURL(const String& urlString, int32_t& status, String& launchedURLString);
+ bool openFile(const String& urlString);
+#endif
+
+ CountedUserActivity& connectionActivity() { return m_connectionActivity; }
+
+private:
+ PluginProcess();
+ ~PluginProcess();
+
+#if PLATFORM(MAC)
+ bool shouldOverrideQuarantine() final;
+#endif
+
+ // AuxiliaryProcess
+ void initializeProcess(const AuxiliaryProcessInitializationParameters&) override;
+ void initializeProcessName(const AuxiliaryProcessInitializationParameters&) override;
+ void initializeConnection(IPC::Connection*) override;
+ void initializeSandbox(const AuxiliaryProcessInitializationParameters&, SandboxInitializationParameters&) override;
+ bool shouldTerminate() override;
+ void platformInitializeProcess(const AuxiliaryProcessInitializationParameters&);
+
+#if USE(APPKIT)
+ void stopRunLoop() override;
+#endif
+
+ // IPC::Connection::Client
+ void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
+
+ // Message handlers.
+ void didReceivePluginProcessMessage(IPC::Connection&, IPC::Decoder&);
+ void initializePluginProcess(PluginProcessCreationParameters&&);
+ void createWebProcessConnection();
+
+ void getSitesWithData(uint64_t callbackID);
+ void deleteWebsiteData(WallTime modifiedSince, uint64_t callbackID);
+ void deleteWebsiteDataForHostNames(const Vector<String>& hostNames, uint64_t callbackID);
+
+ void platformInitializePluginProcess(PluginProcessCreationParameters&&);
+
+ void setMinimumLifetime(Seconds);
+ void minimumLifetimeTimerFired();
+ // Our web process connections.
+ Vector<RefPtr<WebProcessConnection>> m_webProcessConnections;
+
+ // The plug-in path.
+ String m_pluginPath;
+
+#if PLATFORM(COCOA)
+ String m_pluginBundleIdentifier;
+#endif
+
+ // The plug-in module.
+ RefPtr<NetscapePluginModule> m_pluginModule;
+
+ bool m_supportsAsynchronousPluginInitialization;
+
+ RunLoop::Timer<PluginProcess> m_minimumLifetimeTimer;
+
+#if PLATFORM(COCOA)
+ // The Mach port used for accelerated compositing.
+ WTF::MachSendRight m_compositingRenderServerPort;
+
+ String m_nsurlCacheDirectory;
+#endif
+
+ CountedUserActivity m_connectionActivity;
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/PluginProcess.messages.in webkitgtk-2.36.7/Source/WebKit/PluginProcess/PluginProcess.messages.in
--- webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/PluginProcess.messages.in 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/PluginProcess/PluginProcess.messages.in 2022-08-26 14:18:14.977022313 -0500
@@ -0,0 +1,46 @@
+# Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+messages -> PluginProcess LegacyReceiver NotRefCounted {
+ # Initializes the plug-in process.
+ InitializePluginProcess(struct WebKit::PluginProcessCreationParameters processCreationParameters)
+
+ # Creates a web process connection. When the connection has been created,
+ # The plug-in process sends back a DidCreateWebProcessConnection message with
+ # a connection identifier.
+ CreateWebProcessConnection()
+
+ # Asks the plug-in process for sites with data. The plug-in process sends back a
+ # DidGetSitesWithData message with the sites.
+ GetSitesWithData(uint64_t callbackID)
+
+ DeleteWebsiteData(WallTime modifiedSince, uint64_t callbackID)
+ DeleteWebsiteDataForHostNames(Vector<String> hostNames, uint64_t callbackID)
+
+#if PLATFORM(COCOA)
+ SetQOS(int latencyQOS, int throughputQOS)
+#endif
+}
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/unix/PluginControllerProxyUnix.cpp webkitgtk-2.36.7/Source/WebKit/PluginProcess/unix/PluginControllerProxyUnix.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/unix/PluginControllerProxyUnix.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/PluginProcess/unix/PluginControllerProxyUnix.cpp 2022-08-26 14:18:14.977022313 -0500
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2011 Igalia S.L.
+ *
+ * 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 INC. 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 INC. 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 "config.h"
+#include "PluginControllerProxy.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include <WebCore/NotImplemented.h>
+
+namespace WebKit {
+using namespace WebCore;
+
+void PluginControllerProxy::platformInitialize(const PluginCreationParameters&)
+{
+ notImplemented();
+}
+
+void PluginControllerProxy::platformDestroy()
+{
+ notImplemented();
+}
+
+void PluginControllerProxy::platformGeometryDidChange()
+{
+ notImplemented();
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/unix/PluginProcessMainUnix.cpp webkitgtk-2.36.7/Source/WebKit/PluginProcess/unix/PluginProcessMainUnix.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/unix/PluginProcessMainUnix.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/PluginProcess/unix/PluginProcessMainUnix.cpp 2022-08-26 14:18:14.977022313 -0500
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2011, 2014 Igalia S.L.
+ * Copyright (C) 2011 Apple Inc.
+ * Copyright (C) 2012 Samsung Electronics
+ *
+ * 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT OWNER OR 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 "config.h"
+#include "PluginProcessMain.h"
+
+#if ENABLE(PLUGIN_PROCESS)
+
+#include "AuxiliaryProcessMain.h"
+#include "Logging.h"
+#include "NetscapePlugin.h"
+#include "PluginProcess.h"
+#include <stdlib.h>
+#include <wtf/FileSystem.h>
+
+#if PLATFORM(GTK)
+#include <gtk/gtk.h>
+#endif
+
+#if PLATFORM(X11)
+#include <WebCore/PlatformDisplayX11.h>
+#include <WebCore/XErrorTrapper.h>
+#include <wtf/NeverDestroyed.h>
+#endif
+
+namespace WebKit {
+
+#if PLATFORM(X11)
+static LazyNeverDestroyed<WebCore::XErrorTrapper> xErrorTrapper;
+#endif
+
+class PluginProcessMainUnix final: public AuxiliaryProcessMainBase<PluginProcess> {
+public:
+ bool platformInitialize() override
+ {
+#if PLATFORM(GTK)
+ gtk_init(nullptr, nullptr);
+#endif
+
+ return true;
+ }
+
+ bool parseCommandLine(int argc, char** argv) override
+ {
+ ASSERT(argc > 2);
+ if (argc < 3)
+ return false;
+
+ if (!strcmp(argv[1], "-scanPlugin")) {
+ ASSERT(argc == 3);
+#if PLUGIN_ARCHITECTURE(UNIX)
+ InitializeWebKit2();
+ exit(NetscapePluginModule::scanPlugin(argv[2]) ? EXIT_SUCCESS : EXIT_FAILURE);
+#else
+ exit(EXIT_FAILURE);
+#endif
+ }
+
+ ASSERT(argc == 4);
+#if PLATFORM(X11)
+ if (WebCore::PlatformDisplay::sharedDisplay().type() == WebCore::PlatformDisplay::Type::X11) {
+ auto* display = downcast<WebCore::PlatformDisplayX11>(WebCore::PlatformDisplay::sharedDisplay()).native();
+ xErrorTrapper.construct(display, WebCore::XErrorTrapper::Policy::Warn);
+ }
+#endif
+
+ m_parameters.extraInitializationData.add("plugin-path", argv[3]);
+ return AuxiliaryProcessMainBase::parseCommandLine(argc, argv);
+ }
+};
+
+int PluginProcessMain(int argc, char** argv)
+{
+ return AuxiliaryProcessMain<PluginProcessMainUnix>(argc, argv);
+}
+
+} // namespace WebKit
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/unix/PluginProcessUnix.cpp webkitgtk-2.36.7/Source/WebKit/PluginProcess/unix/PluginProcessUnix.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/unix/PluginProcessUnix.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/PluginProcess/unix/PluginProcessUnix.cpp 2022-08-26 14:18:14.977022313 -0500
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2011 Igalia S.L.
+ *
+ * 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 INC. 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 INC. 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 "config.h"
+#include "PluginProcess.h"
+
+#if ENABLE(PLUGIN_PROCESS)
+
+#include "PluginProcessCreationParameters.h"
+#include <WebCore/NotImplemented.h>
+
+namespace WebKit {
+
+void PluginProcess::platformInitializeProcess(const AuxiliaryProcessInitializationParameters&)
+{
+}
+
+void PluginProcess::platformInitializePluginProcess(PluginProcessCreationParameters&&)
+{
+ notImplemented();
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(PLUGIN_PROCESS)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/WebProcessConnection.cpp webkitgtk-2.36.7/Source/WebKit/PluginProcess/WebProcessConnection.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/WebProcessConnection.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/PluginProcess/WebProcessConnection.cpp 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,328 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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 "config.h"
+#include "WebProcessConnection.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "ActivityAssertion.h"
+#include "ArgumentCoders.h"
+#include "NPObjectMessageReceiverMessages.h"
+#include "NPRemoteObjectMap.h"
+#include "PluginControllerProxy.h"
+#include "PluginCreationParameters.h"
+#include "PluginProcess.h"
+#include "PluginProcessConnectionMessages.h"
+#include "PluginProxyMessages.h"
+#include "WebProcessConnectionMessages.h"
+#include <wtf/SetForScope.h>
+
+#if !OS(WINDOWS)
+#include <unistd.h>
+#endif
+
+namespace WebKit {
+using namespace WebCore;
+
+static IPC::Connection* currentConnection;
+
+Ref<WebProcessConnection> WebProcessConnection::create(IPC::Connection::Identifier connectionIdentifier)
+{
+ return adoptRef(*new WebProcessConnection(connectionIdentifier));
+}
+
+WebProcessConnection::~WebProcessConnection()
+{
+ ASSERT(m_pluginControllers.isEmpty());
+ ASSERT(!m_npRemoteObjectMap);
+ ASSERT(!m_connection);
+}
+
+WebProcessConnection::WebProcessConnection(IPC::Connection::Identifier connectionIdentifier)
+{
+ m_connection = IPC::Connection::createServerConnection(connectionIdentifier, *this);
+ m_npRemoteObjectMap = NPRemoteObjectMap::create(m_connection.get());
+
+ // Use this flag to force synchronous messages to be treated as asynchronous messages in the WebProcess.
+ // Otherwise, the WebProcess would process incoming synchronous IPC while waiting for a synchronous IPC
+ // reply from the Plugin process, which would be unsafe.
+ m_connection->setOnlySendMessagesAsDispatchWhenWaitingForSyncReplyWhenProcessingSuchAMessage(true);
+ m_connection->open();
+}
+
+void WebProcessConnection::addPluginControllerProxy(std::unique_ptr<PluginControllerProxy> pluginController)
+{
+ uint64_t pluginInstanceID = pluginController->pluginInstanceID();
+
+ ASSERT(!m_pluginControllers.contains(pluginInstanceID));
+ m_pluginControllers.set(pluginInstanceID, WTFMove(pluginController));
+}
+
+void WebProcessConnection::destroyPluginControllerProxy(PluginControllerProxy* pluginController)
+{
+ // This may end up calling removePluginControllerProxy which ends up deleting
+ // the WebProcessConnection object if this was the last object.
+ pluginController->destroy();
+}
+
+void WebProcessConnection::removePluginControllerProxy(PluginControllerProxy* pluginController, Plugin* plugin)
+{
+ unsigned pluginInstanceID = pluginController->pluginInstanceID();
+ {
+ ASSERT(m_pluginControllers.contains(pluginInstanceID));
+
+ std::unique_ptr<PluginControllerProxy> pluginControllerUniquePtr = m_pluginControllers.take(pluginInstanceID);
+ ASSERT(pluginControllerUniquePtr.get() == pluginController);
+ }
+
+ // Invalidate all objects related to this plug-in.
+ if (plugin)
+ m_npRemoteObjectMap->pluginDestroyed(plugin);
+
+ if (!m_pluginControllers.isEmpty())
+ return;
+
+ m_npRemoteObjectMap = nullptr;
+
+ // The last plug-in went away, close this connection.
+ m_connection->invalidate();
+ m_connection = nullptr;
+
+ // This will cause us to be deleted.
+ PluginProcess::singleton().removeWebProcessConnection(this);
+}
+
+void WebProcessConnection::setGlobalException(const String& exceptionString)
+{
+ if (!currentConnection)
+ return;
+
+ currentConnection->sendSync(Messages::PluginProcessConnection::SetException(exceptionString), Messages::PluginProcessConnection::SetException::Reply(), 0);
+}
+
+void WebProcessConnection::didReceiveMessage(IPC::Connection& connection, IPC::Decoder& decoder)
+{
+ SetForScope<IPC::Connection*> currentConnectionChange(currentConnection, &connection);
+
+ if (decoder.messageReceiverName() == Messages::WebProcessConnection::messageReceiverName()) {
+ didReceiveWebProcessConnectionMessage(connection, decoder);
+ return;
+ }
+
+ if (!decoder.destinationID()) {
+ ASSERT_NOT_REACHED();
+ return;
+ }
+
+ PluginControllerProxy* pluginControllerProxy = m_pluginControllers.get(decoder.destinationID());
+ if (!pluginControllerProxy)
+ return;
+
+ PluginController::PluginDestructionProtector protector(pluginControllerProxy->asPluginController());
+ pluginControllerProxy->didReceivePluginControllerProxyMessage(connection, decoder);
+}
+
+bool WebProcessConnection::didReceiveSyncMessage(IPC::Connection& connection, IPC::Decoder& decoder, UniqueRef<IPC::Encoder>& replyEncoder)
+{
+ SetForScope<IPC::Connection*> currentConnectionChange(currentConnection, &connection);
+
+ uint64_t destinationID = decoder.destinationID();
+
+ if (!destinationID)
+ return didReceiveSyncWebProcessConnectionMessage(connection, decoder, replyEncoder);
+
+ if (decoder.messageReceiverName() == Messages::NPObjectMessageReceiver::messageReceiverName())
+ return m_npRemoteObjectMap->didReceiveSyncMessage(connection, decoder, replyEncoder);
+
+ PluginControllerProxy* pluginControllerProxy = m_pluginControllers.get(decoder.destinationID());
+ if (!pluginControllerProxy)
+ return false;
+
+ PluginController::PluginDestructionProtector protector(pluginControllerProxy->asPluginController());
+ return pluginControllerProxy->didReceiveSyncPluginControllerProxyMessage(connection, decoder, replyEncoder);
+}
+
+void WebProcessConnection::didClose(IPC::Connection&)
+{
+ // The web process crashed. Destroy all the plug-in controllers. Destroying the last plug-in controller
+ // will cause the web process connection itself to be destroyed.
+ Vector<PluginControllerProxy*> pluginControllers;
+ for (auto it = m_pluginControllers.values().begin(), end = m_pluginControllers.values().end(); it != end; ++it)
+ pluginControllers.append(it->get());
+
+ for (size_t i = 0; i < pluginControllers.size(); ++i)
+ destroyPluginControllerProxy(pluginControllers[i]);
+}
+
+void WebProcessConnection::destroyPlugin(uint64_t pluginInstanceID, bool asynchronousCreationIncomplete, Messages::WebProcessConnection::DestroyPlugin::DelayedReply&& reply)
+{
+ // We return immediately from this synchronous IPC. We want to make sure the plugin destruction is just about to start so audio playback
+ // will finish soon after returning. However we don't want to wait for destruction to complete fully as that may take a while.
+ reply();
+
+ // Ensure we don't clamp any timers during destruction
+ ActivityAssertion activityAssertion(PluginProcess::singleton().connectionActivity());
+
+ PluginControllerProxy* pluginControllerProxy = m_pluginControllers.get(pluginInstanceID);
+
+ // If there is no PluginControllerProxy then this plug-in doesn't exist yet and we probably have nothing to do.
+ if (!pluginControllerProxy) {
+ // If the plugin we're supposed to destroy was requested asynchronously and doesn't exist yet,
+ // we need to flag the instance ID so it is not created later.
+ if (asynchronousCreationIncomplete)
+ m_asynchronousInstanceIDsToIgnore.add(pluginInstanceID);
+
+ return;
+ }
+
+ destroyPluginControllerProxy(pluginControllerProxy);
+}
+
+void WebProcessConnection::didReceiveInvalidMessage(IPC::Connection&, IPC::MessageName)
+{
+ // FIXME: Implement.
+}
+
+void WebProcessConnection::createPluginInternal(const PluginCreationParameters& creationParameters, bool& result, bool& wantsWheelEvents, uint32_t& remoteLayerClientID)
+{
+ auto pluginControllerProxy = makeUnique<PluginControllerProxy>(this, creationParameters);
+
+ PluginControllerProxy* pluginControllerProxyPtr = pluginControllerProxy.get();
+
+ // Make sure to add the proxy to the map before initializing it, since the plug-in might call out to the web process from
+ // its NPP_New function. This will hand over ownership of the proxy to the web process connection.
+ addPluginControllerProxy(WTFMove(pluginControllerProxy));
+
+ // Now try to initialize the plug-in.
+ result = pluginControllerProxyPtr->initialize(creationParameters);
+
+ if (!result)
+ return;
+
+ wantsWheelEvents = pluginControllerProxyPtr->wantsWheelEvents();
+#if PLATFORM(COCOA)
+ remoteLayerClientID = pluginControllerProxyPtr->remoteLayerClientID();
+#else
+ UNUSED_PARAM(remoteLayerClientID);
+#endif
+}
+
+void WebProcessConnection::createPlugin(const PluginCreationParameters& creationParameters, Messages::WebProcessConnection::CreatePlugin::DelayedReply&& reply)
+{
+ // Ensure we don't clamp any timers during initialization
+ ActivityAssertion activityAssertion(PluginProcess::singleton().connectionActivity());
+
+ PluginControllerProxy* pluginControllerProxy = m_pluginControllers.get(creationParameters.pluginInstanceID);
+
+ // The controller proxy for the plug-in we're being asked to create synchronously might already exist if it was requested asynchronously before.
+ if (pluginControllerProxy) {
+ // It might still be in the middle of initialization in which case we have to let that initialization complete and respond to this message later.
+ if (pluginControllerProxy->isInitializing()) {
+ pluginControllerProxy->setInitializationReply(WTFMove(reply));
+ return;
+ }
+
+ // If its initialization is complete then we need to respond to this message with the correct information about its creation.
+#if PLATFORM(COCOA)
+ reply(true, pluginControllerProxy->wantsWheelEvents(), pluginControllerProxy->remoteLayerClientID());
+#else
+ reply(true, pluginControllerProxy->wantsWheelEvents(), 0);
+#endif
+ return;
+ }
+
+ // The plugin we're supposed to create might have been requested asynchronously before.
+ // In that case we need to create it synchronously now but flag the instance ID so we don't recreate it asynchronously later.
+ if (creationParameters.asynchronousCreationIncomplete)
+ m_asynchronousInstanceIDsToIgnore.add(creationParameters.pluginInstanceID);
+
+ bool result = false;
+ bool wantsWheelEvents = false;
+ uint32_t remoteLayerClientID = 0;
+ createPluginInternal(creationParameters, result, wantsWheelEvents, remoteLayerClientID);
+
+ reply(result, wantsWheelEvents, remoteLayerClientID);
+}
+
+void WebProcessConnection::createPluginAsynchronously(const PluginCreationParameters& creationParameters)
+{
+ // In the time since this plugin was requested asynchronously we might have created it synchronously or destroyed it.
+ // In either of those cases we need to ignore this creation request.
+ if (m_asynchronousInstanceIDsToIgnore.contains(creationParameters.pluginInstanceID)) {
+ m_asynchronousInstanceIDsToIgnore.remove(creationParameters.pluginInstanceID);
+ return;
+ }
+
+ // This version of CreatePlugin is only used by plug-ins that are known to behave when started asynchronously.
+ bool result = false;
+ bool wantsWheelEvents = false;
+ uint32_t remoteLayerClientID = 0;
+
+ if (creationParameters.artificialPluginInitializationDelayEnabled) {
+ Seconds artificialPluginInitializationDelay { 5_s };
+ sleep(artificialPluginInitializationDelay);
+ }
+
+ // Since plug-in creation can often message to the WebProcess synchronously (with NPP_Evaluate for example)
+ // we need to make sure that the web process will handle the plug-in process's synchronous messages,
+ // even if the web process is waiting on a synchronous reply itself.
+ // Normally the plug-in process doesn't give its synchronous messages the special flag to allow for that.
+ // We can force it to do so by incrementing the "DispatchMessageMarkedDispatchWhenWaitingForSyncReply" count.
+ m_connection->incrementDispatchMessageMarkedDispatchWhenWaitingForSyncReplyCount();
+
+ // The call to createPluginInternal can potentially cause the plug-in to be destroyed and
+ // thus free the WebProcessConnection object. Protect it.
+ Ref<WebProcessConnection> protect(*this);
+ createPluginInternal(creationParameters, result, wantsWheelEvents, remoteLayerClientID);
+
+ if (!m_connection) {
+ // createPluginInternal caused the connection to go away.
+ return;
+ }
+
+ m_connection->decrementDispatchMessageMarkedDispatchWhenWaitingForSyncReplyCount();
+
+ // If someone asked for this plug-in synchronously while it was in the middle of being created then we need perform the
+ // synchronous reply instead of sending the asynchronous reply.
+ PluginControllerProxy* pluginControllerProxy = m_pluginControllers.get(creationParameters.pluginInstanceID);
+ ASSERT(pluginControllerProxy);
+ if (auto delayedSyncReply = pluginControllerProxy->takeInitializationReply()) {
+ delayedSyncReply(result, wantsWheelEvents, remoteLayerClientID);
+ return;
+ }
+
+ // Otherwise, send the asynchronous results now.
+ if (!result) {
+ m_connection->sendSync(Messages::PluginProxy::DidFailToCreatePlugin(), Messages::PluginProxy::DidFailToCreatePlugin::Reply(), creationParameters.pluginInstanceID);
+ return;
+ }
+
+ m_connection->sendSync(Messages::PluginProxy::DidCreatePlugin(wantsWheelEvents, remoteLayerClientID), Messages::PluginProxy::DidCreatePlugin::Reply(), creationParameters.pluginInstanceID);
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/WebProcessConnection.h webkitgtk-2.36.7/Source/WebKit/PluginProcess/WebProcessConnection.h
--- webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/WebProcessConnection.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/PluginProcess/WebProcessConnection.h 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+ */
+
+#pragma once
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "Connection.h"
+#include "Plugin.h"
+#include "WebProcessConnectionMessagesReplies.h"
+#include <wtf/HashSet.h>
+#include <wtf/RefCounted.h>
+
+namespace WebKit {
+
+class NPRemoteObjectMap;
+class PluginControllerProxy;
+struct PluginCreationParameters;
+
+// A connection from a plug-in process to a web process.
+
+class WebProcessConnection : public RefCounted<WebProcessConnection>, IPC::Connection::Client {
+public:
+ static Ref<WebProcessConnection> create(IPC::Connection::Identifier);
+ virtual ~WebProcessConnection();
+
+ IPC::Connection* connection() const { return m_connection.get(); }
+ NPRemoteObjectMap* npRemoteObjectMap() const { return m_npRemoteObjectMap.get(); }
+
+ void removePluginControllerProxy(PluginControllerProxy*, Plugin*);
+
+ static void setGlobalException(const String&);
+
+private:
+ WebProcessConnection(IPC::Connection::Identifier);
+
+ void addPluginControllerProxy(std::unique_ptr<PluginControllerProxy>);
+
+ void destroyPluginControllerProxy(PluginControllerProxy*);
+
+ // IPC::Connection::Client
+ void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
+ bool didReceiveSyncMessage(IPC::Connection&, IPC::Decoder&, UniqueRef<IPC::Encoder>&) override;
+ void didClose(IPC::Connection&) override;
+ void didReceiveInvalidMessage(IPC::Connection&, IPC::MessageName) override;
+
+ // Message handlers.
+ void didReceiveWebProcessConnectionMessage(IPC::Connection&, IPC::Decoder&);
+ bool didReceiveSyncWebProcessConnectionMessage(IPC::Connection&, IPC::Decoder&, UniqueRef<IPC::Encoder>&);
+ void createPlugin(const PluginCreationParameters&, Messages::WebProcessConnection::CreatePluginDelayedReply&&);
+ void createPluginAsynchronously(const PluginCreationParameters&);
+ void destroyPlugin(uint64_t pluginInstanceID, bool asynchronousCreationIncomplete, Messages::WebProcessConnection::DestroyPluginDelayedReply&&);
+
+ void createPluginInternal(const PluginCreationParameters&, bool& result, bool& wantsWheelEvents, uint32_t& remoteLayerClientID);
+
+ RefPtr<IPC::Connection> m_connection;
+
+ HashMap<uint64_t, std::unique_ptr<PluginControllerProxy>> m_pluginControllers;
+ RefPtr<NPRemoteObjectMap> m_npRemoteObjectMap;
+ HashSet<uint64_t> m_asynchronousInstanceIDsToIgnore;
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/WebProcessConnection.messages.in webkitgtk-2.36.7/Source/WebKit/PluginProcess/WebProcessConnection.messages.in
--- webkitgtk-2.36.7.orig/Source/WebKit/PluginProcess/WebProcessConnection.messages.in 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/PluginProcess/WebProcessConnection.messages.in 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,36 @@
+# Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+messages -> WebProcessConnection LegacyReceiver {
+ # Creates a plug-in instance using the given creation parameters.
+ CreatePlugin(struct WebKit::PluginCreationParameters pluginCreationParameters) -> (bool creationResult, bool wantsWheelEvents, uint32_t remoteLayerClientID) Synchronous
+
+ # Creates a plug-in instance asynchronously using the given creation parameters.
+ CreatePluginAsynchronously(struct WebKit::PluginCreationParameters pluginCreationParameters)
+
+ # Destroys the plug-in instance with the given instance ID.
+ DestroyPlugin(uint64_t pluginInstanceID, bool asynchronousCreationIncomplete) -> () Synchronous
+}
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/cn.microdone.cmb.safari.sb webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/cn.microdone.cmb.safari.sb
--- webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/cn.microdone.cmb.safari.sb 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/cn.microdone.cmb.safari.sb 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,23 @@
+; Copyright (C) 2018 Apple 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 INC. 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 INC. 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.
+
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.appstore.CodeRedeemerNetscapePlugin.sb webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.appstore.CodeRedeemerNetscapePlugin.sb
--- webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.appstore.CodeRedeemerNetscapePlugin.sb 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.appstore.CodeRedeemerNetscapePlugin.sb 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,24 @@
+; Copyright (C) 2014 Apple 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 INC. 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 INC. 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.
+
+(webkit-camera)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.BocomSubmitCtrl.sb webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.BocomSubmitCtrl.sb
--- webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.BocomSubmitCtrl.sb 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.BocomSubmitCtrl.sb 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,23 @@
+; Copyright (C) 2018 Apple 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 INC. 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 INC. 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.
+
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.ist.ds.appleconnect.webplugin.sb webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.ist.ds.appleconnect.webplugin.sb
--- webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.ist.ds.appleconnect.webplugin.sb 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.ist.ds.appleconnect.webplugin.sb 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,65 @@
+; Copyright (C) 2013, 2014 Apple 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 INC. 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 INC. 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.
+
+(allow mach-lookup
+ (global-name "com.apple.ist.ds.appleconnect2.service.admin")
+ (global-name "com.apple.ist.ds.appleconnect2.service.agent")
+ (global-name "com.apple.ist.ds.appleconnect2.service.kdctunnelcontroller")
+ (global-name "com.apple.ist.ds.appleconnect2.service.menuextra")
+ (global-name "com.apple.wifi.anqp")
+ (global-name "com.apple.GSSCred")
+ (global-name "org.h5l.kcm"))
+(allow mach-lookup
+ (global-name-regex #"^com\.apple\.ist\.ds\.appleconnect2\.service\.com\.apple\.WebKit\.Plugin\.(32|64)(\.Development)?\[[0-9]+\]$")
+ (global-name-regex #"^com\.apple\.ist\.ds\.appleconnect2\.service\.PluginProcess\[[0-9]+\]$"))
+
+(shared-preferences-read
+ "com.apple.GSS"
+ "com.apple.ist.ds.appleconnect2"
+ "com.apple.ist.ds.appleconnect2.acceptanceTest"
+ "com.apple.ist.ds.appleconnect2.production"
+ "com.apple.ist.ds.appleconnect2.uat"
+ "com.apple.Kerberos"
+ "com.apple.networkConnect"
+ "edu.mit.Kerberos")
+
+(allow file-read*
+ (subpath "/Library/KerberosPlugins/GSSAPI")
+ (subpath "/Library/KerberosPlugins/KerberosFrameworkPlugins")
+ (literal "/Library/Preferences/edu.mit.Kerberos")
+ (literal "/Library/Preferences/SystemConfiguration/preferences.plist")
+ (home-library-preferences-literal "/edu.mit.Kerberos"))
+
+(allow file-read*
+ (literal "/private/etc/services"))
+
+(if (defined? 'mach-register)
+ (allow mach-register
+ (global-name-regex #"^com\.apple\.ist\.ds\.appleconnect2\.service\.com\.apple\.WebKit\.Plugin\.(32|64)(\.Development)?\[[0-9]+\]$")
+ (global-name-regex #"^com\.apple\.ist\.ds\.appleconnect2\.service\.PluginProcess\[[0-9]+\]$")))
+
+(allow system-socket)
+(allow network-outbound
+ (remote udp "*:4160" "*:88"))
+(allow network-inbound
+ (local udp))
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.NPSafeInput.sb webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.NPSafeInput.sb
--- webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.NPSafeInput.sb 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.NPSafeInput.sb 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,32 @@
+; Copyright (C) 2018 Apple 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 INC. 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 INC. 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.
+
+(allow mach-lookup
+ (global-name "com.apple.dock.fullscreen")
+ (global-name "com.apple.iohideventsystem"))
+
+(allow file-read*
+ (literal "/Library/Internet Plug-Ins/data.ini"))
+
+(allow iokit-get-properties
+ (iokit-property "manufacturer"))
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.NPSafeSubmit.sb webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.NPSafeSubmit.sb
--- webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.NPSafeSubmit.sb 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.NPSafeSubmit.sb 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,23 @@
+; Copyright (C) 2018 Apple 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 INC. 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 INC. 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.
+
diff -urpN "webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.QuickTime Plugin.plugin.sb" "webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.QuickTime Plugin.plugin.sb"
--- "webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.QuickTime Plugin.plugin.sb" 1969-12-31 18:00:00.000000000 -0600
+++ "webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.apple.QuickTime Plugin.plugin.sb" 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,31 @@
+; Copyright (C) 2013 Apple 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 INC. 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 INC. 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.
+
+(webkit-powerbox)
+(shared-preferences-read-write "com.apple.quicktime.plugin.preferences")
+
+(allow file-read* file-write*
+ (home-library-subpath "/Caches/QuickTime")
+ (home-library-preferences-literal "/QuickTime Preferences"))
+
+(allow network-bind (local ip))
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.cfca.npSecEditCtl.MAC.BOC.plugin.sb webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.cfca.npSecEditCtl.MAC.BOC.plugin.sb
--- webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.cfca.npSecEditCtl.MAC.BOC.plugin.sb 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.cfca.npSecEditCtl.MAC.BOC.plugin.sb 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,25 @@
+; Copyright (C) 2018 Apple 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 INC. 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 INC. 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.
+
+(allow file-read* file-write*
+ (literal "/Library/Internet Plug-Ins/npSecEditCtl.MAC.BOC.sig"))
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.cisco.webex.plugin.gpc64.sb webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.cisco.webex.plugin.gpc64.sb
--- webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.cisco.webex.plugin.gpc64.sb 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.cisco.webex.plugin.gpc64.sb 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,83 @@
+; Copyright (C) 2018 Apple 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 INC. 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 INC. 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.
+
+(define allow-symlinks #t)
+
+(define (home-subpath home-relative-subpath)
+ (subpath (string-append (param "HOME_DIR") home-relative-subpath)))
+(define (home-literal home-relative-literal)
+ (literal (string-append (param "HOME_DIR") home-relative-literal)))
+
+(allow file-read* file-write*
+ (home-literal "/Library/Preferences/com.cisco.webex.fuzzyWindowConfig.plist"))
+
+(allow file-read* file-write*
+ (home-literal "/Library/Preferences/com.webex.meetingmanager.plist"))
+
+(allow file-read* file-write* file-write-create
+ (home-subpath "/Library/Application Support/WebEx Folder"))
+
+;; FIXME: We should tigthen the sandbox to some tmp subfolders
+(allow file*
+ (prefix "/private/tmp"))
+
+(allow file-read-data file-write-data
+ (path "/dev/tty"))
+
+(allow process-exec)
+(allow process-fork)
+(allow distributed-notification-post)
+
+(allow mach-lookup
+ (global-name "com.apple.PerformanceAnalysis.animationperfd")
+ (global-name "com.apple.dock.fullscreen")
+ (global-name "com.apple.quicklook.ui.helper.active")
+ (global-name "com.apple.quicklook.ui.helper")
+ (global-name "com.apple.inputmethodkit.launchagent")
+ (global-name "com.apple.inputmethodkit.launcher")
+ (global-name "com.apple.inputmethodkit.getxpcendpoint"))
+
+(allow iokit-get-properties
+ (iokit-property "PowerControlSupported")
+ (iokit-property "SupportTapToWake")
+ (iokit-property "ResetOnLockMs")
+ (iokit-property "ResetOnUnlockMs")
+ (iokit-property "ShouldResetOnButton")
+ (iokit-property "WirelessChargingNotificationSupported")
+ (iokit-property "SupportsSilentClick")
+ (iokit-property "MinDigitizerPressureValue")
+ (iokit-property "AccurateMaxDigitizerPressureValue")
+ (iokit-property "ExtendedMaxDigitizerPressureValue")
+ (iokit-property "AnimationThresholds")
+ (iokit-property "ActivationThresholds")
+ (iokit-property "mt-device-id"))
+
+(webkit-powerbox)
+(webkit-printing)
+(webkit-camera)
+(webkit-microphone)
+
+(allow network-bind (local ip))
+
+(allow network-outbound)
+(allow network-inbound (local ip))
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.cmbchina.CMBSecurity.sb webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.cmbchina.CMBSecurity.sb
--- webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.cmbchina.CMBSecurity.sb 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.cmbchina.CMBSecurity.sb 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,26 @@
+; Copyright (C) 2018 Apple 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 INC. 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 INC. 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.
+
+(allow mach-lookup
+ (global-name "com.apple.dock.fullscreen")
+ (global-name "com.apple.iohideventsystem"))
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.ftsafe.NPAPI-Core-Safe-SoftKeybaord.plugin.rfc1034identifier.sb webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.ftsafe.NPAPI-Core-Safe-SoftKeybaord.plugin.rfc1034identifier.sb
--- webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.ftsafe.NPAPI-Core-Safe-SoftKeybaord.plugin.rfc1034identifier.sb 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.ftsafe.NPAPI-Core-Safe-SoftKeybaord.plugin.rfc1034identifier.sb 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,23 @@
+; Copyright (C) 2018 Apple 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 INC. 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 INC. 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.
+
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.google.googletalkbrowserplugin.sb webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.google.googletalkbrowserplugin.sb
--- webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.google.googletalkbrowserplugin.sb 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.google.googletalkbrowserplugin.sb 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,45 @@
+; Copyright (C) 2018 Apple 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 INC. 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 INC. 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.
+
+(define (home-subpath home-relative-subpath)
+ (subpath (string-append (param "HOME_DIR") home-relative-subpath)))
+
+(allow file-read* file-write*
+ (home-subpath "/Library/Application Support/Google/Google Talk Plugin"))
+
+(allow file-read* file-write*
+ (subpath "/Library/Application Support/Google"))
+
+(allow job-creation)
+(allow signal)
+(allow mach-lookup)
+
+(webkit-powerbox)
+(webkit-printing)
+(webkit-camera)
+(webkit-microphone)
+
+(allow network-bind (local ip))
+
+(allow network-outbound)
+(allow network-inbound (local ip))
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.google.o1dbrowserplugin.sb webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.google.o1dbrowserplugin.sb
--- webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.google.o1dbrowserplugin.sb 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.google.o1dbrowserplugin.sb 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,50 @@
+; Copyright (C) 2018 Apple 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 INC. 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 INC. 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.
+
+(define (home-subpath home-relative-subpath)
+ (subpath (string-append (param "HOME_DIR") home-relative-subpath)))
+
+(allow file-read* file-write*
+ (home-subpath "/Library/Application Support/Google/Google Talk Plugin"))
+
+(allow file-read* file-write*
+ (subpath "/Library/Application Support/Google"))
+
+(allow file*
+ (prefix "/private/tmp"))
+
+(allow network-bind (prefix "/private/tmp"))
+
+(allow job-creation)
+(allow signal)
+(allow mach-lookup)
+
+(webkit-powerbox)
+(webkit-printing)
+(webkit-camera)
+(webkit-microphone)
+
+(allow network-bind (local ip))
+
+(allow network-outbound)
+(allow network-inbound (local ip))
diff -urpN "webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.macromedia.Flash Player ESR.plugin.sb" "webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.macromedia.Flash Player ESR.plugin.sb"
--- "webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.macromedia.Flash Player ESR.plugin.sb" 1969-12-31 18:00:00.000000000 -0600
+++ "webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.macromedia.Flash Player ESR.plugin.sb" 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,79 @@
+; Copyright (C) 2016 Apple 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 INC. 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 INC. 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.
+
+(webkit-powerbox)
+(webkit-printing)
+(webkit-camera)
+(webkit-microphone)
+
+(allow ipc-posix-sem
+ (ipc-posix-name "MacromediaSemaphoreDig")
+ (ipc-posix-name "59918130"))
+
+(allow file-read*
+ (home-literal "/mm.cfg")
+ (home-literal "/mms.cfg"))
+
+(deny file-read-xattr (with no-log)
+ (home-library-literal "/Caches")
+ (home-library-preferences-literal "/"))
+
+(allow file-read* file-write-create file-write-mode file-write-owner
+ (home-library-literal "/Caches/Adobe")
+ (home-library-preferences-literal "/Macromedia"))
+
+(allow file-read* file-write*
+ (literal "/Library/Application Support/Macromedia/mms.cfg")
+ (home-library-literal "/Application Support/Macromedia/mms.cfg")
+ (home-library-subpath "/Caches/Adobe/Flash Player")
+ (home-library-preferences-subpath "/Macromedia/Flash Player"))
+
+(allow file-read*
+ (literal "/Library/PreferencePanes/Flash Player.prefPane")
+ (home-library-literal "/PreferencePanes/Flash Player.prefPane")
+ (home-library-regex "/Application Support/Macromedia/ss\.(cfg|cfn|sgn)$"))
+
+(allow file-read* file-write*
+ (mount-relative-regex #"^/\.TemporaryItems/"))
+
+(deny file-read* (with no-log)
+ (literal "/Library/Application Support/Macromedia/FlashAuthor.cfg")
+ (subpath "/Library/Application Support/Macromedia/FlashPlayerTrust"))
+
+(allow network-bind (local ip))
+
+;;;
+;;; Needed for Camera access
+;;;
+(allow iokit-get-properties
+ (iokit-property-regex #"^(Activation|Animation)Thresholds")
+ (iokit-property-regex #"^((Accurate|Extended)Max|Min)DigitizerPressureValue")
+ (iokit-property "IOPCITunnelCompatible")
+ (iokit-property "PowerControlSupported")
+ (iokit-property "Removable")
+ (iokit-property "ResetOnLockMs")
+ (iokit-property "ResetOnUnlockMs")
+ (iokit-property "ShouldResetOnButton")
+ (iokit-property-regex #"^Support(sSilentClick|TapToWake)")
+ (iokit-property "WirelessChargingNotificationSupported")
+)
diff -urpN "webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.macromedia.Flash Player.plugin.sb" "webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.macromedia.Flash Player.plugin.sb"
--- "webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.macromedia.Flash Player.plugin.sb" 1969-12-31 18:00:00.000000000 -0600
+++ "webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.macromedia.Flash Player.plugin.sb" 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,79 @@
+; Copyright (C) 2013 Apple 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 INC. 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 INC. 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.
+
+(webkit-powerbox)
+(webkit-printing)
+(webkit-camera)
+(webkit-microphone)
+
+(allow ipc-posix-sem
+ (ipc-posix-name "MacromediaSemaphoreDig")
+ (ipc-posix-name "59918130"))
+
+(allow file-read*
+ (home-literal "/mm.cfg")
+ (home-literal "/mms.cfg"))
+
+(deny file-read-xattr (with no-log)
+ (home-library-literal "/Caches")
+ (home-library-preferences-literal "/"))
+
+(allow file-read* file-write-create file-write-mode file-write-owner
+ (home-library-literal "/Caches/Adobe")
+ (home-library-preferences-literal "/Macromedia"))
+
+(allow file-read* file-write*
+ (literal "/Library/Application Support/Macromedia/mms.cfg")
+ (home-library-literal "/Application Support/Macromedia/mms.cfg")
+ (home-library-subpath "/Caches/Adobe/Flash Player")
+ (home-library-preferences-subpath "/Macromedia/Flash Player"))
+
+(allow file-read*
+ (literal "/Library/PreferencePanes/Flash Player.prefPane")
+ (home-library-literal "/PreferencePanes/Flash Player.prefPane")
+ (home-library-regex "/Application Support/Macromedia/ss\.(cfg|cfn|sgn)$"))
+
+(allow file-read* file-write*
+ (mount-relative-regex #"^/\.TemporaryItems/"))
+
+(deny file-read* (with no-log)
+ (literal "/Library/Application Support/Macromedia/FlashAuthor.cfg")
+ (subpath "/Library/Application Support/Macromedia/FlashPlayerTrust"))
+
+(allow network-bind (local ip))
+
+;;;
+;;; Needed for Camera access
+;;;
+(allow iokit-get-properties
+ (iokit-property-regex #"^(Activation|Animation)Thresholds")
+ (iokit-property-regex #"^((Accurate|Extended)Max|Min)DigitizerPressureValue")
+ (iokit-property "IOPCITunnelCompatible")
+ (iokit-property "PowerControlSupported")
+ (iokit-property "Removable")
+ (iokit-property "ResetOnLockMs")
+ (iokit-property "ResetOnUnlockMs")
+ (iokit-property "ShouldResetOnButton")
+ (iokit-property-regex #"^Support(sSilentClick|TapToWake)")
+ (iokit-property "WirelessChargingNotificationSupported")
+)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.microsoft.SilverlightPlugin.sb webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.microsoft.SilverlightPlugin.sb
--- webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.microsoft.SilverlightPlugin.sb 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.microsoft.SilverlightPlugin.sb 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,56 @@
+; Copyright (C) 2013 Apple 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 INC. 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 INC. 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.
+
+(allow iokit-open
+ (iokit-user-client-class "IOHIDLibUserClient")
+ (iokit-user-client-class "IOBluetoothHCIUserClient"))
+
+(shared-preferences-read
+ "com.microsoft.PlayReady"
+ "com.microsoft.autoupdate2")
+(shared-preferences-read-write "com.microsoft.silverlight")
+
+(allow file-write-create
+ (home-library-literal "/Application Support/Microsoft"))
+
+(allow file-read* file-write*
+ ;; Sigh, mode 777 in /Library.
+ (subpath "/Library/Application Support/Microsoft/PlayReady")
+ (home-library-subpath "/Application Support/Microsoft/PlayReady")
+ (home-library-subpath "/Application Support/Microsoft/Silverlight")
+ (home-library-subpath "/Caches/TemporaryItems"))
+
+(if (defined? 'semaphore-owner)
+ (allow ipc-posix-sem
+ (semaphore-owner same-sandbox))
+ (allow ipc-posix-sem
+ (ipc-posix-name "LC_Mutex")))
+
+;; FIXME: <rdar://problem/13636078>
+(allow ipc-posix-shm*
+ (ipc-posix-name-regex #"^CoreCLR_"))
+
+(allow network-bind (local ip))
+
+(webkit-powerbox)
+(webkit-printing)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.oracle.java.JavaAppletPlugin.sb webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.oracle.java.JavaAppletPlugin.sb
--- webkitgtk-2.36.7.orig/Source/WebKit/Resources/PlugInSandboxProfiles/com.oracle.java.JavaAppletPlugin.sb 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Resources/PlugInSandboxProfiles/com.oracle.java.JavaAppletPlugin.sb 2022-08-26 14:18:14.981022335 -0500
@@ -0,0 +1,70 @@
+; Copyright (C) 2013 Apple 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 INC. 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 INC. 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.
+
+(webkit-printing)
+
+(allow signal network-inbound)
+(allow process-fork)
+(allow process-exec
+ (subpath "/System/Library/Java/JavaVirtualMachines")
+ (subpath "/Library/Internet Plug-Ins/JavaAppletPlugin.plugin"))
+
+(allow mach-lookup
+ (global-name "com.apple.coreservices.launchservicesd")
+ (global-name-regex #"^PlaceHolderServerName-"))
+
+(allow file-read*
+ (literal "/dev/fd")
+ (literal "/usr/bin")
+ (literal "/private/etc/hosts")
+ (subpath "/Library/Java")
+ (subpath "/System/Library/Java"))
+
+(shared-preferences-read
+ "com.apple.java.JavaPreferences"
+ "net.java.openjdk.cmd")
+
+(shared-preferences-read-write
+ "com.apple.java.util.prefs"
+ "com.oracle.javadeployment")
+
+(allow file-read* file-write*
+ (home-library-subpath "/Saved Application State/net.java.openjdk.cmd.savedState")
+ (home-library-subpath "/Application Support/Oracle/Java/Deployment")
+ (home-library-subpath "/Caches/Java"))
+
+(allow file-write-create
+ (home-library-literal "/Application Support/Oracle")
+ (home-library-literal "/Application Support/Oracle/Java"))
+
+(allow file-read*
+ (subpath "/Library/Application Support/Java/PublicFiles")
+ (subpath "/Library/Application Support/Oracle/Java/Deployment"))
+
+(allow network-bind network-outbound (subpath (param "DARWIN_USER_TEMP_DIR")))
+(allow network-bind (local ip))
+
+(deny file-write* (with no-log) (subpath "/Library/Application Support/Oracle"))
+(deny file-write* (with no-log) (subpath (param "WEBKIT2_FRAMEWORK_DIR")))
+
+(deny job-creation (with no-log))
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/API/c/WKPluginInformation.cpp webkitgtk-2.36.7/Source/WebKit/Shared/API/c/WKPluginInformation.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/API/c/WKPluginInformation.cpp 2022-06-30 04:49:37.572846000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/Shared/API/c/WKPluginInformation.cpp 2022-08-26 14:18:14.981022335 -0500
@@ -27,74 +27,145 @@
#include "WKPluginInformation.h"
#include "APIString.h"
+#include "PluginInformation.h"
#include "WKSharedAPICast.h"
WKStringRef WKPluginInformationBundleIdentifierKey()
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ static API::String& key = API::String::create(WebKit::pluginInformationBundleIdentifierKey()).leakRef();
+ return WebKit::toAPI(&key);
+#else
return 0;
+#endif
}
WKStringRef WKPluginInformationBundleVersionKey()
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ static API::String& key = API::String::create(WebKit::pluginInformationBundleVersionKey()).leakRef();
+ return WebKit::toAPI(&key);
+#else
return 0;
+#endif
}
WKStringRef WKPluginInformationBundleShortVersionKey()
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ static API::String& key = API::String::create(WebKit::pluginInformationBundleShortVersionKey()).leakRef();
+ return WebKit::toAPI(&key);
+#else
return 0;
+#endif
}
WKStringRef WKPluginInformationPathKey()
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ static API::String& key = API::String::create(WebKit::pluginInformationPathKey()).leakRef();
+ return WebKit::toAPI(&key);
+#else
return 0;
+#endif
}
WKStringRef WKPluginInformationDisplayNameKey()
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ static API::String& key = API::String::create(WebKit::pluginInformationDisplayNameKey()).leakRef();
+ return WebKit::toAPI(&key);
+#else
return 0;
+#endif
}
WKStringRef WKPluginInformationDefaultLoadPolicyKey()
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ static API::String& key = API::String::create(WebKit::pluginInformationDefaultLoadPolicyKey()).leakRef();
+ return WebKit::toAPI(&key);
+#else
return 0;
+#endif
}
WKStringRef WKPluginInformationUpdatePastLastBlockedVersionIsKnownAvailableKey()
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ static API::String& key = API::String::create(WebKit::pluginInformationUpdatePastLastBlockedVersionIsKnownAvailableKey()).leakRef();
+ return WebKit::toAPI(&key);
+#else
return 0;
+#endif
}
WKStringRef WKPluginInformationHasSandboxProfileKey()
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ static API::String& key = API::String::create(WebKit::pluginInformationHasSandboxProfileKey()).leakRef();
+ return WebKit::toAPI(&key);
+#else
return 0;
+#endif
}
WKStringRef WKPluginInformationFrameURLKey()
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ static API::String& key = API::String::create(WebKit::pluginInformationFrameURLKey()).leakRef();
+ return WebKit::toAPI(&key);
+#else
return 0;
+#endif
}
WKStringRef WKPluginInformationMIMETypeKey()
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ static API::String& key = API::String::create(WebKit::pluginInformationMIMETypeKey()).leakRef();
+ return WebKit::toAPI(&key);
+#else
return 0;
+#endif
}
WKStringRef WKPluginInformationPageURLKey()
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ static API::String& key = API::String::create(WebKit::pluginInformationPageURLKey()).leakRef();
+ return WebKit::toAPI(&key);
+#else
return 0;
+#endif
}
WKStringRef WKPluginInformationPluginspageAttributeURLKey()
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ static API::String& key = API::String::create(WebKit::pluginInformationPluginspageAttributeURLKey()).leakRef();
+ return WebKit::toAPI(&key);
+#else
return 0;
+#endif
}
WKStringRef WKPluginInformationPluginURLKey()
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ static API::String& key = API::String::create(WebKit::pluginInformationPluginURLKey()).leakRef();
+ return WebKit::toAPI(&key);
+#else
return 0;
+#endif
}
WKStringRef WKPlugInInformationReplacementObscuredKey()
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ static API::String& key = API::String::create(WebKit::plugInInformationReplacementObscuredKey()).leakRef();
+ return WebKit::toAPI(&key);
+#else
return 0;
+#endif
}
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/AuxiliaryProcess.cpp webkitgtk-2.36.7/Source/WebKit/Shared/AuxiliaryProcess.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/AuxiliaryProcess.cpp 2022-08-08 06:13:37.346126000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/Shared/AuxiliaryProcess.cpp 2022-08-26 14:18:14.981022335 -0500
@@ -50,6 +50,7 @@ using namespace WebCore;
AuxiliaryProcess::AuxiliaryProcess()
: m_terminationCounter(0)
+ , m_terminationTimer(RunLoop::main(), this, &AuxiliaryProcess::terminationTimerFired)
, m_processSuppressionDisabled("Process Suppression Disabled by UIProcess")
{
}
@@ -157,6 +158,7 @@ void AuxiliaryProcess::removeMessageRece
void AuxiliaryProcess::disableTermination()
{
m_terminationCounter++;
+ m_terminationTimer.stop();
}
void AuxiliaryProcess::enableTermination()
@@ -167,8 +169,12 @@ void AuxiliaryProcess::enableTermination
if (m_terminationCounter || m_isInShutDown)
return;
- if (shouldTerminate())
- terminate();
+ if (!m_terminationTimeout) {
+ terminationTimerFired();
+ return;
+ }
+
+ m_terminationTimer.startOneShot(m_terminationTimeout);
}
void AuxiliaryProcess::mainThreadPing(CompletionHandler<void()>&& completionHandler)
@@ -186,6 +192,14 @@ uint64_t AuxiliaryProcess::messageSender
return 0;
}
+void AuxiliaryProcess::terminationTimerFired()
+{
+ if (!shouldTerminate())
+ return;
+
+ terminate();
+}
+
void AuxiliaryProcess::stopRunLoop()
{
platformStopRunLoop();
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/AuxiliaryProcess.h webkitgtk-2.36.7/Source/WebKit/Shared/AuxiliaryProcess.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/AuxiliaryProcess.h 2022-06-30 04:49:37.589512600 -0500
+++ webkitgtk-2.36.7/Source/WebKit/Shared/AuxiliaryProcess.h 2022-08-26 14:18:14.985022355 -0500
@@ -105,6 +105,8 @@ protected:
explicit AuxiliaryProcess();
virtual ~AuxiliaryProcess();
+ void setTerminationTimeout(Seconds seconds) { m_terminationTimeout = seconds; }
+
virtual void initializeProcess(const AuxiliaryProcessInitializationParameters&);
virtual void initializeProcessName(const AuxiliaryProcessInitializationParameters&);
virtual void initializeSandbox(const AuxiliaryProcessInitializationParameters&, SandboxInitializationParameters&);
@@ -160,12 +162,21 @@ private:
void shutDown();
+ void terminationTimerFired();
+
void platformInitialize(const AuxiliaryProcessInitializationParameters&);
void platformStopRunLoop();
- // A termination counter; when the counter reaches zero, the process will be terminated.
+ // The timeout, in seconds, before this process will be terminated if termination
+ // has been enabled. If the timeout is 0 seconds, the process will be terminated immediately.
+ Seconds m_terminationTimeout;
+
+ // A termination counter; when the counter reaches zero, the process will be terminated
+ // after a given period of time.
unsigned m_terminationCounter;
+ RunLoop::Timer<AuxiliaryProcess> m_terminationTimer;
+
bool m_isInShutDown { false };
RefPtr<IPC::Connection> m_connection;
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/AuxiliaryProcessMain.h webkitgtk-2.36.7/Source/WebKit/Shared/AuxiliaryProcessMain.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/AuxiliaryProcessMain.h 2022-06-30 04:49:37.589512600 -0500
+++ webkitgtk-2.36.7/Source/WebKit/Shared/AuxiliaryProcessMain.h 2022-08-26 14:18:14.985022355 -0500
@@ -36,7 +36,7 @@ namespace WebKit {
class AuxiliaryProcessMainCommon {
public:
- bool parseCommandLine(int argc, char** argv);
+ virtual bool parseCommandLine(int argc, char** argv);
protected:
AuxiliaryProcessInitializationParameters m_parameters;
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/Netscape/NetscapePluginModule.cpp webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/Netscape/NetscapePluginModule.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/Netscape/NetscapePluginModule.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/Netscape/NetscapePluginModule.cpp 2022-08-26 14:18:14.985022355 -0500
@@ -0,0 +1,257 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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 "config.h"
+#include "NetscapePluginModule.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "Module.h"
+#include "NPRuntimeUtilities.h"
+#include "NetscapeBrowserFuncs.h"
+#include <wtf/NeverDestroyed.h>
+#include <wtf/text/CString.h>
+
+namespace WebKit {
+
+static Vector<NetscapePluginModule*>& initializedNetscapePluginModules()
+{
+ static NeverDestroyed<Vector<NetscapePluginModule*>> initializedNetscapePluginModules;
+ return initializedNetscapePluginModules;
+}
+
+NetscapePluginModule::NetscapePluginModule(const String& pluginPath)
+ : m_pluginPath(pluginPath)
+ , m_isInitialized(false)
+ , m_loadCount(0)
+ , m_shutdownProcPtr(0)
+ , m_pluginFuncs()
+{
+}
+
+NetscapePluginModule::~NetscapePluginModule()
+{
+ ASSERT(initializedNetscapePluginModules().find(this) == notFound);
+}
+
+Vector<String> NetscapePluginModule::sitesWithData()
+{
+ Vector<String> sites;
+
+ incrementLoadCount();
+ tryGetSitesWithData(sites);
+ decrementLoadCount();
+
+ return sites;
+}
+
+bool NetscapePluginModule::clearSiteData(const String& site, uint64_t flags, uint64_t maxAge)
+{
+ incrementLoadCount();
+ bool result = tryClearSiteData(site, flags, maxAge);
+ decrementLoadCount();
+
+ return result;
+}
+
+bool NetscapePluginModule::tryGetSitesWithData(Vector<String>& sites)
+{
+ if (!m_isInitialized)
+ return false;
+
+ // Check if the plug-in supports NPP_GetSitesWithData.
+ if (!m_pluginFuncs.getsiteswithdata)
+ return false;
+
+ char** siteArray = m_pluginFuncs.getsiteswithdata();
+
+ // There were no sites with data.
+ if (!siteArray)
+ return true;
+
+ for (int i = 0; siteArray[i]; ++i) {
+ char* site = siteArray[i];
+
+ String siteString = String::fromUTF8(site);
+ if (!siteString.isNull())
+ sites.append(siteString);
+
+ npnMemFree(site);
+ }
+
+ npnMemFree(siteArray);
+ return true;
+}
+
+bool NetscapePluginModule::tryClearSiteData(const String& site, uint64_t flags, uint64_t maxAge)
+{
+ if (!m_isInitialized)
+ return false;
+
+ // Check if the plug-in supports NPP_ClearSiteData.
+ if (!m_pluginFuncs.clearsitedata)
+ return false;
+
+ CString siteString;
+ if (!site.isNull())
+ siteString = site.utf8();
+
+ return m_pluginFuncs.clearsitedata(siteString.data(), flags, maxAge) == NPERR_NO_ERROR;
+}
+
+void NetscapePluginModule::shutdown()
+{
+ ASSERT(m_isInitialized);
+
+ m_shutdownProcPtr();
+
+ m_isInitialized = false;
+
+ size_t pluginModuleIndex = initializedNetscapePluginModules().find(this);
+ ASSERT(pluginModuleIndex != notFound);
+
+ initializedNetscapePluginModules().remove(pluginModuleIndex);
+}
+
+RefPtr<NetscapePluginModule> NetscapePluginModule::getOrCreate(const String& pluginPath)
+{
+ // First, see if we already have a module with this plug-in path.
+ for (size_t i = 0; i < initializedNetscapePluginModules().size(); ++i) {
+ NetscapePluginModule* pluginModule = initializedNetscapePluginModules()[i];
+
+ if (pluginModule->m_pluginPath == pluginPath)
+ return pluginModule;
+ }
+
+ auto pluginModule(adoptRef(*new NetscapePluginModule(pluginPath)));
+
+ // Try to load and initialize the plug-in module.
+ if (!pluginModule->load())
+ return nullptr;
+
+ return pluginModule;
+}
+
+void NetscapePluginModule::incrementLoadCount()
+{
+ if (!m_loadCount) {
+ // Load the plug-in module if necessary.
+ load();
+ }
+
+ m_loadCount++;
+}
+
+void NetscapePluginModule::decrementLoadCount()
+{
+ ASSERT(m_loadCount > 0);
+ m_loadCount--;
+
+ if (!m_loadCount && m_isInitialized) {
+ shutdown();
+ unload();
+ }
+}
+
+bool NetscapePluginModule::load()
+{
+ if (m_isInitialized) {
+ ASSERT(initializedNetscapePluginModules().find(this) != notFound);
+ return true;
+ }
+
+ if (!tryLoad()) {
+ unload();
+ return false;
+ }
+
+ m_isInitialized = true;
+
+ ASSERT(initializedNetscapePluginModules().find(this) == notFound);
+ initializedNetscapePluginModules().append(this);
+
+ determineQuirks();
+
+ return true;
+}
+
+#if PLATFORM(GTK)
+static bool moduleMixesGtkSymbols(Module* module)
+{
+ return module->functionPointer<gpointer>("gtk_object_get_type");
+}
+#endif
+
+bool NetscapePluginModule::tryLoad()
+{
+ m_module = makeUnique<Module>(m_pluginPath);
+ if (!m_module->load())
+ return false;
+
+#if PLATFORM(GTK)
+ if (moduleMixesGtkSymbols(m_module.get()))
+ return false;
+#endif
+
+ NP_InitializeFuncPtr initializeFuncPtr = m_module->functionPointer<NP_InitializeFuncPtr>("NP_Initialize");
+ if (!initializeFuncPtr)
+ return false;
+
+#if !PLUGIN_ARCHITECTURE(UNIX)
+ NP_GetEntryPointsFuncPtr getEntryPointsFuncPtr = m_module->functionPointer<NP_GetEntryPointsFuncPtr>("NP_GetEntryPoints");
+ if (!getEntryPointsFuncPtr)
+ return false;
+#endif
+
+ m_shutdownProcPtr = m_module->functionPointer<NPP_ShutdownProcPtr>("NP_Shutdown");
+ if (!m_shutdownProcPtr)
+ return false;
+
+ m_pluginFuncs.size = sizeof(NPPluginFuncs);
+ m_pluginFuncs.version = (NP_VERSION_MAJOR << 8) | NP_VERSION_MINOR;
+
+ // On Mac, NP_Initialize must be called first, then NP_GetEntryPoints. On Windows, the order is
+ // reversed. Failing to follow this order results in crashes (e.g., in Silverlight on Mac and
+ // in Flash and QuickTime on Windows).
+#if PLUGIN_ARCHITECTURE(MAC)
+ return initializeFuncPtr(netscapeBrowserFuncs()) == NPERR_NO_ERROR && getEntryPointsFuncPtr(&m_pluginFuncs) == NPERR_NO_ERROR;
+#elif PLUGIN_ARCHITECTURE(UNIX)
+ if (initializeFuncPtr(netscapeBrowserFuncs(), &m_pluginFuncs) != NPERR_NO_ERROR)
+ return false;
+#endif
+
+ return true;
+}
+
+void NetscapePluginModule::unload()
+{
+ ASSERT(!m_isInitialized);
+
+ m_module = nullptr;
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/Netscape/NetscapePluginModule.h webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/Netscape/NetscapePluginModule.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/Netscape/NetscapePluginModule.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/Netscape/NetscapePluginModule.h 2022-08-26 14:18:14.985022355 -0500
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+ */
+
+#ifndef NetscapePluginModule_h
+#define NetscapePluginModule_h
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "Module.h"
+#include "PluginModuleInfo.h"
+#include "PluginQuirks.h"
+#include <WebCore/npruntime_internal.h>
+#include <wtf/RefCounted.h>
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+struct MimeClassInfo;
+}
+
+namespace WebKit {
+
+struct RawPluginMetaData;
+
+class NetscapePluginModule : public RefCounted<NetscapePluginModule> {
+public:
+ static RefPtr<NetscapePluginModule> getOrCreate(const String& pluginPath);
+ ~NetscapePluginModule();
+
+ const NPPluginFuncs& pluginFuncs() const { return m_pluginFuncs; }
+
+ void incrementLoadCount();
+ void decrementLoadCount();
+
+ static bool getPluginInfo(const String& pluginPath, PluginModuleInfo&);
+
+ const PluginQuirks& pluginQuirks() const { return m_pluginQuirks; }
+
+ // Return a list of domains for which the plug-in has data stored.
+ Vector<String> sitesWithData();
+
+ // Request that the plug-in clear the site data.
+ bool clearSiteData(const String& site, uint64_t flags, uint64_t maxAge);
+
+ Module* module() const { return m_module.get(); }
+
+#if PLUGIN_ARCHITECTURE(UNIX)
+ static bool scanPlugin(const String& pluginPath);
+ static void parseMIMEDescription(const String& mimeDescription, Vector<WebCore::MimeClassInfo>& result);
+ static String buildMIMEDescription(const Vector<WebCore::MimeClassInfo>&);
+#endif
+
+private:
+ explicit NetscapePluginModule(const String& pluginPath);
+
+ void determineQuirks();
+
+#if PLUGIN_ARCHITECTURE(UNIX)
+ bool getPluginInfoForLoadedPlugin(RawPluginMetaData&);
+#endif
+
+ bool tryGetSitesWithData(Vector<String>&);
+ bool tryClearSiteData(const String& site, uint64_t flags, uint64_t maxAge);
+
+ bool tryLoad();
+ bool load();
+ void unload();
+
+ void shutdown();
+
+ String m_pluginPath;
+ bool m_isInitialized;
+ unsigned m_loadCount;
+
+ PluginQuirks m_pluginQuirks;
+
+ NPP_ShutdownProcPtr m_shutdownProcPtr;
+ NPPluginFuncs m_pluginFuncs;
+
+ std::unique_ptr<Module> m_module;
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif // NetscapePluginModule_h
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/Netscape/PluginInformation.cpp webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/Netscape/PluginInformation.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/Netscape/PluginInformation.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/Netscape/PluginInformation.cpp 2022-08-26 14:18:14.985022355 -0500
@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 2013 Apple 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 INC. 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 INC. 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 "config.h"
+#include "PluginInformation.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "APINumber.h"
+#include "APIString.h"
+#include "APIURL.h"
+#include "PluginInfoStore.h"
+#include "PluginModuleInfo.h"
+#include "WKAPICast.h"
+#include <wtf/text/WTFString.h>
+
+namespace WebKit {
+
+String pluginInformationBundleIdentifierKey()
+{
+ return "PluginInformationBundleIdentifier"_s;
+}
+
+String pluginInformationBundleVersionKey()
+{
+ return "PluginInformationBundleVersion"_s;
+}
+
+String pluginInformationBundleShortVersionKey()
+{
+ return "PluginInformationBundleShortVersion"_s;
+}
+
+String pluginInformationPathKey()
+{
+ return "PluginInformationPath"_s;
+}
+
+String pluginInformationDisplayNameKey()
+{
+ return "PluginInformationDisplayName"_s;
+}
+
+String pluginInformationDefaultLoadPolicyKey()
+{
+ return "PluginInformationDefaultLoadPolicy"_s;
+}
+
+String pluginInformationUpdatePastLastBlockedVersionIsKnownAvailableKey()
+{
+ return "PluginInformationUpdatePastLastBlockedVersionIsKnownAvailable"_s;
+}
+
+String pluginInformationHasSandboxProfileKey()
+{
+ return "PluginInformationHasSandboxProfile"_s;
+}
+
+String pluginInformationFrameURLKey()
+{
+ return "PluginInformationFrameURL"_s;
+}
+
+String pluginInformationMIMETypeKey()
+{
+ return "PluginInformationMIMEType"_s;
+}
+
+String pluginInformationPageURLKey()
+{
+ return "PluginInformationPageURL"_s;
+}
+
+String pluginInformationPluginspageAttributeURLKey()
+{
+ return "PluginInformationPluginspageAttributeURL"_s;
+}
+
+String pluginInformationPluginURLKey()
+{
+ return "PluginInformationPluginURL"_s;
+}
+
+String plugInInformationReplacementObscuredKey()
+{
+ return "PlugInInformationReplacementObscured"_s;
+}
+
+void getPluginModuleInformation(const PluginModuleInfo& plugin, API::Dictionary::MapType& map)
+{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ map.set(pluginInformationPathKey(), API::String::create(plugin.path));
+ map.set(pluginInformationDisplayNameKey(), API::String::create(plugin.info.name));
+ map.set(pluginInformationDefaultLoadPolicyKey(), API::UInt64::create(toWKPluginLoadPolicy(PluginInfoStore::defaultLoadPolicyForPlugin(plugin))));
+
+ getPlatformPluginModuleInformation(plugin, map);
+#else
+ UNUSED_PARAM(plugin);
+ UNUSED_PARAM(map);
+#endif
+}
+
+Ref<API::Dictionary> createPluginInformationDictionary(const PluginModuleInfo& plugin)
+{
+ API::Dictionary::MapType map;
+ getPluginModuleInformation(plugin, map);
+
+ return API::Dictionary::create(WTFMove(map));
+}
+
+Ref<API::Dictionary> createPluginInformationDictionary(const PluginModuleInfo& plugin, const String& frameURLString, const String& mimeType, const String& pageURLString, const String& pluginspageAttributeURLString, const String& pluginURLString, bool replacementObscured)
+{
+ API::Dictionary::MapType map;
+ getPluginModuleInformation(plugin, map);
+
+ if (!frameURLString.isEmpty())
+ map.set(pluginInformationFrameURLKey(), API::URL::create(frameURLString));
+ if (!mimeType.isEmpty())
+ map.set(pluginInformationMIMETypeKey(), API::String::create(mimeType));
+ if (!pageURLString.isEmpty())
+ map.set(pluginInformationPageURLKey(), API::URL::create(pageURLString));
+ if (!pluginspageAttributeURLString.isEmpty())
+ map.set(pluginInformationPluginspageAttributeURLKey(), API::URL::create(pluginspageAttributeURLString));
+ if (!pluginURLString.isEmpty())
+ map.set(pluginInformationPluginURLKey(), API::URL::create(pluginURLString));
+ map.set(plugInInformationReplacementObscuredKey(), API::Boolean::create(replacementObscured));
+
+ return API::Dictionary::create(WTFMove(map));
+}
+
+Ref<API::Dictionary> createPluginInformationDictionary(const String& mimeType, const String& frameURLString, const String& pageURLString)
+{
+ API::Dictionary::MapType map;
+
+ if (!frameURLString.isEmpty())
+ map.set(pluginInformationFrameURLKey(), API::URL::create(frameURLString));
+ if (!mimeType.isEmpty())
+ map.set(pluginInformationMIMETypeKey(), API::String::create(mimeType));
+ if (!pageURLString.isEmpty())
+ map.set(pluginInformationPageURLKey(), API::URL::create(pageURLString));
+
+ return API::Dictionary::create(WTFMove(map));
+}
+
+#if !PLATFORM(COCOA)
+void getPlatformPluginModuleInformation(const PluginModuleInfo&, API::Dictionary::MapType&)
+{
+}
+#endif
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/Netscape/PluginInformation.h webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/Netscape/PluginInformation.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/Netscape/PluginInformation.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/Netscape/PluginInformation.h 2022-08-26 14:18:14.985022355 -0500
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2013 Apple 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 INC. 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 INC. 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.
+ */
+
+#ifndef PluginInformation_h
+#define PluginInformation_h
+
+#include "APIDictionary.h"
+#include <wtf/Forward.h>
+
+namespace WebKit {
+
+struct PluginModuleInfo;
+
+// Plug-in module information keys
+String pluginInformationBundleIdentifierKey();
+String pluginInformationBundleVersionKey();
+String pluginInformationBundleShortVersionKey();
+String pluginInformationPathKey();
+String pluginInformationDisplayNameKey();
+String pluginInformationDefaultLoadPolicyKey();
+String pluginInformationUpdatePastLastBlockedVersionIsKnownAvailableKey();
+String pluginInformationHasSandboxProfileKey();
+
+// Plug-in load specific information keys
+String pluginInformationFrameURLKey();
+String pluginInformationMIMETypeKey();
+String pluginInformationPageURLKey();
+String pluginInformationPluginspageAttributeURLKey();
+String pluginInformationPluginURLKey();
+String plugInInformationReplacementObscuredKey();
+
+Ref<API::Dictionary> createPluginInformationDictionary(const PluginModuleInfo&);
+Ref<API::Dictionary> createPluginInformationDictionary(const PluginModuleInfo&, const String& frameURLString, const String& mimeType, const String& pageURLString, const String& pluginspageAttributeURLString, const String& pluginURLString, bool replacementObscured = false);
+Ref<API::Dictionary> createPluginInformationDictionary(const String& mimeType, const String& frameURLString, const String& pageURLString);
+
+void getPluginModuleInformation(const PluginModuleInfo&, API::Dictionary::MapType&);
+void getPlatformPluginModuleInformation(const PluginModuleInfo&, API::Dictionary::MapType&);
+
+} // namespace WebKit
+
+#endif // PluginInformation_h
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/Netscape/unix/NetscapePluginModuleUnix.cpp webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/Netscape/unix/NetscapePluginModuleUnix.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/Netscape/unix/NetscapePluginModuleUnix.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/Netscape/unix/NetscapePluginModuleUnix.cpp 2022-08-26 14:18:14.985022355 -0500
@@ -0,0 +1,246 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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 "config.h"
+#include "NetscapePluginModule.h"
+
+#if PLUGIN_ARCHITECTURE(UNIX) && ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "NetscapeBrowserFuncs.h"
+#include "PluginProcessProxy.h"
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <wtf/FileSystem.h>
+#include <wtf/text/StringBuilder.h>
+
+namespace WebKit {
+using namespace WebCore;
+
+class StdoutDevNullRedirector {
+public:
+ StdoutDevNullRedirector();
+ ~StdoutDevNullRedirector();
+
+private:
+ int m_savedStdout;
+};
+
+StdoutDevNullRedirector::StdoutDevNullRedirector()
+ : m_savedStdout(-1)
+{
+ int newStdout = open("/dev/null", O_WRONLY);
+ if (newStdout == -1)
+ return;
+ m_savedStdout = dup(STDOUT_FILENO);
+ dup2(newStdout, STDOUT_FILENO);
+ close(newStdout);
+}
+
+StdoutDevNullRedirector::~StdoutDevNullRedirector()
+{
+ if (m_savedStdout != -1) {
+ dup2(m_savedStdout, STDOUT_FILENO);
+ close(m_savedStdout);
+ }
+}
+
+
+void NetscapePluginModule::parseMIMEDescription(const String& mimeDescription, Vector<MimeClassInfo>& result)
+{
+ ASSERT_ARG(result, result.isEmpty());
+
+ Vector<String> types = mimeDescription.convertToASCIILowercase().split(';');
+ result.reserveInitialCapacity(types.size());
+
+ size_t mimeInfoCount = 0;
+ for (size_t i = 0; i < types.size(); ++i) {
+ Vector<String> mimeTypeParts = types[i].splitAllowingEmptyEntries(':');
+ if (mimeTypeParts.size() <= 0)
+ continue;
+
+ result.uncheckedAppend(MimeClassInfo());
+ MimeClassInfo& mimeInfo = result[mimeInfoCount++];
+ mimeInfo.type = mimeTypeParts[0];
+
+ if (mimeTypeParts.size() > 1)
+ mimeInfo.extensions = mimeTypeParts[1].split(',');
+
+ if (mimeTypeParts.size() > 2)
+ mimeInfo.desc = mimeTypeParts[2];
+ }
+}
+
+String NetscapePluginModule::buildMIMEDescription(const Vector<MimeClassInfo>& mimeDescription)
+{
+ StringBuilder builder;
+
+ size_t mimeInfoCount = mimeDescription.size();
+ for (size_t i = 0; i < mimeInfoCount; ++i) {
+ const MimeClassInfo& mimeInfo = mimeDescription[i];
+ builder.append(mimeInfo.type);
+ builder.append(':');
+
+ size_t extensionsCount = mimeInfo.extensions.size();
+ for (size_t j = 0; j < extensionsCount; ++j) {
+ builder.append(mimeInfo.extensions[j]);
+ if (j != extensionsCount - 1)
+ builder.append(',');
+ }
+ builder.append(':');
+
+ builder.append(mimeInfo.desc);
+ if (i != mimeInfoCount - 1)
+ builder.append(';');
+ }
+
+ return builder.toString();
+}
+
+bool NetscapePluginModule::getPluginInfoForLoadedPlugin(RawPluginMetaData& metaData)
+{
+ ASSERT(m_isInitialized);
+
+ Module* module = m_module.get();
+ NPP_GetValueProcPtr NPP_GetValue = module->functionPointer<NPP_GetValueProcPtr>("NP_GetValue");
+ if (!NPP_GetValue)
+ return false;
+
+ NP_GetMIMEDescriptionFuncPtr NP_GetMIMEDescription = module->functionPointer<NP_GetMIMEDescriptionFuncPtr>("NP_GetMIMEDescription");
+ if (!NP_GetMIMEDescription)
+ return false;
+
+ char* buffer;
+ NPError error = NPP_GetValue(0, NPPVpluginNameString, &buffer);
+ if (error == NPERR_NO_ERROR)
+ metaData.name = String::fromUTF8(buffer);
+
+ error = NPP_GetValue(0, NPPVpluginDescriptionString, &buffer);
+ if (error == NPERR_NO_ERROR)
+ metaData.description = String::fromUTF8(buffer);
+
+ String mimeDescription = String::fromUTF8(NP_GetMIMEDescription());
+ if (mimeDescription.isNull())
+ return false;
+
+ metaData.mimeDescription = mimeDescription;
+
+ return true;
+}
+
+bool NetscapePluginModule::getPluginInfo(const String& pluginPath, PluginModuleInfo& plugin)
+{
+ RawPluginMetaData metaData;
+ if (!PluginProcessProxy::scanPlugin(pluginPath, metaData))
+ return false;
+
+ plugin.path = pluginPath;
+ plugin.info.file = FileSystem::pathFileName(pluginPath);
+ plugin.info.name = metaData.name;
+ plugin.info.desc = metaData.description;
+ parseMIMEDescription(metaData.mimeDescription, plugin.info.mimes);
+
+ return true;
+}
+
+void NetscapePluginModule::determineQuirks()
+{
+ RawPluginMetaData metaData;
+ if (!getPluginInfoForLoadedPlugin(metaData))
+ return;
+
+ Vector<MimeClassInfo> mimeTypes;
+ parseMIMEDescription(metaData.mimeDescription, mimeTypes);
+
+#if PLATFORM(X11)
+ for (size_t i = 0; i < mimeTypes.size(); ++i) {
+ if (mimeTypes[i].type == "application/x-shockwave-flash") {
+#if CPU(X86_64)
+ m_pluginQuirks.add(PluginQuirks::IgnoreRightClickInWindowlessMode);
+#endif
+ m_pluginQuirks.add(PluginQuirks::DoNotCancelSrcStreamInWindowedMode);
+ break;
+ }
+ }
+#endif // PLATFORM(X11)
+}
+
+static void writeCharacter(char byte)
+{
+ int result;
+ while ((result = fputc(byte, stdout)) == EOF && errno == EINTR) { }
+ ASSERT(result != EOF);
+}
+
+static void writeLine(const String& line)
+{
+ CString utf8String = line.utf8();
+ const char* utf8Data = utf8String.data();
+
+ for (unsigned i = 0; i < utf8String.length(); i++) {
+ char character = utf8Data[i];
+ if (character != '\n')
+ writeCharacter(character);
+ }
+ writeCharacter('\n');
+}
+
+bool NetscapePluginModule::scanPlugin(const String& pluginPath)
+{
+ RawPluginMetaData metaData;
+
+ {
+ // Don't allow the plugin to pollute the standard output.
+ StdoutDevNullRedirector stdOutRedirector;
+
+ // We are loading the plugin here since it does not seem to be a standardized way to
+ // get the needed informations from a UNIX plugin without loading it.
+ RefPtr<NetscapePluginModule> pluginModule = NetscapePluginModule::getOrCreate(pluginPath);
+ if (!pluginModule)
+ return false;
+
+ pluginModule->incrementLoadCount();
+ bool success = pluginModule->getPluginInfoForLoadedPlugin(metaData);
+ pluginModule->decrementLoadCount();
+
+ if (!success)
+ return false;
+ }
+
+ // Write data to standard output for the UI process.
+ writeLine(metaData.name);
+ writeLine(metaData.description);
+ writeLine(metaData.mimeDescription);
+
+ fflush(stdout);
+
+ return true;
+}
+
+} // namespace WebKit
+
+#endif // PLUGIN_ARCHITECTURE(UNIX) && ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPIdentifierData.cpp webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPIdentifierData.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPIdentifierData.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPIdentifierData.cpp 2022-08-26 14:18:14.985022355 -0500
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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 "config.h"
+#include "NPIdentifierData.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "Decoder.h"
+#include "Encoder.h"
+#include "WebCoreArgumentCoders.h"
+#include <WebCore/IdentifierRep.h>
+
+namespace WebKit {
+using namespace WebCore;
+
+NPIdentifierData::NPIdentifierData()
+ : m_isString(false)
+ , m_number(0)
+{
+}
+
+
+NPIdentifierData NPIdentifierData::fromNPIdentifier(NPIdentifier npIdentifier)
+{
+ NPIdentifierData npIdentifierData;
+
+ IdentifierRep* identifierRep = static_cast<IdentifierRep*>(npIdentifier);
+ npIdentifierData.m_isString = identifierRep->isString();
+
+ if (npIdentifierData.m_isString)
+ npIdentifierData.m_string = identifierRep->string();
+ else
+ npIdentifierData.m_number = identifierRep->number();
+
+ return npIdentifierData;
+}
+
+NPIdentifier NPIdentifierData::createNPIdentifier() const
+{
+ if (m_isString)
+ return static_cast<NPIdentifier>(IdentifierRep::get(m_string.data()));
+
+ return static_cast<NPIdentifier>(IdentifierRep::get(m_number));
+}
+
+void NPIdentifierData::encode(IPC::Encoder& encoder) const
+{
+ encoder << m_isString;
+ if (m_isString)
+ encoder << m_string;
+ else
+ encoder << m_number;
+}
+
+std::optional<NPIdentifierData> NPIdentifierData::decode(IPC::Decoder& decoder)
+{
+ NPIdentifierData result;
+ if (!decoder.decode(result.m_isString))
+ return std::nullopt;
+
+ if (result.m_isString) {
+ if (!decoder.decode(result.m_string))
+ return std::nullopt;
+ return result;
+ }
+
+ if (!decoder.decode(result.m_number))
+ return std::nullopt;
+ return result;
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPIdentifierData.h webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPIdentifierData.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPIdentifierData.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPIdentifierData.h 2022-08-26 14:18:14.985022355 -0500
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+ */
+
+#pragma once
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include <WebCore/npruntime_internal.h>
+#include <wtf/text/CString.h>
+
+namespace IPC {
+class Decoder;
+class Encoder;
+}
+
+namespace WebKit {
+
+class NPIdentifierData {
+public:
+ NPIdentifierData();
+
+ static NPIdentifierData fromNPIdentifier(NPIdentifier);
+ NPIdentifier createNPIdentifier() const;
+
+ void encode(IPC::Encoder&) const;
+ static std::optional<NPIdentifierData> decode(IPC::Decoder&);
+
+private:
+ bool m_isString;
+ CString m_string;
+ int m_number;
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPObjectMessageReceiver.cpp webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPObjectMessageReceiver.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPObjectMessageReceiver.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPObjectMessageReceiver.cpp 2022-08-26 14:18:14.985022355 -0500
@@ -0,0 +1,231 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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 "config.h"
+#include "NPObjectMessageReceiver.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "NPIdentifierData.h"
+#include "NPRemoteObjectMap.h"
+#include "NPRuntimeUtilities.h"
+#include "NPVariantData.h"
+#include "Plugin.h"
+#include "PluginController.h"
+
+namespace WebKit {
+
+NPObjectMessageReceiver::NPObjectMessageReceiver(NPRemoteObjectMap* npRemoteObjectMap, Plugin* plugin, uint64_t npObjectID, NPObject* npObject)
+ : m_npRemoteObjectMap(npRemoteObjectMap)
+ , m_plugin(plugin)
+ , m_npObjectID(npObjectID)
+ , m_npObject(npObject)
+{
+ retainNPObject(m_npObject);
+}
+
+NPObjectMessageReceiver::~NPObjectMessageReceiver()
+{
+ m_npRemoteObjectMap->unregisterNPObject(m_npObjectID);
+
+ releaseNPObject(m_npObject);
+}
+
+void NPObjectMessageReceiver::deallocate(CompletionHandler<void()>&& completionHandler)
+{
+ delete this;
+ completionHandler();
+}
+
+void NPObjectMessageReceiver::hasMethod(const NPIdentifierData& methodNameData, CompletionHandler<void(bool)>&& completionHandler)
+{
+ if (m_plugin->isBeingDestroyed() || !m_npObject->_class->hasMethod)
+ return completionHandler(false);
+
+ completionHandler(m_npObject->_class->hasMethod(m_npObject, methodNameData.createNPIdentifier()));
+}
+
+void NPObjectMessageReceiver::invoke(const NPIdentifierData& methodNameData, const Vector<NPVariantData>& argumentsData, CompletionHandler<void(bool, NPVariantData&&)>&& completionHandler)
+{
+ if (m_plugin->isBeingDestroyed() || !m_npObject->_class->invoke)
+ return completionHandler(false, { });
+
+ Vector<NPVariant> arguments;
+ for (size_t i = 0; i < argumentsData.size(); ++i)
+ arguments.append(m_npRemoteObjectMap->npVariantDataToNPVariant(argumentsData[i], m_plugin));
+
+ NPVariant result;
+ VOID_TO_NPVARIANT(result);
+
+ PluginController::PluginDestructionProtector protector(m_plugin->controller());
+
+ NPVariantData resultData;
+ bool returnValue = m_npObject->_class->invoke(m_npObject, methodNameData.createNPIdentifier(), arguments.data(), arguments.size(), &result);
+ if (returnValue) {
+ // Convert the NPVariant to an NPVariantData.
+ resultData = m_npRemoteObjectMap->npVariantToNPVariantData(result, m_plugin);
+ }
+
+ // Release all arguments.
+ for (size_t i = 0; i < argumentsData.size(); ++i)
+ releaseNPVariantValue(&arguments[i]);
+
+ // And release the result.
+ releaseNPVariantValue(&result);
+ completionHandler(returnValue, WTFMove(resultData));
+}
+
+void NPObjectMessageReceiver::invokeDefault(const Vector<NPVariantData>& argumentsData, CompletionHandler<void(bool, NPVariantData&&)>&& completionHandler)
+{
+ if (m_plugin->isBeingDestroyed() || !m_npObject->_class->invokeDefault)
+ return completionHandler(false, { });
+
+ Vector<NPVariant> arguments;
+ for (size_t i = 0; i < argumentsData.size(); ++i)
+ arguments.append(m_npRemoteObjectMap->npVariantDataToNPVariant(argumentsData[i], m_plugin));
+
+ NPVariant result;
+ VOID_TO_NPVARIANT(result);
+
+ PluginController::PluginDestructionProtector protector(m_plugin->controller());
+
+ NPVariantData resultData;
+ bool returnValue = m_npObject->_class->invokeDefault(m_npObject, arguments.data(), arguments.size(), &result);
+ if (returnValue) {
+ // Convert the NPVariant to an NPVariantData.
+ resultData = m_npRemoteObjectMap->npVariantToNPVariantData(result, m_plugin);
+ }
+
+ // Release all arguments.
+ for (size_t i = 0; i < argumentsData.size(); ++i)
+ releaseNPVariantValue(&arguments[i]);
+
+ // And release the result.
+ releaseNPVariantValue(&result);
+ completionHandler(returnValue, WTFMove(resultData));
+}
+
+void NPObjectMessageReceiver::hasProperty(const NPIdentifierData& propertyNameData, CompletionHandler<void(bool)>&& completionHandler)
+{
+ if (m_plugin->isBeingDestroyed() || !m_npObject->_class->hasProperty)
+ return completionHandler(false);
+
+ completionHandler(m_npObject->_class->hasProperty(m_npObject, propertyNameData.createNPIdentifier()));
+}
+
+void NPObjectMessageReceiver::getProperty(const NPIdentifierData& propertyNameData, CompletionHandler<void(bool, NPVariantData&&)>&& completionHandler)
+{
+ if (m_plugin->isBeingDestroyed() || !m_npObject->_class->getProperty)
+ return completionHandler(false, { });
+
+ NPVariant result;
+ VOID_TO_NPVARIANT(result);
+
+ PluginController::PluginDestructionProtector protector(m_plugin->controller());
+
+ bool returnValue = m_npObject->_class->getProperty(m_npObject, propertyNameData.createNPIdentifier(), &result);
+ if (!returnValue)
+ return completionHandler(false, { });
+
+
+ NPVariantData resultData = m_npRemoteObjectMap->npVariantToNPVariantData(result, m_plugin);
+
+ releaseNPVariantValue(&result);
+ completionHandler(true, WTFMove(resultData));
+}
+
+void NPObjectMessageReceiver::setProperty(const NPIdentifierData& propertyNameData, const NPVariantData& propertyValueData, CompletionHandler<void(bool)>&& completionHandler)
+{
+ if (m_plugin->isBeingDestroyed() || !m_npObject->_class->setProperty)
+ return completionHandler(false);
+
+ NPVariant propertyValue = m_npRemoteObjectMap->npVariantDataToNPVariant(propertyValueData, m_plugin);
+
+ PluginController::PluginDestructionProtector protector(m_plugin->controller());
+
+ bool returnValue = m_npObject->_class->setProperty(m_npObject, propertyNameData.createNPIdentifier(), &propertyValue);
+
+ releaseNPVariantValue(&propertyValue);
+ completionHandler(returnValue);
+}
+
+void NPObjectMessageReceiver::removeProperty(const NPIdentifierData& propertyNameData, CompletionHandler<void(bool)>&& completionHandler)
+{
+ if (m_plugin->isBeingDestroyed() || !m_npObject->_class->removeProperty)
+ return completionHandler(false);
+
+ completionHandler(m_npObject->_class->removeProperty(m_npObject, propertyNameData.createNPIdentifier()));
+}
+
+void NPObjectMessageReceiver::enumerate(CompletionHandler<void(bool, Vector<NPIdentifierData>&&)>&& completionHandler)
+{
+ if (m_plugin->isBeingDestroyed() || !NP_CLASS_STRUCT_VERSION_HAS_ENUM(m_npObject->_class) || !m_npObject->_class->enumerate)
+ return completionHandler(false, { });
+
+ NPIdentifier* identifiers = 0;
+ uint32_t identifierCount = 0;
+
+ bool returnValue = m_npObject->_class->enumerate(m_npObject, &identifiers, &identifierCount);
+ if (!returnValue)
+ return completionHandler(false, { });
+
+ Vector<WebKit::NPIdentifierData> identifiersData;
+ for (uint32_t i = 0; i < identifierCount; ++i)
+ identifiersData.append(NPIdentifierData::fromNPIdentifier(identifiers[i]));
+
+ npnMemFree(identifiers);
+ completionHandler(true, WTFMove(identifiersData));
+}
+
+void NPObjectMessageReceiver::construct(const Vector<NPVariantData>& argumentsData, CompletionHandler<void(bool, NPVariantData&&)>&& completionHandler)
+{
+ if (m_plugin->isBeingDestroyed() || !NP_CLASS_STRUCT_VERSION_HAS_CTOR(m_npObject->_class) || !m_npObject->_class->construct)
+ return completionHandler(false, { });
+
+ Vector<NPVariant> arguments;
+ for (size_t i = 0; i < argumentsData.size(); ++i)
+ arguments.append(m_npRemoteObjectMap->npVariantDataToNPVariant(argumentsData[i], m_plugin));
+
+ NPVariant result;
+ VOID_TO_NPVARIANT(result);
+
+ PluginController::PluginDestructionProtector protector(m_plugin->controller());
+
+ bool returnValue = m_npObject->_class->construct(m_npObject, arguments.data(), arguments.size(), &result);
+ NPVariantData resultData;
+ if (returnValue)
+ resultData = m_npRemoteObjectMap->npVariantToNPVariantData(result, m_plugin);
+
+ for (size_t i = 0; i < argumentsData.size(); ++i)
+ releaseNPVariantValue(&arguments[i]);
+
+ releaseNPVariantValue(&result);
+ completionHandler(returnValue, WTFMove(resultData));
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPObjectMessageReceiver.h webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPObjectMessageReceiver.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPObjectMessageReceiver.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPObjectMessageReceiver.h 2022-08-26 14:18:14.985022355 -0500
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+ */
+
+#pragma once
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "Connection.h"
+#include <WebCore/npruntime.h>
+#include <wtf/Noncopyable.h>
+
+namespace WebKit {
+
+class NPIdentifierData;
+class NPRemoteObjectMap;
+class NPVariantData;
+class Plugin;
+
+class NPObjectMessageReceiver {
+ WTF_MAKE_FAST_ALLOCATED;
+ WTF_MAKE_NONCOPYABLE(NPObjectMessageReceiver);
+
+public:
+ NPObjectMessageReceiver(NPRemoteObjectMap*, Plugin*, uint64_t npObjectID, NPObject*);
+ ~NPObjectMessageReceiver();
+
+ bool didReceiveSyncNPObjectMessageReceiverMessage(IPC::Connection&, IPC::Decoder&, UniqueRef<IPC::Encoder>&);
+
+ Plugin* plugin() const { return m_plugin; }
+ NPObject* npObject() const { return m_npObject; }
+
+private:
+ // Message handlers.
+ void deallocate(CompletionHandler<void()>&&);
+ void hasMethod(const NPIdentifierData&, CompletionHandler<void(bool)>&&);
+ void invoke(const NPIdentifierData&, const Vector<NPVariantData>& argumentsData, CompletionHandler<void(bool, NPVariantData&&)>&&);
+ void invokeDefault(const Vector<NPVariantData>& argumentsData, CompletionHandler<void(bool, NPVariantData&&)>&&);
+ void hasProperty(const NPIdentifierData&, CompletionHandler<void(bool)>&&);
+ void getProperty(const NPIdentifierData&, CompletionHandler<void(bool, NPVariantData&&)>&&);
+ void setProperty(const NPIdentifierData&, const NPVariantData& propertyValueData, CompletionHandler<void(bool)>&&);
+ void removeProperty(const NPIdentifierData&, CompletionHandler<void(bool)>&&);
+ void enumerate(CompletionHandler<void(bool, Vector<NPIdentifierData>&&)>&&);
+ void construct(const Vector<NPVariantData>& argumentsData, CompletionHandler<void(bool, NPVariantData&&)>&&);
+
+ NPRemoteObjectMap* m_npRemoteObjectMap;
+ Plugin* m_plugin;
+ uint64_t m_npObjectID;
+ NPObject* m_npObject;
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPObjectMessageReceiver.messages.in webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPObjectMessageReceiver.messages.in
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPObjectMessageReceiver.messages.in 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPObjectMessageReceiver.messages.in 2022-08-26 14:18:14.985022355 -0500
@@ -0,0 +1,38 @@
+# Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+messages -> NPObjectMessageReceiver LegacyReceiver NotRefCounted {
+ Deallocate() -> () Synchronous
+ HasMethod(WebKit::NPIdentifierData methodName) -> (bool returnValue) Synchronous
+ Invoke(WebKit::NPIdentifierData methodName, Vector<WebKit::NPVariantData> argumentsData) -> (bool returnValue, WebKit::NPVariantData resultData) Synchronous
+ InvokeDefault(Vector<WebKit::NPVariantData> argumentsData) -> (bool returnValue, WebKit::NPVariantData resultData) Synchronous
+ HasProperty(WebKit::NPIdentifierData propertyName) -> (bool returnValue) Synchronous
+ GetProperty(WebKit::NPIdentifierData propertyName) -> (bool returnValue, WebKit::NPVariantData resultData) Synchronous
+ SetProperty(WebKit::NPIdentifierData propertyName, WebKit::NPVariantData propertyValueData) -> (bool returnValue) Synchronous
+ RemoveProperty(WebKit::NPIdentifierData propertyName) -> (bool returnValue) Synchronous
+ Enumerate() -> (bool returnValue, Vector<WebKit::NPIdentifierData> identifiersData) Synchronous
+ Construct(Vector<WebKit::NPVariantData> argumentsData) -> (bool returnValue, WebKit::NPVariantData resultData) Synchronous
+}
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPObjectProxy.cpp webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPObjectProxy.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPObjectProxy.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPObjectProxy.cpp 2022-08-26 14:18:14.985022355 -0500
@@ -0,0 +1,357 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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 "config.h"
+#include "NPObjectProxy.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "ArgumentCoders.h"
+#include "Connection.h"
+#include "NPIdentifierData.h"
+#include "NPObjectMessageReceiverMessages.h"
+#include "NPRemoteObjectMap.h"
+#include "NPRuntimeUtilities.h"
+#include "NPVariantData.h"
+#include <wtf/MainThread.h>
+#include <wtf/RunLoop.h>
+
+namespace WebKit {
+
+NPObjectProxy* NPObjectProxy::create(NPRemoteObjectMap* npRemoteObjectMap, Plugin* plugin, uint64_t npObjectID)
+{
+ NPObjectProxy* npObjectProxy = toNPObjectProxy(createNPObject(0, npClass()));
+ npObjectProxy->initialize(npRemoteObjectMap, plugin, npObjectID);
+
+ return npObjectProxy;
+}
+
+NPObjectProxy::NPObjectProxy()
+ : m_npRemoteObjectMap(0)
+ , m_plugin(0)
+ , m_npObjectID(0)
+{
+}
+
+NPObjectProxy::~NPObjectProxy()
+{
+ ASSERT(RunLoop::isMain());
+
+ if (!m_npRemoteObjectMap)
+ return;
+
+ m_npRemoteObjectMap->npObjectProxyDestroyed(this);
+ m_npRemoteObjectMap->connection()->sendSync(Messages::NPObjectMessageReceiver::Deallocate(), Messages::NPObjectMessageReceiver::Deallocate::Reply(), m_npObjectID);
+}
+
+bool NPObjectProxy::isNPObjectProxy(NPObject* npObject)
+{
+ return npObject->_class == npClass();
+}
+
+void NPObjectProxy::invalidate()
+{
+ ASSERT(m_npRemoteObjectMap);
+ ASSERT(m_plugin);
+
+ m_npRemoteObjectMap = 0;
+ m_plugin = 0;
+}
+
+void NPObjectProxy::initialize(NPRemoteObjectMap* npRemoteObjectMap, Plugin* plugin, uint64_t npObjectID)
+{
+ ASSERT(!m_npRemoteObjectMap);
+ ASSERT(!m_plugin);
+ ASSERT(!m_npObjectID);
+
+ ASSERT(npRemoteObjectMap);
+ ASSERT(plugin);
+ ASSERT(npObjectID);
+
+ m_npRemoteObjectMap = npRemoteObjectMap;
+ m_plugin = plugin;
+ m_npObjectID = npObjectID;
+}
+
+bool NPObjectProxy::hasMethod(NPIdentifier methodName)
+{
+ if (!m_npRemoteObjectMap)
+ return false;
+
+ NPIdentifierData methodNameData = NPIdentifierData::fromNPIdentifier(methodName);
+
+ bool returnValue = false;
+
+ if (!m_npRemoteObjectMap->connection()->sendSync(Messages::NPObjectMessageReceiver::HasMethod(methodNameData), Messages::NPObjectMessageReceiver::HasMethod::Reply(returnValue), m_npObjectID))
+ return false;
+
+ return returnValue;
+}
+
+bool NPObjectProxy::invoke(NPIdentifier methodName, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
+{
+ if (!m_npRemoteObjectMap)
+ return false;
+
+ NPIdentifierData methodNameData = NPIdentifierData::fromNPIdentifier(methodName);
+ Vector<NPVariantData> argumentsData;
+ for (uint32_t i = 0; i < argumentCount; ++i)
+ argumentsData.append(m_npRemoteObjectMap->npVariantToNPVariantData(arguments[i], m_plugin));
+
+ bool returnValue = false;
+ NPVariantData resultData;
+
+ if (!m_npRemoteObjectMap->connection()->sendSync(Messages::NPObjectMessageReceiver::Invoke(methodNameData, argumentsData), Messages::NPObjectMessageReceiver::Invoke::Reply(returnValue, resultData), m_npObjectID))
+ return false;
+
+ if (!returnValue)
+ return false;
+
+ *result = m_npRemoteObjectMap->npVariantDataToNPVariant(resultData, m_plugin);
+ return true;
+}
+
+bool NPObjectProxy::invokeDefault(const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
+{
+ if (!m_npRemoteObjectMap)
+ return false;
+
+ Vector<NPVariantData> argumentsData;
+ for (uint32_t i = 0; i < argumentCount; ++i)
+ argumentsData.append(m_npRemoteObjectMap->npVariantToNPVariantData(arguments[i], m_plugin));
+
+ bool returnValue = false;
+ NPVariantData resultData;
+
+ if (!m_npRemoteObjectMap->connection()->sendSync(Messages::NPObjectMessageReceiver::InvokeDefault(argumentsData), Messages::NPObjectMessageReceiver::InvokeDefault::Reply(returnValue, resultData), m_npObjectID))
+ return false;
+
+ if (!returnValue)
+ return false;
+
+ *result = m_npRemoteObjectMap->npVariantDataToNPVariant(resultData, m_plugin);
+ return true;
+}
+
+bool NPObjectProxy::hasProperty(NPIdentifier propertyName)
+{
+ if (!m_npRemoteObjectMap)
+ return false;
+
+ NPIdentifierData propertyNameData = NPIdentifierData::fromNPIdentifier(propertyName);
+
+ bool returnValue = false;
+
+ if (!m_npRemoteObjectMap->connection()->sendSync(Messages::NPObjectMessageReceiver::HasProperty(propertyNameData), Messages::NPObjectMessageReceiver::HasProperty::Reply(returnValue), m_npObjectID))
+ return false;
+
+ return returnValue;
+}
+
+bool NPObjectProxy::getProperty(NPIdentifier propertyName, NPVariant* result)
+{
+ if (!m_npRemoteObjectMap)
+ return false;
+
+ NPIdentifierData propertyNameData = NPIdentifierData::fromNPIdentifier(propertyName);
+
+ bool returnValue = false;
+ NPVariantData resultData;
+
+ if (!m_npRemoteObjectMap->connection()->sendSync(Messages::NPObjectMessageReceiver::GetProperty(propertyNameData), Messages::NPObjectMessageReceiver::GetProperty::Reply(returnValue, resultData), m_npObjectID))
+ return false;
+
+ if (!returnValue)
+ return false;
+
+ *result = m_npRemoteObjectMap->npVariantDataToNPVariant(resultData, m_plugin);
+ return true;
+}
+
+bool NPObjectProxy::setProperty(NPIdentifier propertyName, const NPVariant* value)
+{
+ if (!m_npRemoteObjectMap)
+ return false;
+
+ NPIdentifierData propertyNameData = NPIdentifierData::fromNPIdentifier(propertyName);
+ NPVariantData propertyValueData = m_npRemoteObjectMap->npVariantToNPVariantData(*value, m_plugin);
+
+ bool returnValue = false;
+
+ if (!m_npRemoteObjectMap->connection()->sendSync(Messages::NPObjectMessageReceiver::SetProperty(propertyNameData, propertyValueData), Messages::NPObjectMessageReceiver::SetProperty::Reply(returnValue), m_npObjectID))
+ return false;
+
+ return returnValue;
+}
+
+bool NPObjectProxy::removeProperty(NPIdentifier propertyName)
+{
+ if (!m_npRemoteObjectMap)
+ return false;
+
+ NPIdentifierData propertyNameData = NPIdentifierData::fromNPIdentifier(propertyName);
+
+ bool returnValue = false;
+
+ if (!m_npRemoteObjectMap->connection()->sendSync(Messages::NPObjectMessageReceiver::RemoveProperty(propertyNameData), Messages::NPObjectMessageReceiver::RemoveProperty::Reply(returnValue), m_npObjectID))
+ return false;
+
+ return returnValue;
+}
+
+bool NPObjectProxy::enumerate(NPIdentifier** identifiers, uint32_t* identifierCount)
+{
+ if (!m_npRemoteObjectMap)
+ return false;
+
+ bool returnValue;
+ Vector<NPIdentifierData> identifiersData;
+
+ if (!m_npRemoteObjectMap->connection()->sendSync(Messages::NPObjectMessageReceiver::Enumerate(), Messages::NPObjectMessageReceiver::Enumerate::Reply(returnValue, identifiersData), m_npObjectID))
+ return false;
+
+ if (!returnValue)
+ return false;
+
+ NPIdentifier* nameIdentifiers = npnMemNewArray<NPIdentifier>(identifiersData.size());
+
+ for (size_t i = 0; i < identifiersData.size(); ++i)
+ nameIdentifiers[i] = identifiersData[i].createNPIdentifier();
+
+ *identifiers = nameIdentifiers;
+ *identifierCount = identifiersData.size();
+ return true;
+}
+
+bool NPObjectProxy::construct(const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
+{
+ if (!m_npRemoteObjectMap)
+ return false;
+
+ Vector<NPVariantData> argumentsData;
+ for (uint32_t i = 0; i < argumentCount; ++i)
+ argumentsData.append(m_npRemoteObjectMap->npVariantToNPVariantData(arguments[i], m_plugin));
+
+ bool returnValue = false;
+ NPVariantData resultData;
+
+ if (!m_npRemoteObjectMap->connection()->sendSync(Messages::NPObjectMessageReceiver::Construct(argumentsData), Messages::NPObjectMessageReceiver::Construct::Reply(returnValue, resultData), m_npObjectID))
+ return false;
+
+ if (!returnValue)
+ return false;
+
+ *result = m_npRemoteObjectMap->npVariantDataToNPVariant(resultData, m_plugin);
+ return true;
+}
+
+NPClass* NPObjectProxy::npClass()
+{
+ static NPClass npClass = {
+ NP_CLASS_STRUCT_VERSION,
+ NP_Allocate,
+ NP_Deallocate,
+ 0,
+ NP_HasMethod,
+ NP_Invoke,
+ NP_InvokeDefault,
+ NP_HasProperty,
+ NP_GetProperty,
+ NP_SetProperty,
+ NP_RemoveProperty,
+ NP_Enumerate,
+ NP_Construct
+ };
+
+ return &npClass;
+}
+
+NPObject* NPObjectProxy::NP_Allocate(NPP npp, NPClass*)
+{
+ ASSERT_UNUSED(npp, !npp);
+
+ return new NPObjectProxy;
+}
+
+void NPObjectProxy::NP_Deallocate(NPObject* npObject)
+{
+ // http://webkit.org/b/118535 - The Java Netscape Plug-in has a background thread do some of their NPP_Destroy work.
+ // That background thread can call NP_Deallocate, and this leads to a WebProcess <-> PluginProcess deadlock.
+ // Since NPAPI behavior on a background thread is undefined, it is okay to limit this workaround to the one API
+ // that is known to be misused during plugin teardown, and to not be concerned about change in behavior if this
+ // occured at any other time.
+ ensureOnMainRunLoop([npObject] {
+ delete toNPObjectProxy(npObject);
+ });
+}
+
+bool NPObjectProxy::NP_HasMethod(NPObject* npObject, NPIdentifier methodName)
+{
+ return toNPObjectProxy(npObject)->hasMethod(methodName);
+}
+
+bool NPObjectProxy::NP_Invoke(NPObject* npObject, NPIdentifier methodName, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
+{
+ return toNPObjectProxy(npObject)->invoke(methodName, arguments, argumentCount, result);
+}
+
+bool NPObjectProxy::NP_InvokeDefault(NPObject* npObject, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
+{
+ return toNPObjectProxy(npObject)->invokeDefault(arguments, argumentCount, result);
+}
+
+bool NPObjectProxy::NP_HasProperty(NPObject* npObject, NPIdentifier propertyName)
+{
+ return toNPObjectProxy(npObject)->hasProperty(propertyName);
+}
+
+bool NPObjectProxy::NP_GetProperty(NPObject* npObject, NPIdentifier propertyName, NPVariant* result)
+{
+ return toNPObjectProxy(npObject)->getProperty(propertyName, result);
+}
+
+bool NPObjectProxy::NP_SetProperty(NPObject* npObject, NPIdentifier propertyName, const NPVariant* value)
+{
+ return toNPObjectProxy(npObject)->setProperty(propertyName, value);
+}
+
+bool NPObjectProxy::NP_RemoveProperty(NPObject* npObject, NPIdentifier propertyName)
+{
+ return toNPObjectProxy(npObject)->removeProperty(propertyName);
+}
+
+bool NPObjectProxy::NP_Enumerate(NPObject* npObject, NPIdentifier** identifiers, uint32_t* identifierCount)
+{
+ return toNPObjectProxy(npObject)->enumerate(identifiers, identifierCount);
+}
+
+bool NPObjectProxy::NP_Construct(NPObject* npObject, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
+{
+ return toNPObjectProxy(npObject)->construct(arguments, argumentCount, result);
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPObjectProxy.h webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPObjectProxy.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPObjectProxy.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPObjectProxy.h 2022-08-26 14:18:14.985022355 -0500
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2010-2020 Apple 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 INC. 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 INC. 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.
+ */
+
+#pragma once
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include <WebCore/npruntime_internal.h>
+#include <wtf/Noncopyable.h>
+
+namespace WebKit {
+
+class NPRemoteObjectMap;
+class Plugin;
+
+class NPObjectProxy : public NPObject {
+ WTF_MAKE_NONCOPYABLE(NPObjectProxy);
+
+public:
+ static NPObjectProxy* create(NPRemoteObjectMap*, Plugin*, uint64_t npObjectID);
+
+ static bool isNPObjectProxy(NPObject*);
+
+ static NPObjectProxy* toNPObjectProxy(NPObject* npObject)
+ {
+ RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(isNPObjectProxy(npObject));
+ return static_cast<NPObjectProxy*>(npObject);
+ }
+
+ Plugin* plugin() const { return m_plugin; }
+ uint64_t npObjectID() const { return m_npObjectID; }
+
+ void invalidate();
+
+private:
+ NPObjectProxy();
+ ~NPObjectProxy();
+
+ void initialize(NPRemoteObjectMap*, Plugin*, uint64_t npObjectID);
+
+ bool hasMethod(NPIdentifier methodName);
+ bool invoke(NPIdentifier methodName, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result);
+ bool invokeDefault(const NPVariant* arguments, uint32_t argumentCount, NPVariant* result);
+ bool hasProperty(NPIdentifier propertyName);
+ bool getProperty(NPIdentifier propertyName, NPVariant* result);
+ bool setProperty(NPIdentifier propertyName, const NPVariant* value);
+ bool removeProperty(NPIdentifier propertyName);
+ bool enumerate(NPIdentifier** identifiers, uint32_t* identifierCount);
+ bool construct(const NPVariant* arguments, uint32_t argumentCount, NPVariant* result);
+
+ static NPClass* npClass();
+ static NPObject* NP_Allocate(NPP, NPClass*);
+ static void NP_Deallocate(NPObject*);
+ static bool NP_HasMethod(NPObject*, NPIdentifier methodName);
+ static bool NP_Invoke(NPObject*, NPIdentifier methodName, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result);
+ static bool NP_InvokeDefault(NPObject*, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result);
+ static bool NP_HasProperty(NPObject*, NPIdentifier propertyName);
+ static bool NP_GetProperty(NPObject*, NPIdentifier propertyName, NPVariant* result);
+ static bool NP_SetProperty(NPObject*, NPIdentifier propertyName, const NPVariant* value);
+ static bool NP_RemoveProperty(NPObject*, NPIdentifier propertyName);
+ static bool NP_Enumerate(NPObject*, NPIdentifier** identifiers, uint32_t* identifierCount);
+ static bool NP_Construct(NPObject*, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result);
+
+ NPRemoteObjectMap* m_npRemoteObjectMap;
+ Plugin* m_plugin;
+ uint64_t m_npObjectID;
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPRemoteObjectMap.cpp webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPRemoteObjectMap.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPRemoteObjectMap.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPRemoteObjectMap.cpp 2022-08-26 14:18:14.985022355 -0500
@@ -0,0 +1,231 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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 "config.h"
+#include "NPRemoteObjectMap.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "NPObjectMessageReceiver.h"
+#include "NPObjectProxy.h"
+#include "NPRuntimeUtilities.h"
+#include "NPVariantData.h"
+
+namespace WebKit {
+
+static uint64_t generateNPObjectID()
+{
+ static uint64_t generateNPObjectID;
+ return ++generateNPObjectID;
+}
+
+Ref<NPRemoteObjectMap> NPRemoteObjectMap::create(IPC::Connection* connection)
+{
+ return adoptRef(*new NPRemoteObjectMap(connection));
+}
+
+NPRemoteObjectMap::NPRemoteObjectMap(IPC::Connection* connection)
+ : m_connection(connection)
+{
+}
+
+NPRemoteObjectMap::~NPRemoteObjectMap()
+{
+ ASSERT(m_npObjectProxies.isEmpty());
+ ASSERT(m_registeredNPObjects.isEmpty());
+}
+
+NPObject* NPRemoteObjectMap::createNPObjectProxy(uint64_t remoteObjectID, Plugin* plugin)
+{
+ NPObjectProxy* npObjectProxy = NPObjectProxy::create(this, plugin, remoteObjectID);
+
+ m_npObjectProxies.add(npObjectProxy);
+
+ return npObjectProxy;
+}
+
+void NPRemoteObjectMap::npObjectProxyDestroyed(NPObject* npObject)
+{
+ NPObjectProxy* npObjectProxy = NPObjectProxy::toNPObjectProxy(npObject);
+ ASSERT(m_npObjectProxies.contains(npObjectProxy));
+
+ m_npObjectProxies.remove(npObjectProxy);
+}
+
+uint64_t NPRemoteObjectMap::registerNPObject(NPObject* npObject, Plugin* plugin)
+{
+ uint64_t npObjectID = generateNPObjectID();
+ m_registeredNPObjects.set(npObjectID, makeUnique<NPObjectMessageReceiver>(this, plugin, npObjectID, npObject).release());
+
+ return npObjectID;
+}
+
+void NPRemoteObjectMap::unregisterNPObject(uint64_t npObjectID)
+{
+ m_registeredNPObjects.remove(npObjectID);
+}
+
+static uint64_t remoteNPObjectID(Plugin* plugin, NPObject* npObject)
+{
+ if (!NPObjectProxy::isNPObjectProxy(npObject))
+ return 0;
+
+ NPObjectProxy* npObjectProxy = NPObjectProxy::toNPObjectProxy(npObject);
+ if (npObjectProxy->plugin() != plugin)
+ return 0;
+
+ return npObjectProxy->npObjectID();
+}
+
+NPVariantData NPRemoteObjectMap::npVariantToNPVariantData(const NPVariant& variant, Plugin* plugin)
+{
+ switch (variant.type) {
+ case NPVariantType_Void:
+ return NPVariantData::makeVoid();
+
+ case NPVariantType_Null:
+ return NPVariantData::makeNull();
+
+ case NPVariantType_Bool:
+ return NPVariantData::makeBool(variant.value.boolValue);
+
+ case NPVariantType_Int32:
+ return NPVariantData::makeInt32(variant.value.intValue);
+
+ case NPVariantType_Double:
+ return NPVariantData::makeDouble(variant.value.doubleValue);
+
+ case NPVariantType_String:
+ return NPVariantData::makeString(variant.value.stringValue.UTF8Characters, variant.value.stringValue.UTF8Length);
+
+ case NPVariantType_Object: {
+ NPObject* npObject = variant.value.objectValue;
+
+ if (uint64_t npObjectID = remoteNPObjectID(plugin, npObject)) {
+ // FIXME: Under some circumstances, this might leak the NPObjectProxy object.
+ // Figure out how to avoid that.
+ retainNPObject(npObject);
+ return NPVariantData::makeRemoteNPObjectID(npObjectID);
+ }
+
+ uint64_t npObjectID = registerNPObject(npObject, plugin);
+ return NPVariantData::makeLocalNPObjectID(npObjectID);
+ }
+
+ }
+
+ ASSERT_NOT_REACHED();
+ return NPVariantData::makeVoid();
+}
+
+NPVariant NPRemoteObjectMap::npVariantDataToNPVariant(const NPVariantData& npVariantData, Plugin* plugin)
+{
+ NPVariant npVariant;
+
+ switch (npVariantData.type()) {
+ case NPVariantData::Void:
+ VOID_TO_NPVARIANT(npVariant);
+ break;
+ case NPVariantData::Null:
+ NULL_TO_NPVARIANT(npVariant);
+ break;
+ case NPVariantData::Bool:
+ BOOLEAN_TO_NPVARIANT(npVariantData.boolValue(), npVariant);
+ break;
+ case NPVariantData::Int32:
+ INT32_TO_NPVARIANT(npVariantData.int32Value(), npVariant);
+ break;
+ case NPVariantData::Double:
+ DOUBLE_TO_NPVARIANT(npVariantData.doubleValue(), npVariant);
+ break;
+ case NPVariantData::String: {
+ NPString npString = createNPString(npVariantData.stringValue());
+ STRINGN_TO_NPVARIANT(npString.UTF8Characters, npString.UTF8Length, npVariant);
+ break;
+ }
+ case NPVariantData::LocalNPObjectID: {
+ uint64_t npObjectID = npVariantData.localNPObjectIDValue();
+ ASSERT(npObjectID);
+
+ NPObjectMessageReceiver* npObjectMessageReceiver = m_registeredNPObjects.get(npObjectID);
+ if (!npObjectMessageReceiver) {
+ ASSERT_NOT_REACHED();
+ VOID_TO_NPVARIANT(npVariant);
+ break;
+ }
+
+ NPObject* npObject = npObjectMessageReceiver->npObject();
+ ASSERT(npObject);
+
+ retainNPObject(npObject);
+ OBJECT_TO_NPVARIANT(npObject, npVariant);
+ break;
+ }
+ case NPVariantData::RemoteNPObjectID: {
+ NPObject* npObjectProxy = createNPObjectProxy(npVariantData.remoteNPObjectIDValue(), plugin);
+ OBJECT_TO_NPVARIANT(npObjectProxy, npVariant);
+ break;
+ }
+ }
+
+ return npVariant;
+}
+
+void NPRemoteObjectMap::pluginDestroyed(Plugin* plugin)
+{
+ // Gather and delete the receivers associated with this plug-in.
+ Vector<NPObjectMessageReceiver*> receivers;
+ for (auto* receiver : m_registeredNPObjects.values()) {
+ if (receiver->plugin() == plugin)
+ receivers.append(receiver);
+ }
+ for (auto* receiver : receivers)
+ delete receiver;
+
+ // Invalidate and remove all proxies associated with this plug-in.
+ Vector<NPObjectProxy*> proxies;
+ for (auto* proxy : m_npObjectProxies) {
+ if (proxy->plugin() == plugin)
+ proxies.append(proxy);
+ }
+ for (auto* proxy : proxies) {
+ proxy->invalidate();
+ ASSERT(m_npObjectProxies.contains(proxy));
+ m_npObjectProxies.remove(proxy);
+ }
+}
+
+bool NPRemoteObjectMap::didReceiveSyncMessage(IPC::Connection& connection, IPC::Decoder& decoder, UniqueRef<IPC::Encoder>& replyEncoder)
+{
+ NPObjectMessageReceiver* messageReceiver = m_registeredNPObjects.get(decoder.destinationID());
+ if (!messageReceiver)
+ return false;
+
+ return messageReceiver->didReceiveSyncNPObjectMessageReceiverMessage(connection, decoder, replyEncoder);
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPRemoteObjectMap.h webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPRemoteObjectMap.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPRemoteObjectMap.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPRemoteObjectMap.h 2022-08-26 14:18:14.985022355 -0500
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+ */
+
+#ifndef NPRemoteObjectMap_h
+#define NPRemoteObjectMap_h
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "Connection.h"
+#include <WebCore/npruntime.h>
+#include <wtf/HashMap.h>
+#include <wtf/HashSet.h>
+#include <wtf/RefCounted.h>
+
+namespace WebKit {
+
+class NPObjectMessageReceiver;
+class NPObjectProxy;
+class NPVariantData;
+class Plugin;
+
+class NPRemoteObjectMap : public RefCounted<NPRemoteObjectMap> {
+public:
+ static Ref<NPRemoteObjectMap> create(IPC::Connection*);
+ ~NPRemoteObjectMap();
+
+ // Creates an NPObjectProxy wrapper for the remote object with the given remote object ID.
+ NPObject* createNPObjectProxy(uint64_t remoteObjectID, Plugin*);
+ void npObjectProxyDestroyed(NPObject*);
+
+ // Expose the given NPObject as a remote object. Returns the objectID.
+ uint64_t registerNPObject(NPObject*, Plugin*);
+ void unregisterNPObject(uint64_t);
+
+ NPVariantData npVariantToNPVariantData(const NPVariant&, Plugin*);
+ NPVariant npVariantDataToNPVariant(const NPVariantData&, Plugin*);
+
+ IPC::Connection* connection() const { return m_connection; }
+
+ void pluginDestroyed(Plugin*);
+
+ bool didReceiveSyncMessage(IPC::Connection&, IPC::Decoder&, UniqueRef<IPC::Encoder>&);
+
+private:
+ explicit NPRemoteObjectMap(IPC::Connection*);
+ IPC::Connection* m_connection;
+
+ // A map of NPObjectMessageReceiver classes, wrapping objects that we export to the
+ // other end of the connection.
+ HashMap<uint64_t, NPObjectMessageReceiver*> m_registeredNPObjects;
+
+ // A set of NPObjectProxy objects associated with this map.
+ HashSet<NPObjectProxy*> m_npObjectProxies;
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif // NPRemoteObjectMap_h
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPVariantData.cpp webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPVariantData.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPVariantData.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPVariantData.cpp 2022-08-26 14:18:14.985022355 -0500
@@ -0,0 +1,203 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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 "config.h"
+#include "NPVariantData.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "Decoder.h"
+#include "Encoder.h"
+#include "WebCoreArgumentCoders.h"
+
+namespace WebKit {
+
+NPVariantData::NPVariantData()
+ : m_type(NPVariantData::Void)
+ , m_boolValue(false)
+ , m_int32Value(0)
+ , m_doubleValue(0)
+ , m_localNPObjectIDValue(0)
+ , m_remoteNPObjectIDValue(0)
+{
+}
+
+NPVariantData NPVariantData::makeVoid()
+{
+ return NPVariantData();
+}
+
+NPVariantData NPVariantData::makeNull()
+{
+ NPVariantData npVariantData;
+
+ npVariantData.m_type = NPVariantData::Null;
+
+ return npVariantData;
+}
+
+NPVariantData NPVariantData::makeBool(bool value)
+{
+ NPVariantData npVariantData;
+
+ npVariantData.m_type = NPVariantData::Bool;
+ npVariantData.m_boolValue = value;
+
+ return npVariantData;
+}
+
+NPVariantData NPVariantData::makeInt32(int32_t value)
+{
+ NPVariantData npVariantData;
+
+ npVariantData.m_type = NPVariantData::Int32;
+ npVariantData.m_int32Value = value;
+
+ return npVariantData;
+}
+
+NPVariantData NPVariantData::makeDouble(double value)
+{
+ NPVariantData npVariantData;
+
+ npVariantData.m_type = NPVariantData::Double;
+ npVariantData.m_doubleValue = value;
+
+ return npVariantData;
+}
+
+NPVariantData NPVariantData::makeString(const char* string, unsigned length)
+{
+ NPVariantData npVariantData;
+
+ npVariantData.m_type = NPVariantData::String;
+ npVariantData.m_stringValue = CString(string, length);
+
+ return npVariantData;
+}
+
+NPVariantData NPVariantData::makeLocalNPObjectID(uint64_t value)
+{
+ NPVariantData npVariantData;
+
+ npVariantData.m_type = NPVariantData::LocalNPObjectID;
+ npVariantData.m_localNPObjectIDValue = value;
+
+ return npVariantData;
+}
+
+NPVariantData NPVariantData::makeRemoteNPObjectID(uint64_t value)
+{
+ NPVariantData npVariantData;
+
+ npVariantData.m_type = NPVariantData::RemoteNPObjectID;
+ npVariantData.m_remoteNPObjectIDValue = value;
+
+ return npVariantData;
+}
+
+void NPVariantData::encode(IPC::Encoder& encoder) const
+{
+ encoder << m_type;
+
+ switch (type()) {
+ case NPVariantData::Void:
+ case NPVariantData::Null:
+ break;
+ case NPVariantData::Bool:
+ encoder << boolValue();
+ break;
+ case NPVariantData::Int32:
+ encoder << int32Value();
+ break;
+ case NPVariantData::Double:
+ encoder << doubleValue();
+ break;
+ case NPVariantData::String:
+ encoder << stringValue();
+ break;
+ case NPVariantData::LocalNPObjectID:
+ encoder << localNPObjectIDValue();
+ break;
+ case NPVariantData::RemoteNPObjectID:
+ encoder << remoteNPObjectIDValue();
+ break;
+ }
+}
+
+std::optional<NPVariantData> NPVariantData::decode(IPC::Decoder& decoder)
+{
+ NPVariantData result;
+ uint32_t type;
+ if (!decoder.decode(type))
+ return std::nullopt;
+
+ // We special-case LocalNPObjectID and RemoteNPObjectID here so a LocalNPObjectID is
+ // decoded as a RemoteNPObjectID and vice versa.
+ // This is done because the type is from the perspective of the other connection, and
+ // thus we have to adjust it to match our own perspective.
+ if (type == NPVariantData::LocalNPObjectID)
+ type = NPVariantData::RemoteNPObjectID;
+ else if (type == NPVariantData::RemoteNPObjectID)
+ type = NPVariantData::LocalNPObjectID;
+
+ result.m_type = type;
+
+ switch (result.m_type) {
+ case NPVariantData::Void:
+ case NPVariantData::Null:
+ return result;
+ case NPVariantData::Bool:
+ if (!decoder.decode(result.m_boolValue))
+ return std::nullopt;
+ return result;
+ case NPVariantData::Int32:
+ if (!decoder.decode(result.m_int32Value))
+ return std::nullopt;
+ return result;
+ case NPVariantData::Double:
+ if (!decoder.decode(result.m_doubleValue))
+ return std::nullopt;
+ return result;
+ case NPVariantData::String:
+ if (!decoder.decode(result.m_stringValue))
+ return std::nullopt;
+ return result;
+ case NPVariantData::LocalNPObjectID:
+ if (!decoder.decode(result.m_localNPObjectIDValue))
+ return std::nullopt;
+ return result;
+ case NPVariantData::RemoteNPObjectID:
+ if (!decoder.decode(result.m_remoteNPObjectIDValue))
+ return std::nullopt;
+ return result;
+ }
+
+ return std::nullopt;
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPVariantData.h webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPVariantData.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/NPVariantData.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/NPVariantData.h 2022-08-26 14:18:14.985022355 -0500
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+ */
+
+#pragma once
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include <wtf/text/CString.h>
+
+namespace IPC {
+class Decoder;
+class Encoder;
+}
+
+namespace WebKit {
+
+class NPVariantData {
+public:
+ enum Type {
+ Void,
+ Null,
+ Bool,
+ Int32,
+ Double,
+ String,
+ LocalNPObjectID,
+ RemoteNPObjectID,
+ };
+ NPVariantData();
+
+ static NPVariantData makeVoid();
+ static NPVariantData makeNull();
+ static NPVariantData makeBool(bool value);
+ static NPVariantData makeInt32(int32_t value);
+ static NPVariantData makeDouble(double value);
+ static NPVariantData makeString(const char* string, unsigned length);
+ static NPVariantData makeLocalNPObjectID(uint64_t value);
+ static NPVariantData makeRemoteNPObjectID(uint64_t value);
+
+ Type type() const { return static_cast<Type>(m_type); }
+
+ bool boolValue() const
+ {
+ ASSERT(type() == NPVariantData::Bool);
+ return m_boolValue;
+ }
+
+ int32_t int32Value() const
+ {
+ ASSERT(type() == NPVariantData::Int32);
+ return m_int32Value;
+ }
+
+ double doubleValue() const
+ {
+ ASSERT(type() == NPVariantData::Double);
+ return m_doubleValue;
+ }
+
+ const CString& stringValue() const
+ {
+ ASSERT(type() == NPVariantData::String);
+ return m_stringValue;
+ }
+
+ uint64_t localNPObjectIDValue() const
+ {
+ ASSERT(type() == NPVariantData::LocalNPObjectID);
+ return m_localNPObjectIDValue;
+ }
+
+ uint64_t remoteNPObjectIDValue() const
+ {
+ ASSERT(type() == NPVariantData::RemoteNPObjectID);
+ return m_remoteNPObjectIDValue;
+ }
+
+ void encode(IPC::Encoder&) const;
+ static std::optional<NPVariantData> decode(IPC::Decoder&);
+
+private:
+ uint32_t m_type;
+ bool m_boolValue;
+ int32_t m_int32Value;
+ double m_doubleValue;
+ CString m_stringValue;
+ uint64_t m_localNPObjectIDValue;
+ uint64_t m_remoteNPObjectIDValue;
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/PluginModuleInfo.h webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/PluginModuleInfo.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/PluginModuleInfo.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/PluginModuleInfo.h 2022-08-26 14:18:14.985022355 -0500
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2011 Apple 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 INC. 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 INC. 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.
+ */
+
+#pragma once
+
+#include <WebCore/PluginData.h>
+
+#if PLATFORM(COCOA)
+#include <mach/machine.h>
+#endif
+
+namespace WebKit {
+
+enum PluginModuleLoadPolicy {
+ // The plug-in module should be loaded normally.
+ PluginModuleLoadNormally,
+
+ // The plug-in module should be loaded normally. If the plug-in has a sandbox, it will be disabled.
+ PluginModuleLoadUnsandboxed,
+
+ // The plug-in should be blocked from being instantiated.
+ // Note that the plug-in will still be seen by e.g. navigator.plugins
+ PluginModuleBlockedForSecurity,
+ PluginModuleBlockedForCompatibility,
+};
+
+struct PluginModuleInfo {
+ String path;
+ WebCore::PluginInfo info;
+
+#if PLATFORM(COCOA)
+ cpu_type_t pluginArchitecture;
+ String bundleIdentifier;
+ String versionString;
+ String shortVersionString;
+ bool hasSandboxProfile;
+#endif
+};
+
+} // namespace WebKit
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/PluginProcessAttributes.h webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/PluginProcessAttributes.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/PluginProcessAttributes.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/PluginProcessAttributes.h 2022-08-26 14:18:14.989022377 -0500
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2013-2020 Apple 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 INC. 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 INC. 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.
+ */
+
+#pragma once
+
+#include "PluginModuleInfo.h"
+#include <wtf/EnumTraits.h>
+
+namespace WebKit {
+
+enum class PluginProcessSandboxPolicy : bool {
+ Normal,
+ Unsandboxed,
+};
+
+struct PluginProcessAttributes {
+ PluginModuleInfo moduleInfo;
+ PluginProcessSandboxPolicy sandboxPolicy;
+};
+
+} // namespace WebKit
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/PluginProcessCreationParameters.cpp webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/PluginProcessCreationParameters.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/PluginProcessCreationParameters.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/PluginProcessCreationParameters.cpp 2022-08-26 14:18:14.989022377 -0500
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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 "config.h"
+#include "PluginProcessCreationParameters.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+#if PLATFORM(COCOA)
+#include "ArgumentCodersCF.h"
+#endif
+#include "WebCoreArgumentCoders.h"
+
+namespace WebKit {
+
+PluginProcessCreationParameters::PluginProcessCreationParameters()
+ : supportsAsynchronousPluginInitialization(false)
+{
+}
+
+void PluginProcessCreationParameters::encode(IPC::Encoder& encoder) const
+{
+ encoder << supportsAsynchronousPluginInitialization;
+ encoder << minimumLifetime;
+ encoder << terminationTimeout;
+#if PLATFORM(COCOA)
+ encoder << acceleratedCompositingPort;
+ encoder << networkATSContext;
+#endif
+}
+
+bool PluginProcessCreationParameters::decode(IPC::Decoder& decoder, PluginProcessCreationParameters& result)
+{
+ if (!decoder.decode(result.supportsAsynchronousPluginInitialization))
+ return false;
+ if (!decoder.decode(result.minimumLifetime))
+ return false;
+ if (!decoder.decode(result.terminationTimeout))
+ return false;
+#if PLATFORM(COCOA)
+ if (!decoder.decode(result.acceleratedCompositingPort))
+ return false;
+ if (!decoder.decode(result.networkATSContext))
+ return false;
+#endif
+
+ return true;
+}
+
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/PluginProcessCreationParameters.h webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/PluginProcessCreationParameters.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/PluginProcessCreationParameters.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/PluginProcessCreationParameters.h 2022-08-26 14:18:14.989022377 -0500
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2010-2018 Apple 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 INC. 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 INC. 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.
+ */
+
+#pragma once
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "PluginProcessAttributes.h"
+#include <wtf/Seconds.h>
+
+#if PLATFORM(COCOA)
+#include <wtf/MachSendRight.h>
+#endif
+
+namespace IPC {
+class Decoder;
+class Encoder;
+}
+
+namespace WebKit {
+
+struct PluginProcessCreationParameters {
+ PluginProcessCreationParameters();
+
+ void encode(IPC::Encoder&) const;
+ static WARN_UNUSED_RETURN bool decode(IPC::Decoder&, PluginProcessCreationParameters&);
+
+ bool supportsAsynchronousPluginInitialization;
+
+ Seconds minimumLifetime;
+ Seconds terminationTimeout;
+
+#if PLATFORM(COCOA)
+ WTF::MachSendRight acceleratedCompositingPort;
+ RetainPtr<CFDataRef> networkATSContext;
+#endif
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/PluginQuirks.h webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/PluginQuirks.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/PluginQuirks.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/PluginQuirks.h 2022-08-26 14:18:14.989022377 -0500
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2010-2020 Apple 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 INC. 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 INC. 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.
+ */
+
+#pragma once
+
+namespace WebKit {
+
+class PluginQuirks {
+public:
+ enum PluginQuirk {
+ // Mac specific quirks:
+#if PLUGIN_ARCHITECTURE(MAC)
+ // The plug-in wants the call to getprogname() to return "WebKitPluginHost".
+ // Adobe Flash Will not handle key down events otherwise.
+ PrognameShouldBeWebKitPluginHost,
+
+ // Supports receiving a paint event, even when using CoreAnimation rendering.
+ SupportsSnapshotting,
+
+ // Make the plug-in opaque unless it has a "background" attribute set to a transparent color
+ // according to http://msdn.microsoft.com/en-us/library/cc838148(VS.95).aspx
+ // A non-existent "background" attribute is interpreted as the named color White which is opaque.
+ // Microsoft Silverlight doesn't opt into transparency using NPN_SetValue and
+ // NPPVpluginTransparentBool, so we'll always force it unless the plug-in has a "background"
+ // attribute that specifies a opaque color.
+ MakeOpaqueUnlessTransparentSilverlightBackgroundAttributeExists,
+
+ // Whether calling NPP_GetValue with NPPVpluginCoreAnimationLayer returns a retained Core Animation
+ // layer or not. According to the NPAPI specifications, plug-in shouldn't return a retained layer but
+ // WebKit1 expects a retained plug-in layer. We use this for Flash to avoid leaking OpenGL layers.
+ ReturnsRetainedCoreAnimationLayer,
+
+ // Whether NPP_GetValue with NPPVpluginScriptableNPObject returns a non-retained NPObject or not.
+ // Versions of Silverlight prior to 4 never retained the returned NPObject.
+ ReturnsNonRetainedScriptableNPObject,
+
+ // Whether the plug-in wants parameter names to be lowercase.
+ // <rdar://problem/8440903>: AppleConnect has a bug where it does not
+ // understand the parameter names specified in the <object> element that
+ // embeds its plug-in.
+ WantsLowercaseParameterNames,
+
+ // Whether to append Version/3.2.1 to the user-agent passed to the plugin
+ // This is necessary to disable Silverlight's workaround for a Safari 2 leak
+ // which is enabled if it doesn't find Version/3 in the user-agent.
+ AppendVersion3UserAgent,
+
+ // Whether all thrown NSExceptions should be leaked.
+ // <rdar://problem/13003470> Adobe Flash has a bug where exceptions are released too early.
+ LeakAllThrownNSExceptions,
+
+ // X11 specific quirks:
+#elif PLATFORM(X11)
+ // Flash and npwrapper ask the browser about which GTK version does it use
+ // and refuse to load and work if it is not GTK 2 so we need to fake it in
+ // NPN_GetValue even when it is a lie.
+ RequiresGTKToolKit,
+
+ // Some version 10 releases of Flash run under nspluginwrapper will completely
+ // freeze when sending right click events to them in windowed mode.
+ IgnoreRightClickInWindowlessMode,
+
+ // Some ports don't support windowed plugins.
+ ForceFlashWindowlessMode,
+
+ // Flash crashes when NPP_GetValue is called for NPPVpluginCancelSrcStream in windowed mode.
+ DoNotCancelSrcStreamInWindowedMode,
+#endif
+
+ // This isn't really a quirk as much as the opposite of a quirk. By default, we don't send wheel events
+ // to plug-ins unless we know that they handle them correctly. Adobe Reader on Mac handles wheel events correctly.
+ WantsWheelEvents,
+
+ NumPluginQuirks
+ };
+
+ PluginQuirks()
+ : m_quirks(0)
+ {
+ COMPILE_ASSERT(sizeof(m_quirks) * 8 >= NumPluginQuirks, not_enough_room_for_quirks);
+ }
+
+ void add(PluginQuirk quirk)
+ {
+ ASSERT(quirk >= 0);
+ RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(quirk < NumPluginQuirks);
+
+ m_quirks |= (1 << quirk);
+ }
+
+ bool contains(PluginQuirk quirk) const
+ {
+ return m_quirks & (1 << quirk);
+ }
+
+private:
+ uint32_t m_quirks;
+};
+
+} // namespace WebKit
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/unix/PluginSearchPath.cpp webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/unix/PluginSearchPath.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/unix/PluginSearchPath.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/unix/PluginSearchPath.cpp 2022-08-26 14:18:14.989022377 -0500
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2015 Igalia S.L.
+ *
+ * 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 INC. 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 INC. 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 "config.h"
+#include "PluginSearchPath.h"
+
+#include <wtf/FileSystem.h>
+
+namespace WebKit {
+
+Vector<String> pluginsDirectories()
+{
+ Vector<String> result;
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ String mozillaPaths(getenv("MOZ_PLUGIN_PATH"));
+ if (!mozillaPaths.isEmpty()) {
+ Vector<String> paths = mozillaPaths.split(':');
+ result.appendVector(paths);
+ }
+
+ String mozillaHome(getenv("MOZILLA_HOME"));
+ if (!mozillaHome.isEmpty())
+ result.append(mozillaHome + "/plugins");
+
+ result.append("/usr/lib/browser/plugins");
+ result.append("/usr/local/lib/mozilla/plugins");
+ result.append("/usr/lib/firefox/plugins");
+ result.append("/usr/lib64/browser-plugins");
+ result.append("/usr/lib/browser-plugins");
+ result.append("/usr/lib/mozilla/plugins");
+ result.append("/usr/local/netscape/plugins");
+ result.append("/opt/mozilla/plugins");
+ result.append("/opt/mozilla/lib/plugins");
+ result.append("/opt/netscape/plugins");
+ result.append("/opt/netscape/communicator/plugins");
+ result.append("/usr/lib/netscape/plugins");
+ result.append("/usr/lib/netscape/plugins-libc5");
+ result.append("/usr/lib/netscape/plugins-libc6");
+ result.append("/usr/lib64/netscape/plugins");
+ result.append("/usr/lib64/mozilla/plugins");
+ result.append("/usr/lib/nsbrowser/plugins");
+ result.append("/usr/lib64/nsbrowser/plugins");
+#endif
+
+ return result;
+}
+
+} // namespace WebKit
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/unix/PluginSearchPath.h webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/unix/PluginSearchPath.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/Plugins/unix/PluginSearchPath.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/Shared/Plugins/unix/PluginSearchPath.h 2022-08-26 14:18:14.989022377 -0500
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2015 Igalia S.L.
+ *
+ * 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 INC. 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 INC. 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.
+ */
+
+#ifndef PluginSearchPath_h
+#define PluginSearchPath_h
+
+#include <wtf/Forward.h>
+#include <wtf/Vector.h>
+
+namespace WebKit {
+
+Vector<String> pluginsDirectories();
+
+} // namespace WebKit
+
+#endif // PluginSandboxProfile_h
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/WebPreferencesDefaultValues.cpp webkitgtk-2.36.7/Source/WebKit/Shared/WebPreferencesDefaultValues.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/WebPreferencesDefaultValues.cpp 2022-06-30 04:49:37.646179200 -0500
+++ webkitgtk-2.36.7/Source/WebKit/Shared/WebPreferencesDefaultValues.cpp 2022-08-26 14:18:14.989022377 -0500
@@ -321,7 +321,7 @@ bool defaultMediaSessionCoordinatorEnabl
static dispatch_once_t onceToken;
static bool enabled { false };
dispatch_once(&onceToken, ^{
- if (WebCore::isInWebProcess())
+ if (isInWebProcess())
enabled = WebProcess::singleton().parentProcessHasEntitlement("com.apple.developer.group-session.urlactivity");
else
enabled = WTF::processHasEntitlement("com.apple.developer.group-session.urlactivity");
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/WebProcessCreationParameters.cpp webkitgtk-2.36.7/Source/WebKit/Shared/WebProcessCreationParameters.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/WebProcessCreationParameters.cpp 2022-06-30 04:49:37.649512500 -0500
+++ webkitgtk-2.36.7/Source/WebKit/Shared/WebProcessCreationParameters.cpp 2022-08-26 14:18:14.989022377 -0500
@@ -80,6 +80,7 @@ void WebProcessCreationParameters::encod
encoder << shouldSuppressMemoryPressureHandler;
encoder << shouldUseFontSmoothing;
encoder << fontAllowList;
+ encoder << terminationTimeout;
encoder << overrideLanguages;
#if USE(GSTREAMER)
encoder << gstreamerOptions;
@@ -309,6 +310,8 @@ bool WebProcessCreationParameters::decod
return false;
if (!decoder.decode(parameters.fontAllowList))
return false;
+ if (!decoder.decode(parameters.terminationTimeout))
+ return false;
if (!decoder.decode(parameters.overrideLanguages))
return false;
#if USE(GSTREAMER)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/WebProcessCreationParameters.h webkitgtk-2.36.7/Source/WebKit/Shared/WebProcessCreationParameters.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/WebProcessCreationParameters.h 2022-06-30 04:49:37.649512500 -0500
+++ webkitgtk-2.36.7/Source/WebKit/Shared/WebProcessCreationParameters.h 2022-08-26 14:18:14.989022377 -0500
@@ -50,6 +50,10 @@
#include <WebCore/RenderThemeIOS.h>
#endif
+#if ENABLE(NETSCAPE_PLUGIN_API)
+#include <WebCore/PluginData.h>
+#endif
+
#if PLATFORM(GTK) || PLATFORM(WPE)
#include <wtf/MemoryPressureHandler.h>
#endif
@@ -143,6 +147,8 @@ struct WebProcessCreationParameters {
bool hasRichContentServices { false };
#endif
+ Seconds terminationTimeout;
+
TextCheckerState textCheckerState;
#if PLATFORM(COCOA)
@@ -170,6 +176,10 @@ struct WebProcessCreationParameters {
HashMap<String, bool> notificationPermissions;
#endif
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ HashMap<String, HashMap<String, HashMap<String, WebCore::PluginLoadClientPolicy>>> pluginLoadClientPolicies;
+#endif
+
#if PLATFORM(COCOA)
RetainPtr<CFDataRef> networkATSContext;
#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/WebsiteData/WebsiteData.cpp webkitgtk-2.36.7/Source/WebKit/Shared/WebsiteData/WebsiteData.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/WebsiteData/WebsiteData.cpp 2022-06-30 04:49:37.649512500 -0500
+++ webkitgtk-2.36.7/Source/WebKit/Shared/WebsiteData/WebsiteData.cpp 2022-08-26 14:18:14.989022377 -0500
@@ -65,6 +65,9 @@ void WebsiteData::encode(IPC::Encoder& e
{
encoder << entries;
encoder << hostNamesWithCookies;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ encoder << hostNamesWithPluginData;
+#endif
encoder << hostNamesWithHSTSCache;
#if ENABLE(INTELLIGENT_TRACKING_PREVENTION)
encoder << registrableDomainsWithResourceLoadStatistics;
@@ -77,6 +80,10 @@ bool WebsiteData::decode(IPC::Decoder& d
return false;
if (!decoder.decode(result.hostNamesWithCookies))
return false;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ if (!decoder.decode(result.hostNamesWithPluginData))
+ return false;
+#endif
if (!decoder.decode(result.hostNamesWithHSTSCache))
return false;
#if ENABLE(INTELLIGENT_TRACKING_PREVENTION)
@@ -111,6 +118,10 @@ WebsiteDataProcessType WebsiteData::owne
return WebsiteDataProcessType::Network;
case WebsiteDataType::SearchFieldRecentSearches:
return WebsiteDataProcessType::UI;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ case WebsiteDataType::PlugInData:
+ return WebsiteDataProcessType::UI;
+#endif
case WebsiteDataType::ResourceLoadStatistics:
return WebsiteDataProcessType::Network;
case WebsiteDataType::Credentials:
@@ -152,6 +163,9 @@ WebsiteData WebsiteData::isolatedCopy()
return WebsiteData {
crossThreadCopy(entries),
crossThreadCopy(hostNamesWithCookies),
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ crossThreadCopy(hostNamesWithPluginData),
+#endif
crossThreadCopy(hostNamesWithHSTSCache),
#if ENABLE(INTELLIGENT_TRACKING_PREVENTION)
crossThreadCopy(registrableDomainsWithResourceLoadStatistics),
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/WebsiteData/WebsiteData.h webkitgtk-2.36.7/Source/WebKit/Shared/WebsiteData/WebsiteData.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/WebsiteData/WebsiteData.h 2022-06-30 04:49:37.649512500 -0500
+++ webkitgtk-2.36.7/Source/WebKit/Shared/WebsiteData/WebsiteData.h 2022-08-26 14:18:14.989022377 -0500
@@ -59,6 +59,9 @@ struct WebsiteData {
Vector<Entry> entries;
HashSet<String> hostNamesWithCookies;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ HashSet<String> hostNamesWithPluginData;
+#endif
HashSet<String> hostNamesWithHSTSCache;
#if ENABLE(INTELLIGENT_TRACKING_PREVENTION)
HashSet<WebCore::RegistrableDomain> registrableDomainsWithResourceLoadStatistics;
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Shared/WebsiteData/WebsiteDataType.h webkitgtk-2.36.7/Source/WebKit/Shared/WebsiteData/WebsiteDataType.h
--- webkitgtk-2.36.7.orig/Source/WebKit/Shared/WebsiteData/WebsiteDataType.h 2022-06-30 04:49:37.649512500 -0500
+++ webkitgtk-2.36.7/Source/WebKit/Shared/WebsiteData/WebsiteDataType.h 2022-08-26 14:18:14.989022377 -0500
@@ -41,6 +41,9 @@ enum class WebsiteDataType : uint32_t {
MediaKeys = 1 << 8,
HSTSCache = 1 << 9,
SearchFieldRecentSearches = 1 << 10,
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ PlugInData = 1 << 11,
+#endif
ResourceLoadStatistics = 1 << 12,
Credentials = 1 << 13,
#if ENABLE(SERVICE_WORKER)
@@ -73,6 +76,9 @@ template<> struct EnumTraits<WebKit::Web
WebKit::WebsiteDataType::MediaKeys,
WebKit::WebsiteDataType::HSTSCache,
WebKit::WebsiteDataType::SearchFieldRecentSearches,
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ WebKit::WebsiteDataType::PlugInData,
+#endif
WebKit::WebsiteDataType::ResourceLoadStatistics,
WebKit::WebsiteDataType::Credentials,
#if ENABLE(SERVICE_WORKER)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/SourcesCocoa.txt webkitgtk-2.36.7/Source/WebKit/SourcesCocoa.txt
--- webkitgtk-2.36.7.orig/Source/WebKit/SourcesCocoa.txt 2022-06-30 04:49:37.669512500 -0500
+++ webkitgtk-2.36.7/Source/WebKit/SourcesCocoa.txt 2022-08-26 14:18:14.989022377 -0500
@@ -110,6 +110,11 @@ Platform/mac/StringUtilities.mm
Platform/unix/EnvironmentUtilities.cpp
+PluginProcess/EntryPoint/Cocoa/XPCService/PluginServiceEntryPoint.mm @no-unify
+
+PluginProcess/mac/PluginControllerProxyMac.mm @no-unify
+PluginProcess/mac/PluginProcessMac.mm @no-unify
+
Shared/API/c/cf/WKErrorCF.cpp
Shared/API/c/cf/WKStringCF.mm
Shared/API/c/cf/WKURLCF.mm
@@ -239,6 +244,11 @@ Shared/mac/MediaFormatReader/MediaSample
Shared/mac/MediaFormatReader/MediaSampleCursor.cpp
Shared/mac/MediaFormatReader/MediaTrackReader.cpp
+Shared/Plugins/mac/PluginSandboxProfile.mm
+
+Shared/Plugins/Netscape/mac/NetscapePluginModuleMac.mm
+Shared/Plugins/Netscape/mac/PluginInformationMac.mm
+
Shared/RemoteLayerTree/RemoteLayerBackingStore.mm
Shared/RemoteLayerTree/RemoteLayerBackingStoreCollection.mm
Shared/RemoteLayerTree/RemoteLayerWithRemoteRenderingBackingStoreCollection.mm
@@ -560,6 +570,10 @@ UIProcess/Media/cocoa/MediaUsageManagerC
UIProcess/Network/CustomProtocols/LegacyCustomProtocolManagerProxy.cpp
+UIProcess/Plugins/mac/PluginInfoStoreMac.mm
+UIProcess/Plugins/mac/PluginProcessManagerMac.mm
+UIProcess/Plugins/mac/PluginProcessProxyMac.mm
+
UIProcess/RemoteLayerTree/cocoa/RemoteLayerTreeLayers.mm
UIProcess/RemoteLayerTree/mac/ScrollerMac.mm
@@ -672,6 +686,9 @@ WebProcess/Model/ARKitInlinePreviewModel
WebProcess/Model/ios/ARKitInlinePreviewModelPlayerIOS.mm
WebProcess/Model/mac/ARKitInlinePreviewModelPlayerMac.mm
+WebProcess/Plugins/Netscape/mac/NetscapePluginMac.mm
+WebProcess/Plugins/Netscape/mac/PluginProxyMac.mm
+
WebProcess/Plugins/PDF/PDFPlugin.mm
WebProcess/Plugins/PDF/PDFPluginAnnotation.mm
WebProcess/Plugins/PDF/PDFPluginChoiceAnnotation.mm
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/SourcesGTK.txt webkitgtk-2.36.7/Source/WebKit/SourcesGTK.txt
--- webkitgtk-2.36.7.orig/Source/WebKit/SourcesGTK.txt 2022-06-30 04:49:37.669512500 -0500
+++ webkitgtk-2.36.7/Source/WebKit/SourcesGTK.txt 2022-08-26 14:18:14.989022377 -0500
@@ -61,6 +61,10 @@ Platform/glib/ModuleGlib.cpp
Platform/unix/LoggingUnix.cpp
Platform/unix/SharedMemoryUnix.cpp
+PluginProcess/unix/PluginControllerProxyUnix.cpp
+PluginProcess/unix/PluginProcessMainUnix.cpp
+PluginProcess/unix/PluginProcessUnix.cpp
+
Shared/API/c/cairo/WKImageCairo.cpp
Shared/API/glib/WebKitContextMenu.cpp @no-unify
@@ -78,6 +82,11 @@ Shared/CoordinatedGraphics/threadedcompo
Shared/CoordinatedGraphics/threadedcompositor/ThreadedDisplayRefreshMonitor.cpp
Shared/CoordinatedGraphics/threadedcompositor/ThreadedCompositor.cpp
+Shared/Plugins/Netscape/NetscapePluginModuleNone.cpp
+Shared/Plugins/Netscape/unix/NetscapePluginModuleUnix.cpp
+
+Shared/Plugins/unix/PluginSearchPath.cpp
+
Shared/cairo/ShareableBitmapCairo.cpp
Shared/glib/ArgumentCodersGLib.cpp
@@ -238,6 +247,11 @@ UIProcess/Launcher/glib/XDGDBusProxy.cpp
UIProcess/linux/MemoryPressureMonitor.cpp
+UIProcess/Plugins/gtk/PluginInfoCache.cpp
+
+UIProcess/Plugins/unix/PluginInfoStoreUnix.cpp
+UIProcess/Plugins/unix/PluginProcessProxyUnix.cpp
+
UIProcess/WebsiteData/soup/WebsiteDataStoreSoup.cpp
UIProcess/WebsiteData/unix/WebsiteDataStoreUnix.cpp
@@ -416,6 +430,11 @@ WebProcess/MediaCache/WebMediaKeyStorage
WebProcess/WebCoreSupport/WebValidationMessageClient.cpp
+WebProcess/Plugins/Netscape/unix/NetscapePluginUnix.cpp @no-unify
+WebProcess/Plugins/Netscape/unix/PluginProxyUnix.cpp @no-unify
+
+WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp @no-unify
+
WebProcess/WebCoreSupport/glib/WebEditorClientGLib.cpp
WebProcess/WebCoreSupport/gtk/WebContextMenuClientGtk.cpp
@@ -450,3 +469,5 @@ WebProcess/glib/WebProcessGLib.cpp
WebProcess/gtk/GtkSettingsManagerProxy.cpp
WebProcess/gtk/WaylandCompositorDisplay.cpp
WebProcess/gtk/WebProcessMainGtk.cpp
+
+WebProcess/Plugins/Netscape/NetscapePluginNone.cpp
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/Sources.txt webkitgtk-2.36.7/Source/WebKit/Sources.txt
--- webkitgtk-2.36.7.orig/Source/WebKit/Sources.txt 2022-06-30 04:49:37.669512500 -0500
+++ webkitgtk-2.36.7/Source/WebKit/Sources.txt 2022-08-26 14:18:14.989022377 -0500
@@ -218,6 +218,11 @@ Platform/IPC/SharedFileHandle.cpp
Platform/IPC/StreamServerConnection.cpp
Platform/IPC/StringReference.cpp
+PluginProcess/PluginControllerProxy.cpp @no-unify
+PluginProcess/PluginCreationParameters.cpp @no-unify
+PluginProcess/PluginProcess.cpp @no-unify
+PluginProcess/WebProcessConnection.cpp @no-unify
+
Shared/AccessibilityPreferences.cpp
Shared/ActivityAssertion.cpp
Shared/AuxiliaryProcess.cpp
@@ -243,7 +248,7 @@ Shared/RTCPacketOptions.cpp
Shared/RemoteWorkerInitializationData.cpp
Shared/ScrollingAccelerationCurve.cpp
Shared/SessionState.cpp
-Shared/ShareableBitmap.cpp
+Shared/ShareableBitmap.cpp @no-unify
Shared/ShareableResource.cpp
Shared/SharedStringHashStore.cpp
Shared/SharedStringHashTableReadOnly.cpp
@@ -397,6 +402,18 @@ Shared/WebGPU/WebGPUVertexAttribute.cpp
Shared/WebGPU/WebGPUVertexBufferLayout.cpp
Shared/WebGPU/WebGPUVertexState.cpp
+// TODO: These files should be unified once GTK's PluginProcess2 is removed.
+Shared/Plugins/NPIdentifierData.cpp @no-unify
+Shared/Plugins/NPObjectMessageReceiver.cpp @no-unify
+Shared/Plugins/NPObjectProxy.cpp @no-unify
+Shared/Plugins/NPRemoteObjectMap.cpp @no-unify
+Shared/Plugins/NPVariantData.cpp @no-unify
+Shared/Plugins/PluginProcessCreationParameters.cpp @no-unify
+
+// TODO: These files should be unified once GTK's PluginProcess2 is removed.
+Shared/Plugins/Netscape/NetscapePluginModule.cpp @no-unify
+Shared/Plugins/Netscape/PluginInformation.cpp @no-unify
+
Shared/WebsiteData/WebsiteData.cpp
Shared/XR/XRDeviceInfo.cpp
@@ -592,6 +609,10 @@ UIProcess/Notifications/WebNotificationM
UIProcess/Notifications/WebNotificationManagerProxy.cpp
UIProcess/Notifications/WebNotificationProvider.cpp
+UIProcess/Plugins/PluginInfoStore.cpp
+UIProcess/Plugins/PluginProcessManager.cpp
+UIProcess/Plugins/PluginProcessProxy.cpp
+
UIProcess/UserContent/WebScriptMessageHandler.cpp
UIProcess/UserContent/WebUserContentControllerProxy.cpp
@@ -787,9 +808,22 @@ WebProcess/Notifications/WebNotification
// TODO: These files should be unified once GTK's PluginProcess2 is removed.
WebProcess/Plugins/Plugin.cpp @no-unify
+WebProcess/Plugins/PluginProcessConnection.cpp @no-unify
+WebProcess/Plugins/PluginProcessConnectionManager.cpp @no-unify
+WebProcess/Plugins/PluginProxy.cpp @no-unify
WebProcess/Plugins/PluginView.cpp @no-unify
WebProcess/Plugins/WebPluginInfoProvider.cpp @no-unify
+// TODO: These files should be unified once GTK's PluginProcess2 is removed.
+WebProcess/Plugins/Netscape/JSNPMethod.cpp @no-unify
+WebProcess/Plugins/Netscape/JSNPObject.cpp @no-unify
+WebProcess/Plugins/Netscape/NPJSObject.cpp @no-unify
+WebProcess/Plugins/Netscape/NPRuntimeObjectMap.cpp @no-unify
+WebProcess/Plugins/Netscape/NPRuntimeUtilities.cpp @no-unify
+WebProcess/Plugins/Netscape/NetscapeBrowserFuncs.cpp @no-unify
+WebProcess/Plugins/Netscape/NetscapePlugin.cpp @no-unify
+WebProcess/Plugins/Netscape/NetscapePluginStream.cpp @no-unify
+
WebProcess/Speech/SpeechRecognitionRealtimeMediaSourceManager.cpp
WebProcess/Storage/RemoteWorkerFrameLoaderClient.cpp
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/SourcesWPE.txt webkitgtk-2.36.7/Source/WebKit/SourcesWPE.txt
--- webkitgtk-2.36.7.orig/Source/WebKit/SourcesWPE.txt 2022-06-30 04:49:37.669512500 -0500
+++ webkitgtk-2.36.7/Source/WebKit/SourcesWPE.txt 2022-08-26 14:18:14.989022377 -0500
@@ -61,6 +61,10 @@ Platform/glib/ModuleGlib.cpp
Platform/unix/LoggingUnix.cpp
Platform/unix/SharedMemoryUnix.cpp
+PluginProcess/unix/PluginControllerProxyUnix.cpp
+PluginProcess/unix/PluginProcessMainUnix.cpp
+PluginProcess/unix/PluginProcessUnix.cpp
+
Shared/API/c/cairo/WKImageCairo.cpp
Shared/API/glib/WebKitContextMenu.cpp @no-unify
@@ -78,6 +82,9 @@ Shared/CoordinatedGraphics/threadedcompo
Shared/CoordinatedGraphics/threadedcompositor/ThreadedCompositor.cpp
Shared/CoordinatedGraphics/threadedcompositor/ThreadedDisplayRefreshMonitor.cpp
+Shared/Plugins/Netscape/NetscapePluginModuleNone.cpp
+Shared/Plugins/Netscape/unix/NetscapePluginModuleUnix.cpp
+
Shared/cairo/ShareableBitmapCairo.cpp
Shared/glib/ArgumentCodersGLib.cpp
@@ -212,6 +219,9 @@ UIProcess/Launcher/glib/BubblewrapLaunch
UIProcess/Launcher/glib/FlatpakLauncher.cpp
UIProcess/Launcher/glib/XDGDBusProxy.cpp
+UIProcess/Plugins/unix/PluginInfoStoreUnix.cpp
+UIProcess/Plugins/unix/PluginProcessProxyUnix.cpp
+
UIProcess/WebsiteData/soup/WebsiteDataStoreSoup.cpp
UIProcess/WebsiteData/unix/WebsiteDataStoreUnix.cpp
@@ -249,6 +259,8 @@ WebProcess/InjectedBundle/glib/InjectedB
WebProcess/MediaCache/WebMediaKeyStorageManager.cpp
+WebProcess/Plugins/Netscape/NetscapePluginNone.cpp @no-unify
+
WebProcess/WebCoreSupport/glib/WebEditorClientGLib.cpp
WebProcess/WebCoreSupport/soup/WebFrameNetworkingContext.cpp
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/APILoaderClient.h webkitgtk-2.36.7/Source/WebKit/UIProcess/API/APILoaderClient.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/APILoaderClient.h 2022-06-30 04:49:37.676179200 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/APILoaderClient.h 2022-08-26 14:18:14.989022377 -0500
@@ -26,6 +26,7 @@
#pragma once
#include "APIData.h"
+#include "PluginModuleInfo.h"
#include "SameDocumentNavigationType.h"
#include <WebCore/FrameLoaderTypes.h>
#include <WebCore/LayoutMilestone.h>
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/APINavigationClient.h webkitgtk-2.36.7/Source/WebKit/UIProcess/API/APINavigationClient.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/APINavigationClient.h 2022-06-30 04:49:37.679512500 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/APINavigationClient.h 2022-08-26 14:18:14.989022377 -0500
@@ -30,6 +30,7 @@
#include "AuthenticationChallengeDisposition.h"
#include "AuthenticationChallengeProxy.h"
#include "AuthenticationDecisionListener.h"
+#include "PluginModuleInfo.h"
#include "ProcessTerminationReason.h"
#include "SameDocumentNavigationType.h"
#include "WebFramePolicyListenerProxy.h"
@@ -133,6 +134,15 @@ public:
}
virtual void contentRuleListNotification(WebKit::WebPageProxy&, WTF::URL&&, WebCore::ContentRuleListResults&&) { };
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ virtual bool didFailToInitializePlugIn(WebKit::WebPageProxy&, API::Dictionary&) { return false; }
+ virtual bool didBlockInsecurePluginVersion(WebKit::WebPageProxy&, API::Dictionary&) { return false; }
+ virtual void decidePolicyForPluginLoad(WebKit::WebPageProxy&, WebKit::PluginModuleLoadPolicy currentPluginLoadPolicy, Dictionary&, CompletionHandler<void(WebKit::PluginModuleLoadPolicy, const WTF::String&)>&& completionHandler)
+ {
+ completionHandler(currentPluginLoadPolicy, { });
+ }
+#endif
#if ENABLE(WEBGL)
virtual void webGLLoadPolicy(WebKit::WebPageProxy&, const WTF::URL&, CompletionHandler<void(WebCore::WebGLLoadPolicy)>&& completionHandler) const { completionHandler(WebCore::WebGLLoadPolicy::WebGLAllowCreation); }
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/APIUIClient.h webkitgtk-2.36.7/Source/WebKit/UIProcess/API/APIUIClient.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/APIUIClient.h 2022-06-30 04:49:37.682845800 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/APIUIClient.h 2022-08-26 14:18:14.989022377 -0500
@@ -108,6 +108,9 @@ public:
virtual void setStatusText(WebKit::WebPageProxy*, const WTF::String&) { }
virtual void mouseDidMoveOverElement(WebKit::WebPageProxy&, const WebKit::WebHitTestResultData&, OptionSet<WebKit::WebEvent::Modifier>, Object*) { }
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ virtual void unavailablePluginButtonClicked(WebKit::WebPageProxy&, WKPluginUnavailabilityReason, Dictionary&) { }
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
virtual void didNotHandleKeyEvent(WebKit::WebPageProxy*, const WebKit::NativeWebKeyboardEvent&) { }
virtual void didNotHandleWheelEvent(WebKit::WebPageProxy*, const WebKit::NativeWebWheelEvent&) { }
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/C/WKAPICast.h webkitgtk-2.36.7/Source/WebKit/UIProcess/API/C/WKAPICast.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/C/WKAPICast.h 2022-06-30 04:49:37.686179200 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/C/WKAPICast.h 2022-08-26 14:18:14.989022377 -0500
@@ -29,6 +29,7 @@
#include "CacheModel.h"
#include "InjectedBundleHitTestResultMediaType.h"
+#include "PluginModuleInfo.h"
#include "ProcessTerminationReason.h"
#include "WKBundleHitTestResult.h"
#include "WKContext.h"
@@ -419,6 +420,78 @@ inline WKStorageBlockingPolicy toAPI(Web
return kWKAllowAllStorage;
}
+inline WKPluginLoadPolicy toWKPluginLoadPolicy(PluginModuleLoadPolicy pluginModuleLoadPolicy)
+{
+ switch (pluginModuleLoadPolicy) {
+ case PluginModuleLoadNormally:
+ return kWKPluginLoadPolicyLoadNormally;
+ case PluginModuleLoadUnsandboxed:
+ return kWKPluginLoadPolicyLoadUnsandboxed;
+ case PluginModuleBlockedForSecurity:
+ return kWKPluginLoadPolicyBlocked;
+ case PluginModuleBlockedForCompatibility:
+ return kWKPluginLoadPolicyBlockedForCompatibility;
+ }
+
+ ASSERT_NOT_REACHED();
+ return kWKPluginLoadPolicyBlocked;
+}
+
+inline WKPluginLoadClientPolicy toWKPluginLoadClientPolicy(WebCore::PluginLoadClientPolicy PluginLoadClientPolicy)
+{
+ switch (PluginLoadClientPolicy) {
+ case WebCore::PluginLoadClientPolicy::Undefined:
+ return kWKPluginLoadClientPolicyUndefined;
+ case WebCore::PluginLoadClientPolicy::Block:
+ return kWKPluginLoadClientPolicyBlock;
+ case WebCore::PluginLoadClientPolicy::Ask:
+ return kWKPluginLoadClientPolicyAsk;
+ case WebCore::PluginLoadClientPolicy::Allow:
+ return kWKPluginLoadClientPolicyAllow;
+ case WebCore::PluginLoadClientPolicy::AllowAlways:
+ return kWKPluginLoadClientPolicyAllowAlways;
+ }
+
+ ASSERT_NOT_REACHED();
+ return kWKPluginLoadClientPolicyBlock;
+}
+
+inline PluginModuleLoadPolicy toPluginModuleLoadPolicy(WKPluginLoadPolicy pluginLoadPolicy)
+{
+ switch (pluginLoadPolicy) {
+ case kWKPluginLoadPolicyLoadNormally:
+ return PluginModuleLoadNormally;
+ case kWKPluginLoadPolicyBlocked:
+ return PluginModuleBlockedForSecurity;
+ case kWKPluginLoadPolicyBlockedForCompatibility:
+ return PluginModuleBlockedForCompatibility;
+ case kWKPluginLoadPolicyLoadUnsandboxed:
+ return PluginModuleLoadUnsandboxed;
+ }
+
+ ASSERT_NOT_REACHED();
+ return PluginModuleBlockedForSecurity;
+}
+
+inline WebCore::PluginLoadClientPolicy toPluginLoadClientPolicy(WKPluginLoadClientPolicy pluginLoadClientPolicy)
+{
+ switch (pluginLoadClientPolicy) {
+ case kWKPluginLoadClientPolicyUndefined:
+ return WebCore::PluginLoadClientPolicy::Undefined;
+ case kWKPluginLoadClientPolicyBlock:
+ return WebCore::PluginLoadClientPolicy::Block;
+ case kWKPluginLoadClientPolicyAsk:
+ return WebCore::PluginLoadClientPolicy::Ask;
+ case kWKPluginLoadClientPolicyAllow:
+ return WebCore::PluginLoadClientPolicy::Allow;
+ case kWKPluginLoadClientPolicyAllowAlways:
+ return WebCore::PluginLoadClientPolicy::AllowAlways;
+ }
+
+ ASSERT_NOT_REACHED();
+ return WebCore::PluginLoadClientPolicy::Block;
+}
+
inline WebCore::WebGLLoadPolicy toWebGLLoadPolicy(WKWebGLLoadPolicy webGLLoadPolicy)
{
switch (webGLLoadPolicy) {
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/C/WKContext.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/API/C/WKContext.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/C/WKContext.cpp 2022-06-30 04:49:37.686179200 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/C/WKContext.cpp 2022-08-26 14:18:14.989022377 -0500
@@ -334,13 +334,21 @@ void WKContextSetShouldUseFontSmoothing(
void WKContextSetAdditionalPluginsDirectory(WKContextRef contextRef, WKStringRef pluginsDirectory)
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ WebKit::toImpl(contextRef)->setAdditionalPluginsDirectory(WebKit::toImpl(pluginsDirectory)->string());
+#else
UNUSED_PARAM(contextRef);
UNUSED_PARAM(pluginsDirectory);
+#endif
}
void WKContextRefreshPlugIns(WKContextRef context)
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ WebKit::toImpl(context)->refreshPlugins();
+#else
UNUSED_PARAM(context);
+#endif
}
void WKContextRegisterURLSchemeAsEmptyDocument(WKContextRef contextRef, WKStringRef urlScheme)
@@ -553,10 +561,26 @@ void WKContextTerminateServiceWorkers(WK
void WKContextAddSupportedPlugin(WKContextRef contextRef, WKStringRef domainRef, WKStringRef nameRef, WKArrayRef mimeTypesRef, WKArrayRef extensionsRef)
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ HashSet<String> mimeTypes;
+ HashSet<String> extensions;
+
+ size_t count = WKArrayGetSize(mimeTypesRef);
+ for (size_t i = 0; i < count; ++i)
+ mimeTypes.add(WebKit::toWTFString(static_cast<WKStringRef>(WKArrayGetItemAtIndex(mimeTypesRef, i))));
+ count = WKArrayGetSize(extensionsRef);
+ for (size_t i = 0; i < count; ++i)
+ extensions.add(WebKit::toWTFString(static_cast<WKStringRef>(WKArrayGetItemAtIndex(extensionsRef, i))));
+
+ WebKit::toImpl(contextRef)->addSupportedPlugin(WebKit::toWTFString(domainRef), WebKit::toWTFString(nameRef), WTFMove(mimeTypes), WTFMove(extensions));
+#endif
}
void WKContextClearSupportedPlugins(WKContextRef contextRef)
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ WebKit::toImpl(contextRef)->clearSupportedPlugins();
+#endif
}
void WKContextClearCurrentModifierStateForTesting(WKContextRef contextRef)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/C/WKPage.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/API/C/WKPage.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/C/WKPage.cpp 2022-07-01 06:23:00.608417300 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/C/WKPage.cpp 2022-08-26 14:18:14.993022398 -0500
@@ -64,6 +64,7 @@
#include "NavigationActionData.h"
#include "NotificationPermissionRequest.h"
#include "PageClient.h"
+#include "PluginInformation.h"
#include "PrintInfo.h"
#include "QueryPermissionResultCallback.h"
#include "SpeechRecognitionPermissionRequest.h"
@@ -1787,6 +1788,37 @@ void WKPageSetPageUIClient(WKPageRef pag
m_client.mouseDidMoveOverElement(toAPI(&page), toAPI(apiHitTestResult.ptr()), toAPI(modifiers), toAPI(userData), m_client.base.clientInfo);
}
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ void unavailablePluginButtonClicked(WebPageProxy& page, WKPluginUnavailabilityReason pluginUnavailabilityReason, API::Dictionary& pluginInformation) final
+ {
+ if (pluginUnavailabilityReason == kWKPluginUnavailabilityReasonPluginMissing) {
+ if (m_client.missingPluginButtonClicked_deprecatedForUseWithV0)
+ m_client.missingPluginButtonClicked_deprecatedForUseWithV0(
+ toAPI(&page),
+ toAPI(pluginInformation.get<API::String>(pluginInformationMIMETypeKey())),
+ toAPI(pluginInformation.get<API::String>(pluginInformationPluginURLKey())),
+ toAPI(pluginInformation.get<API::String>(pluginInformationPluginspageAttributeURLKey())),
+ m_client.base.clientInfo);
+ }
+
+ if (m_client.unavailablePluginButtonClicked_deprecatedForUseWithV1)
+ m_client.unavailablePluginButtonClicked_deprecatedForUseWithV1(
+ toAPI(&page),
+ pluginUnavailabilityReason,
+ toAPI(pluginInformation.get<API::String>(pluginInformationMIMETypeKey())),
+ toAPI(pluginInformation.get<API::String>(pluginInformationPluginURLKey())),
+ toAPI(pluginInformation.get<API::String>(pluginInformationPluginspageAttributeURLKey())),
+ m_client.base.clientInfo);
+
+ if (m_client.unavailablePluginButtonClicked)
+ m_client.unavailablePluginButtonClicked(
+ toAPI(&page),
+ pluginUnavailabilityReason,
+ toAPI(&pluginInformation),
+ m_client.base.clientInfo);
+ }
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
void didNotHandleKeyEvent(WebPageProxy* page, const NativeWebKeyboardEvent& event) final
{
if (!m_client.didNotHandleKeyEvent)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/C/WKPreferences.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/API/C/WKPreferences.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/C/WKPreferences.cpp 2022-06-30 04:49:37.699512700 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/C/WKPreferences.cpp 2022-08-26 14:18:14.993022398 -0500
@@ -25,6 +25,7 @@
#include "config.h"
+#include "PluginProcessManager.h"
#include "WKPreferencesRef.h"
#include "WKPreferencesRefPrivate.h"
#include "WKAPICast.h"
@@ -605,13 +606,14 @@ bool WKPreferencesGetPageCacheEnabled(WK
return toImpl(preferencesRef)->usesBackForwardCache();
}
-void WKPreferencesSetPageCacheSupportsPlugins(WKPreferencesRef, bool)
+void WKPreferencesSetPageCacheSupportsPlugins(WKPreferencesRef preferencesRef, bool backForwardCacheSupportsPlugins)
{
+ toImpl(preferencesRef)->setBackForwardCacheSupportsPlugins(backForwardCacheSupportsPlugins);
}
-bool WKPreferencesGetPageCacheSupportsPlugins(WKPreferencesRef)
+bool WKPreferencesGetPageCacheSupportsPlugins(WKPreferencesRef preferencesRef)
{
- return false;
+ return toImpl(preferencesRef)->backForwardCacheSupportsPlugins();
}
void WKPreferencesSetPaginateDuringLayoutEnabled(WKPreferencesRef preferencesRef, bool enabled)
@@ -1003,31 +1005,34 @@ bool WKPreferencesGetDiagnosticLoggingEn
return toImpl(preferencesRef)->diagnosticLoggingEnabled();
}
-void WKPreferencesSetAsynchronousPluginInitializationEnabled(WKPreferencesRef, bool)
+void WKPreferencesSetAsynchronousPluginInitializationEnabled(WKPreferencesRef preferencesRef, bool enabled)
{
+ toImpl(preferencesRef)->setAsynchronousPluginInitializationEnabled(enabled);
}
-bool WKPreferencesGetAsynchronousPluginInitializationEnabled(WKPreferencesRef)
+bool WKPreferencesGetAsynchronousPluginInitializationEnabled(WKPreferencesRef preferencesRef)
{
- return false;
+ return toImpl(preferencesRef)->asynchronousPluginInitializationEnabled();
}
-void WKPreferencesSetAsynchronousPluginInitializationEnabledForAllPlugins(WKPreferencesRef, bool)
+void WKPreferencesSetAsynchronousPluginInitializationEnabledForAllPlugins(WKPreferencesRef preferencesRef, bool enabled)
{
+ toImpl(preferencesRef)->setAsynchronousPluginInitializationEnabledForAllPlugins(enabled);
}
-bool WKPreferencesGetAsynchronousPluginInitializationEnabledForAllPlugins(WKPreferencesRef)
+bool WKPreferencesGetAsynchronousPluginInitializationEnabledForAllPlugins(WKPreferencesRef preferencesRef)
{
- return false;
+ return toImpl(preferencesRef)->asynchronousPluginInitializationEnabledForAllPlugins();
}
-void WKPreferencesSetArtificialPluginInitializationDelayEnabled(WKPreferencesRef, bool)
+void WKPreferencesSetArtificialPluginInitializationDelayEnabled(WKPreferencesRef preferencesRef, bool enabled)
{
+ toImpl(preferencesRef)->setArtificialPluginInitializationDelayEnabled(enabled);
}
-bool WKPreferencesGetArtificialPluginInitializationDelayEnabled(WKPreferencesRef)
+bool WKPreferencesGetArtificialPluginInitializationDelayEnabled(WKPreferencesRef preferencesRef)
{
- return false;
+ return toImpl(preferencesRef)->artificialPluginInitializationDelayEnabled();
}
void WKPreferencesSetInteractiveFormValidationEnabled(WKPreferencesRef preferencesRef, bool enabled)
@@ -1059,13 +1064,17 @@ bool WKPreferencesGetPlugInSnapshottingE
return false;
}
-void WKPreferencesSetPluginSandboxProfilesEnabledForAllPlugins(WKPreferencesRef, bool)
+void WKPreferencesSetPluginSandboxProfilesEnabledForAllPlugins(WKPreferencesRef preferencesRef, bool enabled)
{
+#if ENABLE(NETSCAPE_PLUGIN_API) && PLATFORM(MAC)
+ WebKit::PluginProcessManager::singleton().setExperimentalPlugInSandboxProfilesEnabled(enabled);
+#endif
+ toImpl(preferencesRef)->setExperimentalPlugInSandboxProfilesEnabled(enabled);
}
-bool WKPreferencesGetPluginSandboxProfilesEnabledForAllPlugins(WKPreferencesRef)
+bool WKPreferencesGetPluginSandboxProfilesEnabledForAllPlugins(WKPreferencesRef preferencesRef)
{
- return false;
+ return toImpl(preferencesRef)->experimentalPlugInSandboxProfilesEnabled();
}
void WKPreferencesSetSnapshotAllPlugIns(WKPreferencesRef, bool)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/glib/WebKitMimeInfo.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/API/glib/WebKitMimeInfo.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/glib/WebKitMimeInfo.cpp 2022-06-30 04:49:37.772846000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/glib/WebKitMimeInfo.cpp 2022-08-26 14:18:14.993022398 -0500
@@ -20,12 +20,32 @@
#include "config.h"
#include "WebKitMimeInfo.h"
+#include "WebKitMimeInfoPrivate.h"
+#include <wtf/glib/GRefPtr.h>
+#include <wtf/text/CString.h>
+
struct _WebKitMimeInfo {
+ _WebKitMimeInfo(const WebCore::MimeClassInfo& mimeInfo)
+ : mimeInfo(mimeInfo)
+ {
+ }
+
+ WebCore::MimeClassInfo mimeInfo;
+ CString mimeType;
+ CString description;
+ GRefPtr<GPtrArray> extensions;
+
+ int referenceCount { 0 };
};
-ALLOW_DEPRECATED_DECLARATIONS_BEGIN
G_DEFINE_BOXED_TYPE(WebKitMimeInfo, webkit_mime_info, webkit_mime_info_ref, webkit_mime_info_unref)
-ALLOW_DEPRECATED_DECLARATIONS_END
+
+WebKitMimeInfo* webkitMimeInfoCreate(const WebCore::MimeClassInfo& mimeInfo)
+{
+ WebKitMimeInfo* info = static_cast<WebKitMimeInfo*>(fastMalloc(sizeof(WebKitMimeInfo)));
+ new (info) WebKitMimeInfo(mimeInfo);
+ return info;
+}
/**
* webkit_mime_info_ref:
@@ -35,12 +55,11 @@ ALLOW_DEPRECATED_DECLARATIONS_END
* function is MT-safe and may be called from any thread.
*
* Returns: The passed in #WebKitMimeInfo
- *
- * Deprecated: 2.32
*/
-WebKitMimeInfo* webkit_mime_info_ref(WebKitMimeInfo*)
+WebKitMimeInfo* webkit_mime_info_ref(WebKitMimeInfo* info)
{
- return nullptr;
+ g_atomic_int_inc(&info->referenceCount);
+ return info;
}
/**
@@ -51,11 +70,13 @@ WebKitMimeInfo* webkit_mime_info_ref(Web
* reference count drops to 0, all memory allocated by the #WebKitMimeInfo is
* released. This function is MT-safe and may be called from any
* thread.
- *
- * Deprecated: 2.32
*/
-void webkit_mime_info_unref(WebKitMimeInfo*)
+void webkit_mime_info_unref(WebKitMimeInfo* info)
{
+ if (g_atomic_int_dec_and_test(&info->referenceCount)) {
+ info->~WebKitMimeInfo();
+ fastFree(info);
+ }
}
/**
@@ -63,12 +84,17 @@ void webkit_mime_info_unref(WebKitMimeIn
* @info: a #WebKitMimeInfo
*
* Returns: the MIME type of @info
- *
- * Deprecated: 2.32
*/
-const char* webkit_mime_info_get_mime_type(WebKitMimeInfo*)
+const char* webkit_mime_info_get_mime_type(WebKitMimeInfo* info)
{
- return nullptr;
+ if (!info->mimeType.isNull())
+ return info->mimeType.data();
+
+ if (info->mimeInfo.type.isEmpty())
+ return 0;
+
+ info->mimeType = info->mimeInfo.type.utf8();
+ return info->mimeType.data();
}
/**
@@ -76,12 +102,17 @@ const char* webkit_mime_info_get_mime_ty
* @info: a #WebKitMimeInfo
*
* Returns: the description of the MIME type of @info
- *
- * Deprecated: 2.32
*/
-const char* webkit_mime_info_get_description(WebKitMimeInfo*)
+const char* webkit_mime_info_get_description(WebKitMimeInfo* info)
{
- return nullptr;
+ if (!info->description.isNull())
+ return info->description.data();
+
+ if (info->mimeInfo.desc.isEmpty())
+ return 0;
+
+ info->description = info->mimeInfo.desc.utf8();
+ return info->description.data();
}
/**
@@ -93,10 +124,22 @@ const char* webkit_mime_info_get_descrip
*
* Returns: (array zero-terminated=1) (transfer none): a
* %NULL-terminated array of strings
- *
- * Deprecated: 2.32
*/
-const char* const* webkit_mime_info_get_extensions(WebKitMimeInfo*)
+const char* const* webkit_mime_info_get_extensions(WebKitMimeInfo* info)
{
- return nullptr;
+ if (info->extensions)
+ return reinterpret_cast<gchar**>(info->extensions->pdata);
+
+ if (info->mimeInfo.extensions.isEmpty())
+ return 0;
+
+ info->extensions = adoptGRef(g_ptr_array_new_with_free_func(g_free));
+ for (size_t i = 0; i < info->mimeInfo.extensions.size(); ++i) {
+ if (info->mimeInfo.extensions[i].isEmpty())
+ continue;
+ g_ptr_array_add(info->extensions.get(), g_strdup(info->mimeInfo.extensions[i].utf8().data()));
+ }
+ g_ptr_array_add(info->extensions.get(), 0);
+
+ return reinterpret_cast<gchar**>(info->extensions->pdata);
}
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/glib/WebKitMimeInfoPrivate.h webkitgtk-2.36.7/Source/WebKit/UIProcess/API/glib/WebKitMimeInfoPrivate.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/glib/WebKitMimeInfoPrivate.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/glib/WebKitMimeInfoPrivate.h 2022-08-26 14:18:14.993022398 -0500
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include "WebKitMimeInfo.h"
+#include <WebCore/PluginData.h>
+
+WebKitMimeInfo* webkitMimeInfoCreate(const WebCore::MimeClassInfo&);
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/glib/WebKitPlugin.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/API/glib/WebKitPlugin.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/glib/WebKitPlugin.cpp 2022-06-30 04:49:37.776179300 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/glib/WebKitPlugin.cpp 2022-08-26 14:18:14.993022398 -0500
@@ -20,7 +20,12 @@
#include "config.h"
#include "WebKitPlugin.h"
+#include "WebKitMimeInfoPrivate.h"
+#include "WebKitPluginPrivate.h"
#include <wtf/glib/WTFGType.h>
+#include <wtf/text/CString.h>
+
+using namespace WebKit;
/**
* SECTION: WebKitPlugin
@@ -34,31 +39,52 @@
* be obtained from the #WebKitWebContext, with
* webkit_web_context_get_plugins().
*
- * Deprecated: 2.32
*/
struct _WebKitPluginPrivate {
+ ~_WebKitPluginPrivate()
+ {
+ g_list_free_full(mimeInfoList, reinterpret_cast<GDestroyNotify>(webkit_mime_info_unref));
+ }
+
+ PluginModuleInfo pluginInfo;
+ CString name;
+ CString description;
+ CString path;
+ GList* mimeInfoList;
};
-ALLOW_DEPRECATED_DECLARATIONS_BEGIN
WEBKIT_DEFINE_TYPE(WebKitPlugin, webkit_plugin, G_TYPE_OBJECT)
-ALLOW_DEPRECATED_DECLARATIONS_END
static void webkit_plugin_class_init(WebKitPluginClass*)
{
}
+WebKitPlugin* webkitPluginCreate(const PluginModuleInfo& pluginInfo)
+{
+ WebKitPlugin* plugin = WEBKIT_PLUGIN(g_object_new(WEBKIT_TYPE_PLUGIN, NULL));
+ plugin->priv->pluginInfo = pluginInfo;
+ return plugin;
+}
+
/**
* webkit_plugin_get_name:
* @plugin: a #WebKitPlugin
*
* Returns: the name of the plugin.
- *
- * Deprecated: 2.32
*/
-const char* webkit_plugin_get_name(WebKitPlugin*)
+const char* webkit_plugin_get_name(WebKitPlugin* plugin)
{
- return nullptr;
+ g_return_val_if_fail(WEBKIT_IS_PLUGIN(plugin), 0);
+
+ if (!plugin->priv->name.isNull())
+ return plugin->priv->name.data();
+
+ if (plugin->priv->pluginInfo.info.name.isEmpty())
+ return 0;
+
+ plugin->priv->name = plugin->priv->pluginInfo.info.name.utf8();
+ return plugin->priv->name.data();
}
/**
@@ -66,12 +92,19 @@ const char* webkit_plugin_get_name(WebKi
* @plugin: a #WebKitPlugin
*
* Returns: the description of the plugin.
- *
- * Deprecated: 2.32
*/
-const char* webkit_plugin_get_description(WebKitPlugin*)
+const char* webkit_plugin_get_description(WebKitPlugin* plugin)
{
- return nullptr;
+ g_return_val_if_fail(WEBKIT_IS_PLUGIN(plugin), 0);
+
+ if (!plugin->priv->description.isNull())
+ return plugin->priv->description.data();
+
+ if (plugin->priv->pluginInfo.info.desc.isEmpty())
+ return 0;
+
+ plugin->priv->description = plugin->priv->pluginInfo.info.desc.utf8();
+ return plugin->priv->description.data();
}
/**
@@ -79,12 +112,19 @@ const char* webkit_plugin_get_descriptio
* @plugin: a #WebKitPlugin
*
* Returns: the absolute path where the plugin is installed.
- *
- * Deprecated: 2.32
*/
-const char* webkit_plugin_get_path(WebKitPlugin*)
+const char* webkit_plugin_get_path(WebKitPlugin* plugin)
{
- return nullptr;
+ g_return_val_if_fail(WEBKIT_IS_PLUGIN(plugin), 0);
+
+ if (!plugin->priv->path.isNull())
+ return plugin->priv->path.data();
+
+ if (plugin->priv->pluginInfo.path.isEmpty())
+ return 0;
+
+ plugin->priv->path = plugin->priv->pluginInfo.path.utf8();
+ return plugin->priv->path.data();
}
/**
@@ -95,10 +135,18 @@ const char* webkit_plugin_get_path(WebKi
* as a list of #WebKitMimeInfo.
*
* Returns: (element-type WebKitMimeInfo) (transfer none): a #GList of #WebKitMimeInfo.
- *
- * Deprecated: 2.32
*/
-GList* webkit_plugin_get_mime_info_list(WebKitPlugin*)
+GList* webkit_plugin_get_mime_info_list(WebKitPlugin* plugin)
{
- return nullptr;
+ g_return_val_if_fail(WEBKIT_IS_PLUGIN(plugin), 0);
+
+ if (plugin->priv->mimeInfoList)
+ return plugin->priv->mimeInfoList;
+
+ if (plugin->priv->pluginInfo.info.mimes.isEmpty())
+ return 0;
+
+ for (size_t i = 0; i < plugin->priv->pluginInfo.info.mimes.size(); ++i)
+ plugin->priv->mimeInfoList = g_list_prepend(plugin->priv->mimeInfoList, webkitMimeInfoCreate(plugin->priv->pluginInfo.info.mimes[i]));
+ return plugin->priv->mimeInfoList;
}
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/glib/WebKitPluginPrivate.h webkitgtk-2.36.7/Source/WebKit/UIProcess/API/glib/WebKitPluginPrivate.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/glib/WebKitPluginPrivate.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/glib/WebKitPluginPrivate.h 2022-08-26 14:18:14.993022398 -0500
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include "PluginModuleInfo.h"
+#include "WebKitPlugin.h"
+
+WebKitPlugin* webkitPluginCreate(const WebKit::PluginModuleInfo&);
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/glib/WebKitSettings.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/API/glib/WebKitSettings.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/glib/WebKitSettings.cpp 2022-06-30 04:49:37.779512600 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/glib/WebKitSettings.cpp 2022-08-26 14:18:14.993022398 -0500
@@ -235,6 +235,7 @@ static void webKitSettingsSetProperty(GO
webkit_settings_set_enable_frame_flattening(settings, g_value_get_boolean(value));
break;
case PROP_ENABLE_PLUGINS:
+ webkit_settings_set_enable_plugins(settings, g_value_get_boolean(value));
break;
case PROP_ENABLE_JAVA:
webkit_settings_set_enable_java(settings, g_value_get_boolean(value));
@@ -437,7 +438,7 @@ static void webKitSettingsGetProperty(GO
g_value_set_boolean(value, webkit_settings_get_enable_frame_flattening(settings));
break;
case PROP_ENABLE_PLUGINS:
- g_value_set_boolean(value, FALSE);
+ g_value_set_boolean(value, webkit_settings_get_enable_plugins(settings));
break;
case PROP_ENABLE_JAVA:
g_value_set_boolean(value, webkit_settings_get_enable_java(settings));
@@ -746,7 +747,7 @@ static void webkit_settings_class_init(W
"enable-plugins",
_("Enable plugins"),
_("Enable embedded plugin objects."),
- FALSE,
+ TRUE,
readWriteConstructParamFlags);
/**
@@ -1886,16 +1887,12 @@ void webkit_settings_set_enable_frame_fl
* Get the #WebKitSettings:enable-plugins property.
*
* Returns: %TRUE If plugins are enabled or %FALSE otherwise.
- *
- * Deprecated: 2.32
*/
gboolean webkit_settings_get_enable_plugins(WebKitSettings* settings)
{
g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
- g_warning("webkit_settings_get_enable_plugins is deprecated and always returns FALSE. Plugins are no longer supported.");
-
- return FALSE;
+ return settings->priv->preferences->pluginsEnabled();
}
/**
@@ -1904,15 +1901,18 @@ gboolean webkit_settings_get_enable_plug
* @enabled: Value to be set
*
* Set the #WebKitSettings:enable-plugins property.
- *
- * Deprecated: 2.32
*/
void webkit_settings_set_enable_plugins(WebKitSettings* settings, gboolean enabled)
{
g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
- if (enabled)
- g_warning("webkit_settings_set_enable_plugins is deprecated and does nothing. Plugins are no longer supported.");
+ WebKitSettingsPrivate* priv = settings->priv;
+ bool currentValue = priv->preferences->pluginsEnabled();
+ if (currentValue == enabled)
+ return;
+
+ priv->preferences->setPluginsEnabled(enabled);
+ g_object_notify(G_OBJECT(settings), "enable-plugins");
}
/**
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp 2022-08-08 16:28:31.851981200 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp 2022-08-26 14:18:14.993022398 -0500
@@ -42,6 +42,7 @@
#include "WebKitMemoryPressureSettings.h"
#include "WebKitMemoryPressureSettingsPrivate.h"
#include "WebKitNotificationProvider.h"
+#include "WebKitPluginPrivate.h"
#include "WebKitPrivate.h"
#include "WebKitProtocolHandler.h"
#include "WebKitSecurityManagerPrivate.h"
@@ -1147,12 +1148,31 @@ WebKitSecurityManager* webkit_web_contex
* @directory: the directory to add
*
* Set an additional directory where WebKit will look for plugins.
- *
- * Deprecated: 2.32
*/
-void webkit_web_context_set_additional_plugins_directory(WebKitWebContext*, const char*)
+void webkit_web_context_set_additional_plugins_directory(WebKitWebContext* context, const char* directory)
+{
+ g_return_if_fail(WEBKIT_IS_WEB_CONTEXT(context));
+ g_return_if_fail(directory);
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ context->priv->processPool->setAdditionalPluginsDirectory(FileSystem::stringFromFileSystemRepresentation(directory));
+#endif
+}
+
+static void destroyPluginList(GList* plugins)
+{
+ g_list_free_full(plugins, g_object_unref);
+}
+
+static void webkitWebContextGetPluginThread(GTask* task, gpointer object, gpointer /* taskData */, GCancellable*)
{
- g_warning("webkit_web_context_set_additional_plugins_directory is deprecated and does nothing. Netscape plugins are no longer supported.");
+ GList* returnValue = 0;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ Vector<PluginModuleInfo> plugins = WEBKIT_WEB_CONTEXT(object)->priv->processPool->pluginInfoStore().plugins();
+ for (size_t i = 0; i < plugins.size(); ++i)
+ returnValue = g_list_prepend(returnValue, webkitPluginCreate(plugins[i]));
+#endif
+ g_task_return_pointer(task, returnValue, reinterpret_cast<GDestroyNotify>(destroyPluginList));
}
/**
@@ -1166,17 +1186,13 @@ void webkit_web_context_set_additional_p
*
* When the operation is finished, @callback will be called. You can then call
* webkit_web_context_get_plugins_finish() to get the result of the operation.
- *
- * Deprecated: 2.32
*/
void webkit_web_context_get_plugins(WebKitWebContext* context, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
{
g_return_if_fail(WEBKIT_IS_WEB_CONTEXT(context));
- g_warning("webkit_web_context_get_plugins is deprecated and always returns an empty list. Netscape plugins are no longer supported.");
-
GRefPtr<GTask> task = adoptGRef(g_task_new(context, cancellable, callback, userData));
- g_task_return_pointer(task.get(), nullptr, nullptr);
+ g_task_run_in_thread(task.get(), webkitWebContextGetPluginThread);
}
/**
@@ -1189,13 +1205,11 @@ void webkit_web_context_get_plugins(WebK
*
* Returns: (element-type WebKitPlugin) (transfer full): a #GList of #WebKitPlugin. You must free the #GList with
* g_list_free() and unref the #WebKitPlugin<!-- -->s with g_object_unref() when you're done with them.
- *
- * Deprecated: 2.32
*/
GList* webkit_web_context_get_plugins_finish(WebKitWebContext* context, GAsyncResult* result, GError** error)
{
- g_return_val_if_fail(WEBKIT_IS_WEB_CONTEXT(context), nullptr);
- g_return_val_if_fail(g_task_is_valid(result, context), nullptr);
+ g_return_val_if_fail(WEBKIT_IS_WEB_CONTEXT(context), 0);
+ g_return_val_if_fail(g_task_is_valid(result, context), 0);
return static_cast<GList*>(g_task_propagate_pointer(G_TASK(result), error));
}
@@ -1226,7 +1240,9 @@ GList* webkit_web_context_get_plugins_fi
* const gchar *path;
*
* path = webkit_uri_scheme_request_get_path (request);
- * if (!g_strcmp0 (path, "memory")) {
+ * if (!g_strcmp0 (path, "plugins")) {
+ * /<!-- -->* Create a GInputStream with the contents of plugins about page, and set its length to stream_length *<!-- -->/
+ * } else if (!g_strcmp0 (path, "memory")) {
* /<!-- -->* Create a GInputStream with the contents of memory about page, and set its length to stream_length *<!-- -->/
* } else if (!g_strcmp0 (path, "applications")) {
* /<!-- -->* Create a GInputStream with the contents of applications about page, and set its length to stream_length *<!-- -->/
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/glib/WebKitWebsiteData.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/API/glib/WebKitWebsiteData.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/glib/WebKitWebsiteData.cpp 2022-06-30 04:49:37.782846000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/glib/WebKitWebsiteData.cpp 2022-08-26 14:18:14.993022398 -0500
@@ -74,6 +74,9 @@ static bool recordContainsSupportedDataT
WebsiteDataType::WebSQLDatabases,
WebsiteDataType::IndexedDBDatabases,
WebsiteDataType::HSTSCache,
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ WebsiteDataType::PlugInData,
+#endif
WebsiteDataType::Cookies,
WebsiteDataType::DeviceIdHashSalt,
WebsiteDataType::ResourceLoadStatistics,
@@ -103,6 +106,10 @@ static WebKitWebsiteDataTypes toWebKitWe
returnValue |= WEBKIT_WEBSITE_DATA_INDEXEDDB_DATABASES;
if (types.contains(WebsiteDataType::HSTSCache))
returnValue |= WEBKIT_WEBSITE_DATA_HSTS_CACHE;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ if (types.contains(WebsiteDataType::PlugInData))
+ returnValue |= WEBKIT_WEBSITE_DATA_PLUGIN_DATA;
+#endif
if (types.contains(WebsiteDataType::Cookies))
returnValue |= WEBKIT_WEBSITE_DATA_COOKIES;
if (types.contains(WebsiteDataType::DeviceIdHashSalt))
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp 2022-06-30 04:49:37.782846000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp 2022-08-26 14:18:14.993022398 -0500
@@ -993,6 +993,10 @@ static OptionSet<WebsiteDataType> toWebs
returnValue.add(WebsiteDataType::IndexedDBDatabases);
if (types & WEBKIT_WEBSITE_DATA_HSTS_CACHE)
returnValue.add(WebsiteDataType::HSTSCache);
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ if (types & WEBKIT_WEBSITE_DATA_PLUGIN_DATA)
+ returnValue.add(WebsiteDataType::PlugInData);
+#endif
if (types & WEBKIT_WEBSITE_DATA_COOKIES)
returnValue.add(WebsiteDataType::Cookies);
if (types & WEBKIT_WEBSITE_DATA_DEVICE_ID_HASH_SALT)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp 2022-08-08 06:13:37.346126000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp 2022-08-26 14:18:14.997022419 -0500
@@ -501,7 +501,8 @@ static gboolean webkitWebViewLoadFail(We
{
if (g_error_matches(error, WEBKIT_NETWORK_ERROR, WEBKIT_NETWORK_ERROR_CANCELLED)
|| g_error_matches(error, WEBKIT_PLUGIN_ERROR, WEBKIT_PLUGIN_ERROR_WILL_HANDLE_LOAD)
- || g_error_matches(error, WEBKIT_POLICY_ERROR, WEBKIT_POLICY_ERROR_FRAME_LOAD_INTERRUPTED_BY_POLICY_CHANGE))
+ || g_error_matches(error, WEBKIT_POLICY_ERROR, WEBKIT_POLICY_ERROR_FRAME_LOAD_INTERRUPTED_BY_POLICY_CHANGE)
+ || g_error_matches(error, WEBKIT_PLUGIN_ERROR, WEBKIT_PLUGIN_ERROR_WILL_HANDLE_LOAD))
return FALSE;
GUniquePtr<char> htmlString(g_strdup_printf("<html><body>%s</body></html>", error->message));
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/gtk/WebKitError.h webkitgtk-2.36.7/Source/WebKit/UIProcess/API/gtk/WebKitError.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/gtk/WebKitError.h 2022-06-30 04:49:37.789512600 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/gtk/WebKitError.h 2022-08-26 14:18:14.997022419 -0500
@@ -41,6 +41,12 @@ G_BEGIN_DECLS
/**
* WebKitNetworkError:
* @WEBKIT_NETWORK_ERROR_FAILED: Generic load failure
+ * @WEBKIT_PLUGIN_ERROR_FAILED: Generic plugin load failure
+ * @WEBKIT_PLUGIN_ERROR_CANNOT_FIND_PLUGIN: Load failure due to missing plugin
+ * @WEBKIT_PLUGIN_ERROR_CANNOT_LOAD_PLUGIN: Load failure due to inability to load plugin
+ * @WEBKIT_PLUGIN_ERROR_JAVA_UNAVAILABLE: Load failure due to missing Java support that is required to load plugin
+ * @WEBKIT_PLUGIN_ERROR_CONNECTION_CANCELLED: Load failure due to connection cancellation
+ * @WEBKIT_PLUGIN_ERROR_WILL_HANDLE_LOAD: Load failure since plugin handles the load
* @WEBKIT_NETWORK_ERROR_TRANSPORT: Load failure due to transport error
* @WEBKIT_NETWORK_ERROR_UNKNOWN_PROTOCOL: Load failure due to unknown protocol
* @WEBKIT_NETWORK_ERROR_CANCELLED: Load failure due to cancellation
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/gtk/WebKitMimeInfo.h webkitgtk-2.36.7/Source/WebKit/UIProcess/API/gtk/WebKitMimeInfo.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/gtk/WebKitMimeInfo.h 2022-06-30 04:49:37.792846000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/gtk/WebKitMimeInfo.h 2022-08-26 14:18:14.997022419 -0500
@@ -34,22 +34,22 @@ G_BEGIN_DECLS
typedef struct _WebKitMimeInfo WebKitMimeInfo;
-WEBKIT_DEPRECATED GType
+WEBKIT_API GType
webkit_mime_info_get_type (void);
-WEBKIT_DEPRECATED WebKitMimeInfo *
+WEBKIT_API WebKitMimeInfo *
webkit_mime_info_ref (WebKitMimeInfo *info);
-WEBKIT_DEPRECATED void
+WEBKIT_API void
webkit_mime_info_unref (WebKitMimeInfo *info);
-WEBKIT_DEPRECATED const gchar *
+WEBKIT_API const gchar *
webkit_mime_info_get_mime_type (WebKitMimeInfo *info);
-WEBKIT_DEPRECATED const gchar *
+WEBKIT_API const gchar *
webkit_mime_info_get_description (WebKitMimeInfo *info);
-WEBKIT_DEPRECATED const gchar * const *
+WEBKIT_API const gchar * const *
webkit_mime_info_get_extensions (WebKitMimeInfo *info);
G_END_DECLS
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/gtk/WebKitPlugin.h webkitgtk-2.36.7/Source/WebKit/UIProcess/API/gtk/WebKitPlugin.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/gtk/WebKitPlugin.h 2022-06-30 04:49:37.792846000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/gtk/WebKitPlugin.h 2022-08-26 14:18:14.997022419 -0500
@@ -55,19 +55,19 @@ struct _WebKitPluginClass {
void (*_webkit_reserved3) (void);
};
-WEBKIT_DEPRECATED GType
+WEBKIT_API GType
webkit_plugin_get_type (void);
-WEBKIT_DEPRECATED const gchar *
+WEBKIT_API const gchar *
webkit_plugin_get_name (WebKitPlugin *plugin);
-WEBKIT_DEPRECATED const gchar *
+WEBKIT_API const gchar *
webkit_plugin_get_description (WebKitPlugin *plugin);
-WEBKIT_DEPRECATED const gchar *
+WEBKIT_API const gchar *
webkit_plugin_get_path (WebKitPlugin *plugin);
-WEBKIT_DEPRECATED GList *
+WEBKIT_API GList *
webkit_plugin_get_mime_info_list (WebKitPlugin *plugin);
G_END_DECLS
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/gtk/WebKitSettings.h webkitgtk-2.36.7/Source/WebKit/UIProcess/API/gtk/WebKitSettings.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/gtk/WebKitSettings.h 2022-06-30 04:49:37.792846000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/gtk/WebKitSettings.h 2022-08-26 14:18:14.997022419 -0500
@@ -147,10 +147,10 @@ WEBKIT_API void
webkit_settings_set_enable_frame_flattening (WebKitSettings *settings,
gboolean enabled);
-WEBKIT_DEPRECATED gboolean
+WEBKIT_API gboolean
webkit_settings_get_enable_plugins (WebKitSettings *settings);
-WEBKIT_DEPRECATED void
+WEBKIT_API void
webkit_settings_set_enable_plugins (WebKitSettings *settings,
gboolean enabled);
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/gtk/WebKitWebContext.h webkitgtk-2.36.7/Source/WebKit/UIProcess/API/gtk/WebKitWebContext.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/gtk/WebKitWebContext.h 2022-06-30 04:49:37.796179300 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/gtk/WebKitWebContext.h 2022-08-26 14:18:14.997022419 -0500
@@ -197,17 +197,17 @@ webkit_web_context_get_favicon_database_
WEBKIT_API WebKitSecurityManager *
webkit_web_context_get_security_manager (WebKitWebContext *context);
-WEBKIT_DEPRECATED void
+WEBKIT_API void
webkit_web_context_set_additional_plugins_directory (WebKitWebContext *context,
const gchar *directory);
-WEBKIT_DEPRECATED void
+WEBKIT_API void
webkit_web_context_get_plugins (WebKitWebContext *context,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data);
-WEBKIT_DEPRECATED GList *
+WEBKIT_API GList *
webkit_web_context_get_plugins_finish (WebKitWebContext *context,
GAsyncResult *result,
GError **error);
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/gtk/WebKitWebsiteData.h webkitgtk-2.36.7/Source/WebKit/UIProcess/API/gtk/WebKitWebsiteData.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/API/gtk/WebKitWebsiteData.h 2022-06-30 04:49:37.796179300 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/API/gtk/WebKitWebsiteData.h 2022-08-26 14:18:14.997022419 -0500
@@ -42,7 +42,7 @@ typedef struct _WebKitWebsiteData WebKit
* @WEBKIT_WEBSITE_DATA_LOCAL_STORAGE: Local storage data.
* @WEBKIT_WEBSITE_DATA_WEBSQL_DATABASES: WebSQL databases. Deprecated 2.24
* @WEBKIT_WEBSITE_DATA_INDEXEDDB_DATABASES: IndexedDB databases.
- * @WEBKIT_WEBSITE_DATA_PLUGIN_DATA: Plugins data. Deprecated 2.32
+ * @WEBKIT_WEBSITE_DATA_PLUGIN_DATA: Plugins data.
* @WEBKIT_WEBSITE_DATA_COOKIES: Cookies.
* @WEBKIT_WEBSITE_DATA_DEVICE_ID_HASH_SALT: Hash salt used to generate the device ids used by webpages. Since 2.24
* @WEBKIT_WEBSITE_DATA_HSTS_CACHE: HSTS cache. Since 2.26
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/AuxiliaryProcessProxy.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/AuxiliaryProcessProxy.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/AuxiliaryProcessProxy.cpp 2022-06-30 04:49:37.822846000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/AuxiliaryProcessProxy.cpp 2022-08-26 14:18:14.997022419 -0500
@@ -78,6 +78,11 @@ void AuxiliaryProcessProxy::getLaunchOpt
case ProcessLauncher::ProcessType::Web:
varname = "WEB_PROCESS_CMD_PREFIX";
break;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ case ProcessLauncher::ProcessType::Plugin:
+ varname = "PLUGIN_PROCESS_CMD_PREFIX";
+ break;
+#endif
case ProcessLauncher::ProcessType::Network:
varname = "NETWORK_PROCESS_CMD_PREFIX";
break;
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/gtk/WebPageProxyGtk.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/gtk/WebPageProxyGtk.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/gtk/WebPageProxyGtk.cpp 2022-06-30 04:49:37.909512500 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/gtk/WebPageProxyGtk.cpp 2022-08-26 14:18:14.997022419 -0500
@@ -38,6 +38,10 @@
#include <WebCore/PlatformDisplay.h>
#include <wtf/NeverDestroyed.h>
+#if PLATFORM(X11) && ENABLE(NETSCAPE_PLUGIN_API)
+#include <gtk/gtkx.h>
+#endif
+
namespace WebKit {
void WebPageProxy::platformInitialize()
@@ -70,6 +74,62 @@ void WebPageProxy::didUpdateEditorState(
pageClient().selectionDidChange();
}
+#if PLATFORM(X11) && ENABLE(NETSCAPE_PLUGIN_API)
+typedef HashMap<uint64_t, GtkWidget* > PluginWindowMap;
+static PluginWindowMap& pluginWindowMap()
+{
+ static NeverDestroyed<PluginWindowMap> map;
+ return map;
+}
+
+static gboolean pluginContainerPlugRemoved(GtkSocket* socket)
+{
+ uint64_t windowID = static_cast<uint64_t>(gtk_socket_get_id(socket));
+ pluginWindowMap().remove(windowID);
+ return FALSE;
+}
+
+void WebPageProxy::createPluginContainer(CompletionHandler<void(uint64_t)>&& completionHandler)
+{
+ RELEASE_ASSERT(WebCore::PlatformDisplay::sharedDisplay().type() == WebCore::PlatformDisplay::Type::X11);
+ GtkWidget* socket = gtk_socket_new();
+ g_signal_connect(socket, "plug-removed", G_CALLBACK(pluginContainerPlugRemoved), 0);
+ gtk_container_add(GTK_CONTAINER(viewWidget()), socket);
+
+ uint64_t windowID = static_cast<uint64_t>(gtk_socket_get_id(GTK_SOCKET(socket)));
+ pluginWindowMap().set(windowID, socket);
+ completionHandler(windowID);
+}
+
+void WebPageProxy::windowedPluginGeometryDidChange(const WebCore::IntRect& frameRect, const WebCore::IntRect& clipRect, uint64_t windowID)
+{
+ GtkWidget* plugin = pluginWindowMap().get(windowID);
+ if (!plugin)
+ return;
+
+ if (gtk_widget_get_realized(plugin)) {
+ GdkRectangle clip = clipRect;
+ cairo_region_t* clipRegion = cairo_region_create_rectangle(&clip);
+ gdk_window_shape_combine_region(gtk_widget_get_window(plugin), clipRegion, 0, 0);
+ cairo_region_destroy(clipRegion);
+ }
+
+ webkitWebViewBaseChildMoveResize(WEBKIT_WEB_VIEW_BASE(viewWidget()), plugin, frameRect);
+}
+
+void WebPageProxy::windowedPluginVisibilityDidChange(bool isVisible, uint64_t windowID)
+{
+ GtkWidget* plugin = pluginWindowMap().get(windowID);
+ if (!plugin)
+ return;
+
+ if (isVisible)
+ gtk_widget_show(plugin);
+ else
+ gtk_widget_hide(plugin);
+}
+#endif // PLATFORM(X11) && ENABLE(NETSCAPE_PLUGIN_API)
+
void WebPageProxy::setInputMethodState(std::optional<InputMethodState>&& state)
{
webkitWebViewBaseSetInputMethodState(WEBKIT_WEB_VIEW_BASE(viewWidget()), WTFMove(state));
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Launcher/glib/BubblewrapLauncher.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/Launcher/glib/BubblewrapLauncher.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Launcher/glib/BubblewrapLauncher.cpp 2022-06-30 04:49:37.852846000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/Launcher/glib/BubblewrapLauncher.cpp 2022-08-26 14:18:14.997022419 -0500
@@ -636,6 +636,13 @@ GRefPtr<GSubprocess> bubblewrapSpawn(GSu
{
ASSERT(launcher);
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ // It is impossible to know what access arbitrary plugins need and since it is for legacy
+ // reasons lets just leave it unsandboxed.
+ if (launchOptions.processType == ProcessLauncher::ProcessType::Plugin)
+ return adoptGRef(g_subprocess_launcher_spawnv(launcher, argv, error));
+#endif
+
// For now we are just considering the network process trusted as it
// requires a lot of access but doesn't execute arbitrary code like
// the WebProcess where our focus lies.
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Launcher/glib/ProcessLauncherGLib.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/Launcher/glib/ProcessLauncherGLib.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Launcher/glib/ProcessLauncherGLib.cpp 2022-08-08 16:28:31.865314500 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/Launcher/glib/ProcessLauncherGLib.cpp 2022-08-26 14:18:14.997022419 -0500
@@ -74,10 +74,21 @@ void ProcessLauncher::launchProcess()
String executablePath;
CString realExecutablePath;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ String pluginPath;
+ CString realPluginPath;
+#endif
switch (m_launchOptions.processType) {
case ProcessLauncher::ProcessType::Web:
executablePath = executablePathOfWebProcess();
break;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ case ProcessLauncher::ProcessType::Plugin:
+ executablePath = executablePathOfPluginProcess();
+ pluginPath = m_launchOptions.extraInitializationData.get("plugin-path");
+ realPluginPath = FileSystem::fileSystemRepresentation(pluginPath);
+ break;
+#endif
case ProcessLauncher::ProcessType::Network:
executablePath = executablePathOfNetworkProcess();
break;
@@ -125,7 +136,11 @@ void ProcessLauncher::launchProcess()
if (configureJSCForTesting)
argv[i++] = const_cast<char*>("--configure-jsc-for-testing");
#endif
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ argv[i++] = const_cast<char*>(realPluginPath.data());
+#else
argv[i++] = nullptr;
+#endif
// Warning: do not set a child setup function, because we want GIO to be able to spawn with
// posix_spawn() rather than fork()/exec(), in order to better accomodate applications that use
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Launcher/ProcessLauncher.h webkitgtk-2.36.7/Source/WebKit/UIProcess/Launcher/ProcessLauncher.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Launcher/ProcessLauncher.h 2022-06-30 04:49:37.849512600 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/Launcher/ProcessLauncher.h 2022-08-26 14:18:14.997022419 -0500
@@ -70,6 +70,9 @@ public:
enum class ProcessType {
Web,
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ Plugin,
+#endif
Network,
#if ENABLE(GPU_PROCESS)
GPU,
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/PageClient.h webkitgtk-2.36.7/Source/WebKit/UIProcess/PageClient.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/PageClient.h 2022-06-30 04:49:37.856179200 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/PageClient.h 2022-08-26 14:18:14.997022419 -0500
@@ -56,6 +56,7 @@
#include <wtf/WeakPtr.h>
#if PLATFORM(COCOA)
+#include "PluginComplexTextInputState.h"
#include "RemoteLayerTreeNode.h"
#include "WKFoundation.h"
@@ -423,6 +424,8 @@ public:
#endif
#if PLATFORM(MAC)
+ virtual void pluginFocusOrWindowFocusChanged(uint64_t pluginComplexTextInputIdentifier, bool pluginHasFocusAndWindowHasFocus) = 0;
+ virtual void setPluginComplexTextInputState(uint64_t pluginComplexTextInputIdentifier, PluginComplexTextInputState) = 0;
virtual void showCorrectionPanel(WebCore::AlternativeTextType, const WebCore::FloatRect& boundingBoxOfReplacedString, const String& replacedString, const String& replacementString, const Vector<String>& alternativeReplacementStrings) = 0;
virtual void dismissCorrectionPanel(WebCore::ReasonForDismissingAlternativeText) = 0;
virtual String dismissCorrectionPanelSoon(WebCore::ReasonForDismissingAlternativeText) = 0;
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/gtk/PluginInfoCache.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/gtk/PluginInfoCache.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/gtk/PluginInfoCache.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/gtk/PluginInfoCache.cpp 2022-08-26 14:18:14.997022419 -0500
@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2014 Igalia S.L.
+ *
+ * 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 INC. 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 INC. 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 "config.h"
+#include "PluginInfoCache.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "NetscapePluginModule.h"
+#include <WebCore/PlatformDisplay.h>
+#include <wtf/FileSystem.h>
+#include <wtf/text/CString.h>
+
+namespace WebKit {
+
+static const unsigned gSchemaVersion = 3;
+
+PluginInfoCache& PluginInfoCache::singleton()
+{
+ static NeverDestroyed<PluginInfoCache> pluginInfoCache;
+ return pluginInfoCache;
+}
+
+static inline const char* cacheFilenameForCurrentDisplay()
+{
+#if PLATFORM(X11)
+ if (WebCore::PlatformDisplay::sharedDisplay().type() == WebCore::PlatformDisplay::Type::X11)
+ return "plugins-x11";
+#endif
+#if PLATFORM(WAYLAND)
+ if (WebCore::PlatformDisplay::sharedDisplay().type() == WebCore::PlatformDisplay::Type::Wayland)
+ return "plugins-wayland";
+#endif
+
+ ASSERT_NOT_REACHED();
+ return "plugins";
+}
+
+PluginInfoCache::PluginInfoCache()
+ : m_cacheFile(g_key_file_new())
+ , m_saveToFileIdle(RunLoop::main(), this, &PluginInfoCache::saveToFile)
+ , m_readOnlyMode(false)
+{
+ m_saveToFileIdle.setPriority(G_PRIORITY_DEFAULT_IDLE);
+
+ GUniquePtr<char> cacheDirectory(g_build_filename(g_get_user_cache_dir(), "webkitgtk", nullptr));
+ if (FileSystem::makeAllDirectories(cacheDirectory.get())) {
+ // Delete old cache file.
+ GUniquePtr<char> oldCachePath(g_build_filename(cacheDirectory.get(), "plugins", nullptr));
+ FileSystem::deleteFile(FileSystem::stringFromFileSystemRepresentation(oldCachePath.get()));
+
+ m_cachePath.reset(g_build_filename(cacheDirectory.get(), cacheFilenameForCurrentDisplay(), nullptr));
+ g_key_file_load_from_file(m_cacheFile.get(), m_cachePath.get(), G_KEY_FILE_NONE, nullptr);
+ }
+
+ if (g_key_file_has_group(m_cacheFile.get(), "schema")) {
+ unsigned schemaVersion = static_cast<unsigned>(g_key_file_get_integer(m_cacheFile.get(), "schema", "version", nullptr));
+ if (schemaVersion < gSchemaVersion) {
+ // Cache file using an old schema, create a new empty file.
+ m_cacheFile.reset(g_key_file_new());
+ } else if (schemaVersion > gSchemaVersion) {
+ // Cache file using a newer schema, use the cache in read only mode.
+ m_readOnlyMode = true;
+ } else {
+ // Same schema version, we don't need to update it.
+ return;
+ }
+ }
+
+ g_key_file_set_integer(m_cacheFile.get(), "schema", "version", static_cast<unsigned>(gSchemaVersion));
+}
+
+PluginInfoCache::~PluginInfoCache()
+{
+}
+
+void PluginInfoCache::saveToFile()
+{
+ gsize dataLength;
+ GUniquePtr<char> data(g_key_file_to_data(m_cacheFile.get(), &dataLength, nullptr));
+ if (!data)
+ return;
+
+ g_file_set_contents(m_cachePath.get(), data.get(), dataLength, nullptr);
+}
+
+bool PluginInfoCache::getPluginInfo(const String& pluginPath, PluginModuleInfo& plugin)
+{
+ CString pluginGroup = pluginPath.utf8();
+ if (!g_key_file_has_group(m_cacheFile.get(), pluginGroup.data()))
+ return false;
+
+ auto lastModifiedTime = FileSystem::fileModificationTime(pluginPath);
+ if (!lastModifiedTime)
+ return false;
+ time_t cachedLastModified = static_cast<time_t>(g_key_file_get_uint64(m_cacheFile.get(), pluginGroup.data(), "mtime", nullptr));
+ if (lastModifiedTime->secondsSinceEpoch().secondsAs<time_t>() != cachedLastModified)
+ return false;
+
+ plugin.path = pluginPath;
+ plugin.info.file = FileSystem::pathFileName(pluginPath);
+
+ GUniquePtr<char> stringValue(g_key_file_get_string(m_cacheFile.get(), pluginGroup.data(), "name", nullptr));
+ plugin.info.name = String::fromUTF8(stringValue.get());
+
+ stringValue.reset(g_key_file_get_string(m_cacheFile.get(), pluginGroup.data(), "description", nullptr));
+ plugin.info.desc = String::fromUTF8(stringValue.get());
+
+#if PLUGIN_ARCHITECTURE(UNIX)
+ stringValue.reset(g_key_file_get_string(m_cacheFile.get(), pluginGroup.data(), "mime-description", nullptr));
+ NetscapePluginModule::parseMIMEDescription(String::fromUTF8(stringValue.get()), plugin.info.mimes);
+#endif
+
+ return true;
+}
+
+void PluginInfoCache::updatePluginInfo(const String& pluginPath, const PluginModuleInfo& plugin)
+{
+ auto lastModifiedTime = FileSystem::fileModificationTime(pluginPath);
+ if (!lastModifiedTime)
+ return;
+
+ CString pluginGroup = pluginPath.utf8();
+ g_key_file_set_uint64(m_cacheFile.get(), pluginGroup.data(), "mtime", lastModifiedTime->secondsSinceEpoch().secondsAs<guint64>());
+ g_key_file_set_string(m_cacheFile.get(), pluginGroup.data(), "name", plugin.info.name.utf8().data());
+ g_key_file_set_string(m_cacheFile.get(), pluginGroup.data(), "description", plugin.info.desc.utf8().data());
+
+#if PLUGIN_ARCHITECTURE(UNIX)
+ String mimeDescription = NetscapePluginModule::buildMIMEDescription(plugin.info.mimes);
+ g_key_file_set_string(m_cacheFile.get(), pluginGroup.data(), "mime-description", mimeDescription.utf8().data());
+#endif
+
+ if (m_cachePath && !m_readOnlyMode) {
+ // Save the cache file in an idle to make sure it happens in the main thread and
+ // it's done only once when this is called multiple times in a very short time.
+ if (m_saveToFileIdle.isActive())
+ return;
+
+ m_saveToFileIdle.startOneShot(0_s);
+ }
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/gtk/PluginInfoCache.h webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/gtk/PluginInfoCache.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/gtk/PluginInfoCache.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/gtk/PluginInfoCache.h 2022-08-26 14:18:14.997022419 -0500
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2014 Igalia S.L.
+ *
+ * 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 INC. 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 INC. 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.
+ */
+
+#ifndef PluginInfoCache_h
+#define PluginInfoCache_h
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "PluginModuleInfo.h"
+#include <wtf/NeverDestroyed.h>
+#include <wtf/RunLoop.h>
+#include <wtf/glib/GUniquePtr.h>
+
+namespace WebKit {
+
+class PluginInfoCache {
+ WTF_MAKE_NONCOPYABLE(PluginInfoCache);
+ friend NeverDestroyed<PluginInfoCache>;
+public:
+ static PluginInfoCache& singleton();
+
+ bool getPluginInfo(const String& pluginPath, PluginModuleInfo&);
+ void updatePluginInfo(const String& pluginPath, const PluginModuleInfo&);
+
+private:
+ PluginInfoCache();
+ ~PluginInfoCache();
+
+ void saveToFile();
+
+ GUniquePtr<GKeyFile> m_cacheFile;
+ GUniquePtr<char> m_cachePath;
+ RunLoop::Timer<PluginInfoCache> m_saveToFileIdle;
+ bool m_readOnlyMode;
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif // PluginInfoCache_h
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/PluginInfoStore.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/PluginInfoStore.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/PluginInfoStore.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/PluginInfoStore.cpp 2022-08-26 14:18:14.997022419 -0500
@@ -0,0 +1,256 @@
+/*
+ * Copyright (C) 2010, 2012 Apple 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 INC. 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 INC. 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 "config.h"
+#include "PluginInfoStore.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "PluginModuleInfo.h"
+#include <WebCore/MIMETypeRegistry.h>
+#include <WebCore/SecurityOrigin.h>
+#include <algorithm>
+#include <wtf/ListHashSet.h>
+#include <wtf/StdLibExtras.h>
+#include <wtf/URL.h>
+
+namespace WebKit {
+using namespace WebCore;
+
+PluginInfoStore::PluginInfoStore()
+ : m_pluginListIsUpToDate(false)
+{
+}
+
+void PluginInfoStore::setAdditionalPluginsDirectories(const Vector<String>& directories)
+{
+ m_additionalPluginsDirectories = directories;
+ refresh();
+}
+
+void PluginInfoStore::refresh()
+{
+ m_pluginListIsUpToDate = false;
+}
+
+template <typename T, typename U>
+static void addFromVector(T& hashSet, const U& vector)
+{
+ for (size_t i = 0; i < vector.size(); ++i)
+ hashSet.add(vector[i]);
+}
+
+void PluginInfoStore::loadPluginsIfNecessary()
+{
+ if (m_pluginListIsUpToDate)
+ return;
+
+ ListHashSet<String> uniquePluginPaths;
+
+ // First, load plug-ins from the additional plug-ins directories specified.
+ for (size_t i = 0; i < m_additionalPluginsDirectories.size(); ++i)
+ addFromVector(uniquePluginPaths, pluginPathsInDirectory(m_additionalPluginsDirectories[i]));
+
+ // Then load plug-ins from the standard plug-ins directories.
+ Vector<String> directories = pluginsDirectories();
+ for (size_t i = 0; i < directories.size(); ++i)
+ addFromVector(uniquePluginPaths, pluginPathsInDirectory(directories[i]));
+
+ // Then load plug-ins that are not in the standard plug-ins directories.
+ addFromVector(uniquePluginPaths, individualPluginPaths());
+
+ m_plugins.clear();
+
+ for (const auto& pluginPath : uniquePluginPaths)
+ loadPlugin(m_plugins, pluginPath);
+
+ m_pluginListIsUpToDate = true;
+}
+
+void PluginInfoStore::loadPlugin(Vector<PluginModuleInfo>& plugins, const String& pluginPath)
+{
+ PluginModuleInfo plugin;
+
+ if (!getPluginInfo(pluginPath, plugin))
+ return;
+
+ if (!shouldUsePlugin(plugins, plugin))
+ return;
+
+ plugins.append(plugin);
+}
+
+Vector<PluginModuleInfo> PluginInfoStore::plugins()
+{
+ loadPluginsIfNecessary();
+ return m_plugins;
+}
+
+PluginModuleInfo PluginInfoStore::findPluginForMIMEType(const String& mimeType, PluginData::AllowedPluginTypes allowedPluginTypes) const
+{
+ ASSERT(!mimeType.isNull());
+
+ for (const auto& plugin : m_plugins) {
+ if (allowedPluginTypes == PluginData::OnlyApplicationPlugins && !plugin.info.isApplicationPlugin)
+ continue;
+
+ for (const auto& mimeClassInfo : plugin.info.mimes) {
+ if (mimeClassInfo.type == mimeType)
+ return plugin;
+ }
+ }
+
+ return PluginModuleInfo();
+}
+
+PluginModuleInfo PluginInfoStore::findPluginForExtension(const String& extension, String& mimeType, PluginData::AllowedPluginTypes allowedPluginTypes) const
+{
+ ASSERT(!extension.isNull());
+
+ for (const auto& plugin : m_plugins) {
+ if (allowedPluginTypes == PluginData::OnlyApplicationPlugins && !plugin.info.isApplicationPlugin)
+ continue;
+
+ for (const auto& mimeClassInfo : plugin.info.mimes) {
+ if (mimeClassInfo.extensions.contains(extension)) {
+ // We found a supported extension, set the correct MIME type.
+ mimeType = mimeClassInfo.type;
+ return plugin;
+ }
+ }
+ }
+
+ return PluginModuleInfo();
+}
+
+static String pathExtension(const URL& url)
+{
+ auto filename = url.lastPathComponent();
+ if (filename.endsWith('/'))
+ return { };
+ size_t lastDotPosition = filename.reverseFind('.');
+ if (lastDotPosition == notFound)
+ return { };
+ return filename.substring(lastDotPosition + 1).convertToASCIILowercase();
+}
+
+#if !PLATFORM(COCOA)
+
+PluginModuleLoadPolicy PluginInfoStore::defaultLoadPolicyForPlugin(const PluginModuleInfo&)
+{
+ return PluginModuleLoadNormally;
+}
+
+PluginModuleInfo PluginInfoStore::findPluginWithBundleIdentifier(const String&)
+{
+ ASSERT_NOT_REACHED();
+ return PluginModuleInfo();
+}
+
+#endif
+
+PluginModuleInfo PluginInfoStore::findPlugin(String& mimeType, const URL& url, PluginData::AllowedPluginTypes allowedPluginTypes)
+{
+ loadPluginsIfNecessary();
+
+ // First, check if we can get the plug-in based on its MIME type.
+ if (!mimeType.isNull()) {
+ PluginModuleInfo plugin = findPluginForMIMEType(mimeType, allowedPluginTypes);
+ if (!plugin.path.isNull())
+ return plugin;
+ }
+
+ // Next, check if any plug-ins claim to support the URL extension.
+ String extension = pathExtension(url);
+ if (!extension.isNull() && mimeType.isEmpty()) {
+ PluginModuleInfo plugin = findPluginForExtension(extension, mimeType, allowedPluginTypes);
+ if (!plugin.path.isNull())
+ return plugin;
+
+ // Finally, try to get the MIME type from the extension in a platform specific manner and use that.
+ String extensionMimeType = MIMETypeRegistry::mimeTypeForExtension(extension);
+ if (!extensionMimeType.isNull()) {
+ PluginModuleInfo plugin = findPluginForMIMEType(extensionMimeType, allowedPluginTypes);
+ if (!plugin.path.isNull()) {
+ mimeType = extensionMimeType;
+ return plugin;
+ }
+ }
+ }
+
+ return PluginModuleInfo();
+}
+
+bool PluginInfoStore::isSupportedPlugin(const PluginInfoStore::SupportedPlugin& plugin, const String& mimeType, const URL& pluginURL)
+{
+ if (!mimeType.isEmpty() && plugin.mimeTypes.contains(mimeType))
+ return true;
+ auto extension = pathExtension(pluginURL);
+ return extension.isEmpty() ? false : plugin.extensions.contains(extension);
+}
+
+bool PluginInfoStore::isSupportedPlugin(const String& mimeType, const URL& pluginURL, const String&, const URL& pageURL)
+{
+ // We check only pageURL for consistency with WebProcess visible plugins.
+ if (!m_supportedPlugins)
+ return true;
+
+ return m_supportedPlugins->findIf([&] (auto&& plugin) {
+ return pageURL.isMatchingDomain(plugin.matchingDomain) && isSupportedPlugin(plugin, mimeType, pluginURL);
+ }) != notFound;
+}
+
+std::optional<Vector<SupportedPluginIdentifier>> PluginInfoStore::supportedPluginIdentifiers()
+{
+ if (!m_supportedPlugins)
+ return std::nullopt;
+
+ return WTF::map(*m_supportedPlugins, [] (auto&& item) {
+ return SupportedPluginIdentifier { item.matchingDomain, item.identifier };
+ });
+}
+
+void PluginInfoStore::addSupportedPlugin(String&& domainName, String&& identifier, HashSet<String>&& mimeTypes, HashSet<String> extensions)
+{
+ if (!m_supportedPlugins)
+ m_supportedPlugins = Vector<SupportedPlugin> { };
+
+ m_supportedPlugins->append(SupportedPlugin { WTFMove(domainName), WTFMove(identifier), WTFMove(mimeTypes), WTFMove(extensions) });
+}
+
+PluginModuleInfo PluginInfoStore::infoForPluginWithPath(const String& pluginPath) const
+{
+ for (const auto& plugin : m_plugins) {
+ if (plugin.path == pluginPath)
+ return plugin;
+ }
+
+ ASSERT_NOT_REACHED();
+ return PluginModuleInfo();
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/PluginInfoStore.h webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/PluginInfoStore.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/PluginInfoStore.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/PluginInfoStore.h 2022-08-26 14:18:14.997022419 -0500
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2010, 2012, 2016 Apple 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 INC. 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 INC. 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.
+ */
+
+#pragma once
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "PluginModuleInfo.h"
+
+#include <WebCore/PluginData.h>
+#include <wtf/HashSet.h>
+
+namespace WebKit {
+
+class PluginInfoStore;
+
+class PluginInfoStore {
+ WTF_MAKE_NONCOPYABLE(PluginInfoStore);
+
+public:
+ PluginInfoStore();
+
+ void setAdditionalPluginsDirectories(const Vector<String>&);
+
+ void refresh();
+ Vector<PluginModuleInfo> plugins();
+
+ // Returns the info for a plug-in that can handle the given MIME type.
+ // If the MIME type is null, the file extension of the given url will be used to infer the
+ // plug-in type. In that case, mimeType will be filled in with the right MIME type.
+ PluginModuleInfo findPlugin(String& mimeType, const URL&, WebCore::PluginData::AllowedPluginTypes = WebCore::PluginData::AllPlugins);
+
+ // Returns the info for the plug-in with the given bundle identifier.
+ PluginModuleInfo findPluginWithBundleIdentifier(const String& bundleIdentifier);
+
+ // Returns the info for the plug-in with the given path.
+ PluginModuleInfo infoForPluginWithPath(const String& pluginPath) const;
+
+ static PluginModuleLoadPolicy defaultLoadPolicyForPlugin(const PluginModuleInfo&);
+
+ bool isSupportedPlugin(const String& mimeType, const URL& pluginURL, const String& frameURLString, const URL& pageURL);
+ std::optional<Vector<WebCore::SupportedPluginIdentifier>> supportedPluginIdentifiers();
+ void addSupportedPlugin(String&& matchingDomain, String&& identifier, HashSet<String>&& mimeTypes, HashSet<String> extensions);
+ void clearSupportedPlugins() { m_supportedPlugins = std::nullopt; }
+
+private:
+ PluginModuleInfo findPluginForMIMEType(const String& mimeType, WebCore::PluginData::AllowedPluginTypes) const;
+ PluginModuleInfo findPluginForExtension(const String& extension, String& mimeType, WebCore::PluginData::AllowedPluginTypes) const;
+
+ void loadPluginsIfNecessary();
+ static void loadPlugin(Vector<PluginModuleInfo>& plugins, const String& pluginPath);
+
+ // Platform-specific member functions:
+
+ // Returns paths to directories that should be searched for plug-ins (via pluginPathsInDirectory).
+ static Vector<String> pluginsDirectories();
+
+ // Returns paths to all plug-ins in the specified directory.
+ static Vector<String> pluginPathsInDirectory(const String& directory);
+
+ // Returns paths to individual plug-ins that won't be found via pluginsDirectories/pluginPathsInDirectory.
+ static Vector<String> individualPluginPaths();
+
+ // Load plug-in info for the plug-in with the specified path.
+ static bool getPluginInfo(const String& pluginPath, PluginModuleInfo&);
+
+ // Return whether this plug-in should be used (added to the list of plug-ins) or not.
+ static bool shouldUsePlugin(Vector<PluginModuleInfo>& alreadyLoadedPlugins, const PluginModuleInfo&);
+
+ Vector<String> m_additionalPluginsDirectories;
+ Vector<PluginModuleInfo> m_plugins;
+ bool m_pluginListIsUpToDate;
+
+ struct SupportedPlugin {
+ String matchingDomain;
+ String identifier;
+ HashSet<String> mimeTypes;
+ HashSet<String> extensions;
+ };
+ static bool isSupportedPlugin(const SupportedPlugin&, const String& mimeType, const URL& pluginURL);
+
+ std::optional<Vector<SupportedPlugin>> m_supportedPlugins;
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/PluginProcessManager.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/PluginProcessManager.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/PluginProcessManager.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/PluginProcessManager.cpp 2022-08-26 14:18:14.997022419 -0500
@@ -0,0 +1,165 @@
+/*
+ * Copyright (C) 2010-2020 Apple 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 INC. 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 INC. 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 "config.h"
+#include "PluginProcessManager.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "PluginProcessProxy.h"
+#include "WebProcessProxyMessages.h"
+#include "WebsiteDataFetchOption.h"
+#include <wtf/CryptographicallyRandomNumber.h>
+#include <wtf/NeverDestroyed.h>
+#include <wtf/StdLibExtras.h>
+#include <wtf/text/WTFString.h>
+
+namespace WebKit {
+
+PluginProcessManager& PluginProcessManager::singleton()
+{
+ static NeverDestroyed<PluginProcessManager> pluginProcessManager;
+ return pluginProcessManager;
+}
+
+PluginProcessManager::PluginProcessManager()
+#if PLATFORM(COCOA)
+ : m_processSuppressionDisabledForPageCounter([this](RefCounterEvent event) { updateProcessSuppressionDisabled(event); })
+#endif
+{
+}
+
+uint64_t PluginProcessManager::pluginProcessToken(const PluginModuleInfo& pluginModuleInfo, PluginProcessSandboxPolicy pluginProcessSandboxPolicy)
+{
+ // See if we know this token already.
+ for (size_t i = 0; i < m_pluginProcessTokens.size(); ++i) {
+ const PluginProcessAttributes& attributes = m_pluginProcessTokens[i].first;
+
+ if (attributes.moduleInfo.path == pluginModuleInfo.path
+ && attributes.sandboxPolicy == pluginProcessSandboxPolicy)
+ return m_pluginProcessTokens[i].second;
+ }
+
+ uint64_t token;
+ while (true) {
+ cryptographicallyRandomValues(&token, sizeof(token));
+
+ if (m_knownTokens.isValidValue(token) && !m_knownTokens.contains(token))
+ break;
+ }
+
+ PluginProcessAttributes attributes;
+ attributes.moduleInfo = pluginModuleInfo;
+ attributes.sandboxPolicy = pluginProcessSandboxPolicy;
+
+ m_pluginProcessTokens.append(std::make_pair(WTFMove(attributes), token));
+ m_knownTokens.add(token);
+
+ return token;
+}
+
+bool PluginProcessManager::getPluginProcessConnection(uint64_t pluginProcessToken, Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply&& reply)
+{
+ ASSERT(pluginProcessToken);
+
+ auto* pluginProcess = getOrCreatePluginProcess(pluginProcessToken);
+ ASSERT(pluginProcess);
+ if (!pluginProcess)
+ return false;
+
+ pluginProcess->getPluginProcessConnection(WTFMove(reply));
+ return true;
+}
+
+void PluginProcessManager::removePluginProcessProxy(PluginProcessProxy* pluginProcessProxy)
+{
+ size_t vectorIndex = m_pluginProcesses.find(pluginProcessProxy);
+ ASSERT(vectorIndex != notFound);
+
+ m_pluginProcesses.remove(vectorIndex);
+}
+
+void PluginProcessManager::fetchWebsiteData(const PluginModuleInfo& plugin, OptionSet<WebsiteDataFetchOption> fetchOptions, WTF::Function<void (Vector<String>)>&& completionHandler)
+{
+ auto token = pluginProcessToken(plugin, PluginProcessSandboxPolicy::Normal);
+ auto pluginProcess = fetchOptions.contains(WebsiteDataFetchOption::DoNotCreateProcesses) ? getPluginProcess(token) : getOrCreatePluginProcess(token);
+ if (!pluginProcess) {
+ completionHandler({ });
+ return;
+ }
+
+ pluginProcess->fetchWebsiteData(WTFMove(completionHandler));
+}
+
+void PluginProcessManager::deleteWebsiteData(const PluginModuleInfo& plugin, WallTime modifiedSince, WTF::Function<void ()>&& completionHandler)
+{
+ PluginProcessProxy* pluginProcess = getOrCreatePluginProcess(pluginProcessToken(plugin, PluginProcessSandboxPolicy::Normal));
+ pluginProcess->deleteWebsiteData(modifiedSince, WTFMove(completionHandler));
+}
+
+void PluginProcessManager::deleteWebsiteDataForHostNames(const PluginModuleInfo& plugin, const Vector<String>& hostNames,WTF::Function<void ()>&& completionHandler)
+{
+ PluginProcessProxy* pluginProcess = getOrCreatePluginProcess(pluginProcessToken(plugin, PluginProcessSandboxPolicy::Normal));
+ pluginProcess->deleteWebsiteDataForHostNames(hostNames, WTFMove(completionHandler));
+}
+
+PluginProcessProxy* PluginProcessManager::getPluginProcess(uint64_t pluginProcessToken)
+{
+ for (const auto& pluginProcess : m_pluginProcesses) {
+ if (pluginProcess->pluginProcessToken() == pluginProcessToken)
+ return pluginProcess.get();
+ }
+
+ return nullptr;
+}
+
+#if OS(LINUX)
+void PluginProcessManager::sendMemoryPressureEvent(bool isCritical)
+{
+ for (auto& pluginProcess : m_pluginProcesses)
+ pluginProcess->sendMemoryPressureEvent(isCritical);
+}
+#endif
+
+PluginProcessProxy* PluginProcessManager::getOrCreatePluginProcess(uint64_t pluginProcessToken)
+{
+ if (auto existingProcess = getPluginProcess(pluginProcessToken))
+ return existingProcess;
+
+ for (auto& attributesAndToken : m_pluginProcessTokens) {
+ if (attributesAndToken.second == pluginProcessToken) {
+ auto pluginProcess = PluginProcessProxy::create(this, attributesAndToken.first, attributesAndToken.second);
+ PluginProcessProxy* pluginProcessPtr = pluginProcess.ptr();
+ m_pluginProcesses.append(WTFMove(pluginProcess));
+ return pluginProcessPtr;
+ }
+ }
+
+ return nullptr;
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/PluginProcessManager.h webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/PluginProcessManager.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/PluginProcessManager.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/PluginProcessManager.h 2022-08-26 14:18:14.997022419 -0500
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2010-2017 Apple 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 INC. 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 INC. 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.
+ */
+
+#pragma once
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "PluginModuleInfo.h"
+#include "PluginProcess.h"
+#include "PluginProcessAttributes.h"
+#include "ProcessThrottler.h"
+#include "WebProcessProxyMessagesReplies.h"
+#include <wtf/Forward.h>
+#include <wtf/HashSet.h>
+#include <wtf/Noncopyable.h>
+#include <wtf/RefCounter.h>
+#include <wtf/Vector.h>
+
+namespace IPC {
+class Encoder;
+}
+
+namespace WebKit {
+
+class PluginInfoStore;
+class PluginProcessProxy;
+class WebProcessProxy;
+enum class WebsiteDataFetchOption : uint8_t;
+
+class PluginProcessManager {
+ WTF_MAKE_NONCOPYABLE(PluginProcessManager);
+ friend NeverDestroyed<PluginProcessManager>;
+public:
+ static PluginProcessManager& singleton();
+
+ uint64_t pluginProcessToken(const PluginModuleInfo&, PluginProcessSandboxPolicy);
+
+ bool getPluginProcessConnection(uint64_t pluginProcessToken, Messages::WebProcessProxy::GetPluginProcessConnectionDelayedReply&&);
+ void removePluginProcessProxy(PluginProcessProxy*);
+
+ void fetchWebsiteData(const PluginModuleInfo&, OptionSet<WebsiteDataFetchOption>, WTF::Function<void (Vector<String>)>&& completionHandler);
+ void deleteWebsiteData(const PluginModuleInfo&, WallTime modifiedSince, WTF::Function<void ()>&& completionHandler);
+ void deleteWebsiteDataForHostNames(const PluginModuleInfo&, const Vector<String>& hostNames, WTF::Function<void ()>&& completionHandler);
+
+#if OS(LINUX)
+ void sendMemoryPressureEvent(bool isCritical);
+#endif
+
+#if PLATFORM(COCOA)
+ inline ProcessSuppressionDisabledToken processSuppressionDisabledToken();
+ inline bool processSuppressionDisabled() const;
+ void updateProcessSuppressionDisabled(RefCounterEvent);
+#endif
+
+ const Vector<RefPtr<PluginProcessProxy>>& pluginProcesses() const { return m_pluginProcesses; }
+
+#if PLATFORM(MAC)
+ void setExperimentalPlugInSandboxProfilesEnabled(bool);
+ bool experimentalPlugInSandboxProfilesEnabled() const { return m_experimentalPlugInSandboxProfilesEnabled; }
+#endif
+
+private:
+ PluginProcessManager();
+
+ PluginProcessProxy* getPluginProcess(uint64_t pluginProcessToken);
+ PluginProcessProxy* getOrCreatePluginProcess(uint64_t pluginProcessToken);
+
+ Vector<std::pair<PluginProcessAttributes, uint64_t>> m_pluginProcessTokens;
+ HashSet<uint64_t> m_knownTokens;
+
+ Vector<RefPtr<PluginProcessProxy>> m_pluginProcesses;
+
+#if PLATFORM(COCOA)
+ ProcessSuppressionDisabledCounter m_processSuppressionDisabledForPageCounter;
+#endif
+#if PLATFORM(MAC)
+ bool m_experimentalPlugInSandboxProfilesEnabled { false };
+#endif
+};
+
+#if PLATFORM(COCOA)
+inline ProcessSuppressionDisabledToken PluginProcessManager::processSuppressionDisabledToken()
+{
+ return m_processSuppressionDisabledForPageCounter.count();
+}
+
+inline bool PluginProcessManager::processSuppressionDisabled() const
+{
+ return m_processSuppressionDisabledForPageCounter.value();
+}
+#endif
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/PluginProcessProxy.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/PluginProcessProxy.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/PluginProcessProxy.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/PluginProcessProxy.cpp 2022-08-26 14:18:14.997022419 -0500
@@ -0,0 +1,308 @@
+/*
+ * Copyright (C) 2010-2020 Apple 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 INC. 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 INC. 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 "config.h"
+#include "PluginProcessProxy.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "AuxiliaryProcessMessages.h"
+#include "PluginProcessConnectionManagerMessages.h"
+#include "PluginProcessCreationParameters.h"
+#include "PluginProcessManager.h"
+#include "PluginProcessMessages.h"
+#include "WebCoreArgumentCoders.h"
+#include "WebProcessPool.h"
+#include "WebProcessProxy.h"
+#include "WebProcessProxyMessages.h"
+#include <WebCore/NotImplemented.h>
+#include <wtf/RunLoop.h>
+
+namespace WebKit {
+using namespace WebCore;
+
+static const Seconds minimumLifetime { 2_min };
+static const Seconds snapshottingMinimumLifetime { 30_s };
+
+static const Seconds shutdownTimeout { 1_min };
+static const Seconds snapshottingShutdownTimeout { 15_s };
+
+static uint64_t generatePluginProcessCallbackID()
+{
+ static uint64_t callbackID;
+
+ return ++callbackID;
+}
+
+Ref<PluginProcessProxy> PluginProcessProxy::create(PluginProcessManager* PluginProcessManager, const PluginProcessAttributes& pluginProcessAttributes, uint64_t pluginProcessToken)
+{
+ return adoptRef(*new PluginProcessProxy(PluginProcessManager, pluginProcessAttributes, pluginProcessToken));
+}
+
+PluginProcessProxy::PluginProcessProxy(PluginProcessManager* PluginProcessManager, const PluginProcessAttributes& pluginProcessAttributes, uint64_t pluginProcessToken)
+ : m_throttler(*this, false)
+ , m_pluginProcessManager(PluginProcessManager)
+ , m_pluginProcessAttributes(pluginProcessAttributes)
+ , m_pluginProcessToken(pluginProcessToken)
+ , m_numPendingConnectionRequests(0)
+#if PLATFORM(COCOA)
+ , m_modalWindowIsShowing(false)
+ , m_fullscreenWindowIsShowing(false)
+ , m_preFullscreenAppPresentationOptions(0)
+#endif
+{
+ connect();
+}
+
+PluginProcessProxy::~PluginProcessProxy()
+{
+ if (m_connection)
+ m_connection->invalidate();
+
+ ASSERT(m_pendingFetchWebsiteDataRequests.isEmpty());
+ ASSERT(m_pendingFetchWebsiteDataCallbacks.isEmpty());
+ ASSERT(m_pendingDeleteWebsiteDataRequests.isEmpty());
+ ASSERT(m_pendingDeleteWebsiteDataCallbacks.isEmpty());
+}
+
+void PluginProcessProxy::getLaunchOptions(ProcessLauncher::LaunchOptions& launchOptions)
+{
+ platformGetLaunchOptionsWithAttributes(launchOptions, m_pluginProcessAttributes);
+ AuxiliaryProcessProxy::getLaunchOptions(launchOptions);
+}
+
+void PluginProcessProxy::processWillShutDown(IPC::Connection& connection)
+{
+ ASSERT_UNUSED(connection, this->connection() == &connection);
+}
+
+// Asks the plug-in process to create a new connection to a web process. The connection identifier will be
+// encoded in the given argument encoder and sent back to the connection of the given web process.
+void PluginProcessProxy::getPluginProcessConnection(Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply&& reply)
+{
+ m_pendingConnectionReplies.append(WTFMove(reply));
+
+ if (state() == State::Launching) {
+ m_numPendingConnectionRequests++;
+ return;
+ }
+
+ // Ask the plug-in process to create a connection. Since the plug-in can be waiting for a synchronous reply
+ // we need to make sure that this message is always processed, even when the plug-in is waiting for a synchronus reply.
+ m_connection->send(Messages::PluginProcess::CreateWebProcessConnection(), 0, IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
+}
+
+void PluginProcessProxy::fetchWebsiteData(CompletionHandler<void (Vector<String>)>&& completionHandler)
+{
+ uint64_t callbackID = generatePluginProcessCallbackID();
+ m_pendingFetchWebsiteDataCallbacks.set(callbackID, WTFMove(completionHandler));
+
+ if (state() == State::Launching) {
+ m_pendingFetchWebsiteDataRequests.append(callbackID);
+ return;
+ }
+
+ m_connection->send(Messages::PluginProcess::GetSitesWithData(callbackID), 0);
+}
+
+void PluginProcessProxy::deleteWebsiteData(WallTime modifiedSince, CompletionHandler<void ()>&& completionHandler)
+{
+ uint64_t callbackID = generatePluginProcessCallbackID();
+ m_pendingDeleteWebsiteDataCallbacks.set(callbackID, WTFMove(completionHandler));
+
+ if (state() == State::Launching) {
+ m_pendingDeleteWebsiteDataRequests.append({ modifiedSince, callbackID });
+ return;
+ }
+
+ m_connection->send(Messages::PluginProcess::DeleteWebsiteData(modifiedSince, callbackID), 0);
+}
+
+void PluginProcessProxy::deleteWebsiteDataForHostNames(const Vector<String>& hostNames, CompletionHandler<void ()>&& completionHandler)
+{
+ uint64_t callbackID = generatePluginProcessCallbackID();
+ m_pendingDeleteWebsiteDataForHostNamesCallbacks.set(callbackID, WTFMove(completionHandler));
+
+ if (state() == State::Launching) {
+ m_pendingDeleteWebsiteDataForHostNamesRequests.append({ hostNames, callbackID });
+ return;
+ }
+
+ m_connection->send(Messages::PluginProcess::DeleteWebsiteDataForHostNames(hostNames, callbackID), 0);
+}
+
+#if OS(LINUX)
+void PluginProcessProxy::sendMemoryPressureEvent(bool isCritical)
+{
+ if (state() == State::Launching)
+ return;
+
+ m_connection->send(Messages::AuxiliaryProcess::DidReceiveMemoryPressureEvent(isCritical), 0);
+}
+#endif
+
+void PluginProcessProxy::pluginProcessCrashedOrFailedToLaunch()
+{
+ // The plug-in process must have crashed or exited, send any pending sync replies we might have.
+ while (!m_pendingConnectionReplies.isEmpty()) {
+ auto reply = m_pendingConnectionReplies.takeFirst();
+
+#if USE(UNIX_DOMAIN_SOCKETS)
+ reply(IPC::Attachment(), false);
+#elif OS(DARWIN)
+ reply(IPC::Attachment(0, MACH_MSG_TYPE_MOVE_SEND), false);
+#else
+ notImplemented();
+#endif
+ }
+
+ m_pendingFetchWebsiteDataRequests.clear();
+ for (auto&& callback : m_pendingFetchWebsiteDataCallbacks.values())
+ callback({ });
+ m_pendingFetchWebsiteDataCallbacks.clear();
+
+ m_pendingDeleteWebsiteDataRequests.clear();
+ for (auto&& callback : m_pendingDeleteWebsiteDataCallbacks.values())
+ callback();
+ m_pendingDeleteWebsiteDataRequests.clear();
+
+ m_pendingDeleteWebsiteDataForHostNamesRequests.clear();
+ for (auto&& callback : m_pendingDeleteWebsiteDataForHostNamesCallbacks.values())
+ callback();
+ m_pendingDeleteWebsiteDataForHostNamesCallbacks.clear();
+
+ // Tell the plug-in process manager to forget about this plug-in process proxy. This may cause us to be deleted.
+ m_pluginProcessManager->removePluginProcessProxy(this);
+}
+
+void PluginProcessProxy::didClose(IPC::Connection&)
+{
+#if PLATFORM(COCOA)
+ if (m_modalWindowIsShowing)
+ endModal();
+
+ if (m_fullscreenWindowIsShowing)
+ exitFullscreen();
+#endif
+
+ for (auto& processPool : WebProcessPool::allProcessPools())
+ processPool->sendToAllProcesses(Messages::PluginProcessConnectionManager::PluginProcessCrashed(m_pluginProcessToken));
+
+ // This will cause us to be deleted.
+ pluginProcessCrashedOrFailedToLaunch();
+}
+
+void PluginProcessProxy::didReceiveInvalidMessage(IPC::Connection& connection, IPC::MessageName messageName)
+{
+ logInvalidMessage(connection, messageName);
+ terminate();
+}
+
+void PluginProcessProxy::didFinishLaunching(ProcessLauncher*, IPC::Connection::Identifier connectionIdentifier)
+{
+ ASSERT(!m_connection);
+
+ if (!IPC::Connection::identifierIsValid(connectionIdentifier)) {
+ pluginProcessCrashedOrFailedToLaunch();
+ return;
+ }
+
+ m_connection = IPC::Connection::createServerConnection(connectionIdentifier, *this);
+
+ m_connection->open();
+
+ PluginProcessCreationParameters parameters;
+ parameters.minimumLifetime = minimumLifetime;
+ parameters.terminationTimeout = shutdownTimeout;
+
+ platformInitializePluginProcess(parameters);
+
+ // Initialize the plug-in host process.
+ m_connection->send(Messages::PluginProcess::InitializePluginProcess(parameters), 0);
+
+#if PLATFORM(COCOA)
+ m_connection->send(Messages::PluginProcess::SetQOS(pluginProcessLatencyQOS(), pluginProcessThroughputQOS()), 0);
+#endif
+
+ for (auto callbackID : m_pendingFetchWebsiteDataRequests)
+ m_connection->send(Messages::PluginProcess::GetSitesWithData(callbackID), 0);
+ m_pendingFetchWebsiteDataRequests.clear();
+
+ for (auto& request : m_pendingDeleteWebsiteDataRequests)
+ m_connection->send(Messages::PluginProcess::DeleteWebsiteData(request.modifiedSince, request.callbackID), 0);
+ m_pendingDeleteWebsiteDataRequests.clear();
+
+ for (auto& request : m_pendingDeleteWebsiteDataForHostNamesRequests)
+ m_connection->send(Messages::PluginProcess::DeleteWebsiteDataForHostNames(request.hostNames, request.callbackID), 0);
+ m_pendingDeleteWebsiteDataForHostNamesRequests.clear();
+
+ for (unsigned i = 0; i < m_numPendingConnectionRequests; ++i)
+ m_connection->send(Messages::PluginProcess::CreateWebProcessConnection(), 0);
+
+ m_numPendingConnectionRequests = 0;
+
+#if PLATFORM(COCOA)
+ if (!PluginProcessManager::singleton().processSuppressionDisabled())
+ setProcessSuppressionEnabled(true);
+#endif
+}
+
+void PluginProcessProxy::didCreateWebProcessConnection(const IPC::Attachment& connectionIdentifier, bool supportsAsynchronousPluginInitialization)
+{
+ ASSERT(!m_pendingConnectionReplies.isEmpty());
+
+ // Grab the first pending connection reply.
+ auto reply = m_pendingConnectionReplies.takeFirst();
+
+#if USE(UNIX_DOMAIN_SOCKETS)
+ reply(connectionIdentifier, supportsAsynchronousPluginInitialization);
+#elif OS(DARWIN)
+ reply(IPC::Attachment(connectionIdentifier.port(), MACH_MSG_TYPE_MOVE_SEND), supportsAsynchronousPluginInitialization);
+#else
+ notImplemented();
+#endif
+}
+
+void PluginProcessProxy::didGetSitesWithData(const Vector<String>& sites, uint64_t callbackID)
+{
+ auto callback = m_pendingFetchWebsiteDataCallbacks.take(callbackID);
+ callback(sites);
+}
+
+void PluginProcessProxy::didDeleteWebsiteData(uint64_t callbackID)
+{
+ auto callback = m_pendingDeleteWebsiteDataCallbacks.take(callbackID);
+ callback();
+}
+
+void PluginProcessProxy::didDeleteWebsiteDataForHostNames(uint64_t callbackID)
+{
+ auto callback = m_pendingDeleteWebsiteDataForHostNamesCallbacks.take(callbackID);
+ callback();
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/PluginProcessProxy.h webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/PluginProcessProxy.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/PluginProcessProxy.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/PluginProcessProxy.h 2022-08-26 14:18:15.001022440 -0500
@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+ */
+
+#pragma once
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "AuxiliaryProcessProxy.h"
+#include "Connection.h"
+#include "PluginModuleInfo.h"
+#include "PluginProcess.h"
+#include "PluginProcessAttributes.h"
+#include "ProcessLauncher.h"
+#include "ProcessThrottler.h"
+#include "ProcessThrottlerClient.h"
+#include "WebProcessProxyMessagesReplies.h"
+#include <wtf/Deque.h>
+
+#if PLATFORM(COCOA)
+#include <wtf/RetainPtr.h>
+OBJC_CLASS NSObject;
+OBJC_CLASS WKPlaceholderModalWindow;
+#endif
+
+namespace WebKit {
+
+class PluginProcessManager;
+class WebProcessProxy;
+struct PluginProcessCreationParameters;
+
+#if PLUGIN_ARCHITECTURE(UNIX)
+struct RawPluginMetaData {
+ String name;
+ String description;
+ String mimeDescription;
+};
+#endif
+
+#if PLATFORM(COCOA)
+int pluginProcessLatencyQOS();
+int pluginProcessThroughputQOS();
+#endif
+
+class PluginProcessProxy final : public AuxiliaryProcessProxy, private ProcessThrottlerClient {
+public:
+ static Ref<PluginProcessProxy> create(PluginProcessManager*, const PluginProcessAttributes&, uint64_t pluginProcessToken);
+ ~PluginProcessProxy();
+
+ const PluginProcessAttributes& pluginProcessAttributes() const { return m_pluginProcessAttributes; }
+ uint64_t pluginProcessToken() const { return m_pluginProcessToken; }
+
+ // Asks the plug-in process to create a new connection to a web process. The connection identifier will be
+ // encoded in the given argument encoder and sent back to the connection of the given web process.
+ void getPluginProcessConnection(Messages::WebProcessProxy::GetPluginProcessConnectionDelayedReply&&);
+
+ void fetchWebsiteData(CompletionHandler<void (Vector<String>)>&&);
+ void deleteWebsiteData(WallTime modifiedSince, CompletionHandler<void ()>&&);
+ void deleteWebsiteDataForHostNames(const Vector<String>& hostNames, CompletionHandler<void ()>&&);
+
+#if OS(LINUX)
+ void sendMemoryPressureEvent(bool isCritical);
+#endif
+
+ bool isValid() const { return m_connection; }
+
+#if PLUGIN_ARCHITECTURE(UNIX)
+ static bool scanPlugin(const String& pluginPath, RawPluginMetaData& result);
+#endif
+
+ ProcessThrottler& throttler() final { return m_throttler; }
+
+private:
+ PluginProcessProxy(PluginProcessManager*, const PluginProcessAttributes&, uint64_t pluginProcessToken);
+
+ // AuxiliaryProcessProxy
+ ASCIILiteral processName() const final { return "Plugin"_s; }
+
+ void getLaunchOptions(ProcessLauncher::LaunchOptions&) override;
+ void platformGetLaunchOptionsWithAttributes(ProcessLauncher::LaunchOptions&, const PluginProcessAttributes&);
+ void processWillShutDown(IPC::Connection&) override;
+
+ void pluginProcessCrashedOrFailedToLaunch();
+
+ // ProcessThrottlerClient
+ void sendPrepareToSuspend(IsSuspensionImminent, CompletionHandler<void()>&& completionHandler) final { completionHandler(); }
+ void sendProcessDidResume() final { }
+ ASCIILiteral clientName() const final { return "PluginProcess"_s; }
+
+ // IPC::Connection::Client
+ void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
+ bool didReceiveSyncMessage(IPC::Connection&, IPC::Decoder&, UniqueRef<IPC::Encoder>&) override;
+
+ void didClose(IPC::Connection&) override;
+ void didReceiveInvalidMessage(IPC::Connection&, IPC::MessageName) override;
+
+ // ProcessLauncher::Client
+ void didFinishLaunching(ProcessLauncher*, IPC::Connection::Identifier) override;
+
+ // Message handlers
+ void didCreateWebProcessConnection(const IPC::Attachment&, bool supportsAsynchronousPluginInitialization);
+ void didGetSitesWithData(const Vector<String>& sites, uint64_t callbackID);
+ void didDeleteWebsiteData(uint64_t callbackID);
+ void didDeleteWebsiteDataForHostNames(uint64_t callbackID);
+
+#if PLATFORM(COCOA)
+ bool getPluginProcessSerialNumber(ProcessSerialNumber&);
+ void makePluginProcessTheFrontProcess();
+ void makeUIProcessTheFrontProcess();
+
+ void setFullscreenWindowIsShowing(bool);
+ void enterFullscreen();
+ void exitFullscreen();
+
+ void setModalWindowIsShowing(bool);
+ void beginModal();
+ void endModal();
+
+ void applicationDidBecomeActive();
+ void launchProcess(const String& launchPath, const Vector<String>& arguments, CompletionHandler<void(bool)>&&);
+ void launchApplicationAtURL(const String& urlString, const Vector<String>& arguments, CompletionHandler<void(bool)>&&);
+ void openURL(const String& url, CompletionHandler<void(bool result, int32_t status, String launchedURLString)>&&);
+ void openFile(const String& fullPath, CompletionHandler<void(bool)>&&);
+#endif
+
+ void platformInitializePluginProcess(PluginProcessCreationParameters& parameters);
+
+ ProcessThrottler m_throttler;
+
+ // The plug-in host process manager.
+ PluginProcessManager* m_pluginProcessManager;
+
+ PluginProcessAttributes m_pluginProcessAttributes;
+ uint64_t m_pluginProcessToken;
+
+ // The connection to the plug-in host process.
+ RefPtr<IPC::Connection> m_connection;
+
+ Deque<Messages::WebProcessProxy::GetPluginProcessConnectionDelayedReply> m_pendingConnectionReplies;
+
+ Vector<uint64_t> m_pendingFetchWebsiteDataRequests;
+ HashMap<uint64_t, CompletionHandler<void (Vector<String>)>> m_pendingFetchWebsiteDataCallbacks;
+
+ struct DeleteWebsiteDataRequest {
+ WallTime modifiedSince;
+ uint64_t callbackID;
+ };
+ Vector<DeleteWebsiteDataRequest> m_pendingDeleteWebsiteDataRequests;
+ HashMap<uint64_t, CompletionHandler<void ()>> m_pendingDeleteWebsiteDataCallbacks;
+
+ struct DeleteWebsiteDataForHostNamesRequest {
+ Vector<String> hostNames;
+ uint64_t callbackID;
+ };
+ Vector<DeleteWebsiteDataForHostNamesRequest> m_pendingDeleteWebsiteDataForHostNamesRequests;
+ HashMap<uint64_t, CompletionHandler<void ()>> m_pendingDeleteWebsiteDataForHostNamesCallbacks;
+
+ // If createPluginConnection is called while the process is still launching we'll keep count of it and send a bunch of requests
+ // when the process finishes launching.
+ unsigned m_numPendingConnectionRequests;
+
+#if PLATFORM(COCOA)
+ RetainPtr<NSObject> m_activationObserver;
+ RetainPtr<WKPlaceholderModalWindow> m_placeholderWindow;
+ bool m_modalWindowIsShowing;
+ bool m_fullscreenWindowIsShowing;
+ unsigned m_preFullscreenAppPresentationOptions;
+#endif
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/PluginProcessProxy.messages.in webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/PluginProcessProxy.messages.in
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/PluginProcessProxy.messages.in 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/PluginProcessProxy.messages.in 2022-08-26 14:18:15.001022440 -0500
@@ -0,0 +1,50 @@
+# Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+messages -> PluginProcessProxy {
+ DidCreateWebProcessConnection(IPC::Attachment connectionIdentifier, bool supportsAsynchronousPluginInitialization)
+
+ DidGetSitesWithData(Vector<String> sites, uint64_t callbackID)
+ DidDeleteWebsiteData(uint64_t callbackID)
+ DidDeleteWebsiteDataForHostNames(uint64_t callbackID)
+
+#if PLATFORM(COCOA)
+ SetModalWindowIsShowing(bool modalWindowIsShowing)
+ SetFullscreenWindowIsShowing(bool fullscreenWindowIsShowing)
+
+ # Returns true if the UI process launched the process.
+ LaunchProcess(String launchPath, Vector<String> arguments) -> (bool result) Synchronous
+
+ # Returns true if the UI process launched the application.
+ LaunchApplicationAtURL(String url, Vector<String> arguments) -> (bool result) Synchronous
+
+ # Returns true if the UI process did open the URL.
+ OpenURL(String urlString) -> (bool result, int32_t status, String launchedURLString) Synchronous
+
+ # Returns true if the UI process did open the file.
+ OpenFile(String fullPath) -> (bool result) Synchronous
+#endif
+}
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/unix/PluginInfoStoreUnix.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/unix/PluginInfoStoreUnix.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/unix/PluginInfoStoreUnix.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/unix/PluginInfoStoreUnix.cpp 2022-08-26 14:18:15.001022440 -0500
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+ */
+
+// Note: this file is only for UNIX. On other platforms we can reuse the native implementation.
+
+#include "config.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "PluginInfoStore.h"
+
+#include "NetscapePluginModule.h"
+#include "PluginSearchPath.h"
+#include "ProcessExecutablePath.h"
+#include <WebCore/PlatformDisplay.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <wtf/FileSystem.h>
+
+#if PLATFORM(GTK)
+#include "PluginInfoCache.h"
+#endif
+#include <fnmatch.h>
+
+namespace WebKit {
+using namespace WebCore;
+
+Vector<String> PluginInfoStore::pluginsDirectories()
+{
+ return WebKit::pluginsDirectories();
+}
+
+Vector<String> PluginInfoStore::pluginPathsInDirectory(const String& directory)
+{
+ Vector<String> result;
+ char normalizedPath[PATH_MAX];
+ CString cpath = FileSystem::fileSystemRepresentation(directory);
+ for (const auto& path : FileSystem::listDirectory(directory)) {
+ CString filename = FileSystem::fileSystemRepresentation(path);
+ if (fnmatch(filename.data(), "*.so", 0))
+ continue;
+ char filePath[PATH_MAX];
+ if (static_cast<int>(sizeof(filePath) - 1) < snprintf(filePath, sizeof(filePath), "%s/%s", cpath.data(), filename.data()))
+ continue; // buffer overflow
+ if (realpath(filePath, normalizedPath))
+ result.append(FileSystem::stringFromFileSystemRepresentation(normalizedPath));
+ }
+
+ return result;
+}
+
+Vector<String> PluginInfoStore::individualPluginPaths()
+{
+ return Vector<String>();
+}
+
+bool PluginInfoStore::getPluginInfo(const String& pluginPath, PluginModuleInfo& plugin)
+{
+#if PLATFORM(GTK)
+ if (PluginInfoCache::singleton().getPluginInfo(pluginPath, plugin))
+ return true;
+
+ if (NetscapePluginModule::getPluginInfo(pluginPath, plugin)) {
+ PluginInfoCache::singleton().updatePluginInfo(pluginPath, plugin);
+ return true;
+ }
+ return false;
+#else
+ return NetscapePluginModule::getPluginInfo(pluginPath, plugin);
+#endif
+}
+
+bool PluginInfoStore::shouldUsePlugin(Vector<PluginModuleInfo>& /*alreadyLoadedPlugins*/, const PluginModuleInfo& /*plugin*/)
+{
+ // We do not do any black-listing presently.
+ return true;
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/unix/PluginProcessProxyUnix.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/unix/PluginProcessProxyUnix.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/Plugins/unix/PluginProcessProxyUnix.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/Plugins/unix/PluginProcessProxyUnix.cpp 2022-08-26 14:18:15.001022440 -0500
@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2011, 2014 Igalia S.L.
+ * Copyright (C) 2011 Apple Inc.
+ * Copyright (C) 2012 Samsung Electronics
+ *
+ * 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT OWNER OR 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 "config.h"
+#include "PluginProcessProxy.h"
+
+#if ENABLE(PLUGIN_PROCESS)
+
+#include "PluginProcessCreationParameters.h"
+#include "ProcessExecutablePath.h"
+#include <WebCore/PlatformDisplay.h>
+#include <sys/wait.h>
+#include <wtf/FileSystem.h>
+#include <wtf/text/CString.h>
+#include <wtf/text/WTFString.h>
+
+#if PLATFORM(GTK)
+#include <glib.h>
+#include <wtf/glib/GUniquePtr.h>
+#endif
+
+#if PLATFORM(GTK)
+#include "Module.h"
+#endif
+
+namespace WebKit {
+using namespace WebCore;
+
+void PluginProcessProxy::platformGetLaunchOptionsWithAttributes(ProcessLauncher::LaunchOptions& launchOptions, const PluginProcessAttributes& pluginProcessAttributes)
+{
+ launchOptions.processType = ProcessLauncher::ProcessType::Plugin;
+ launchOptions.extraInitializationData.add("plugin-path", pluginProcessAttributes.moduleInfo.path);
+}
+
+void PluginProcessProxy::platformInitializePluginProcess(PluginProcessCreationParameters&)
+{
+}
+
+#if PLATFORM(GTK)
+static bool pluginRequiresGtk2(const String& pluginPath)
+{
+ std::unique_ptr<Module> module = makeUnique<Module>(pluginPath);
+ if (!module->load())
+ return false;
+ return module->functionPointer<gpointer>("gtk_object_get_type");
+}
+#endif
+
+#if PLUGIN_ARCHITECTURE(UNIX)
+bool PluginProcessProxy::scanPlugin(const String& pluginPath, RawPluginMetaData& result)
+{
+ String pluginProcessPath = executablePathOfPluginProcess();
+
+#if PLATFORM(GTK)
+ if (pluginRequiresGtk2(pluginPath))
+ return false;
+#endif
+
+ CString binaryPath = FileSystem::fileSystemRepresentation(pluginProcessPath);
+ CString pluginPathCString = FileSystem::fileSystemRepresentation(pluginPath);
+ char* argv[4];
+ argv[0] = const_cast<char*>(binaryPath.data());
+ argv[1] = const_cast<char*>("-scanPlugin");
+ argv[2] = const_cast<char*>(pluginPathCString.data());
+ argv[3] = nullptr;
+
+ // If the disposition of SIGCLD signal is set to SIG_IGN (default)
+ // then the signal will be ignored and g_spawn_sync() will not be
+ // able to return the status.
+ // As a consequence, we make sure that the disposition is set to
+ // SIG_DFL before calling g_spawn_sync().
+#if defined(SIGCLD)
+ struct sigaction action;
+ sigaction(SIGCLD, 0, &action);
+ if (action.sa_handler == SIG_IGN) {
+ action.sa_handler = SIG_DFL;
+ sigaction(SIGCLD, &action, 0);
+ }
+#endif
+
+ int status;
+ GUniqueOutPtr<char> stdOut;
+ GUniqueOutPtr<GError> error;
+ if (!g_spawn_sync(nullptr, argv, nullptr, G_SPAWN_STDERR_TO_DEV_NULL, nullptr, nullptr, &stdOut.outPtr(), nullptr, &status, &error.outPtr())) {
+ WTFLogAlways("Failed to launch %s: %s", argv[0], error->message);
+ return false;
+ }
+
+ if (!WIFEXITED(status) || WEXITSTATUS(status) != EXIT_SUCCESS) {
+ WTFLogAlways("Error scanning plugin %s, %s returned %d exit status", argv[2], argv[0], status);
+ return false;
+ }
+
+ if (!stdOut) {
+ WTFLogAlways("Error scanning plugin %s, %s didn't write any output to stdout", argv[2], argv[0]);
+ return false;
+ }
+
+ Vector<String> lines = String::fromUTF8(stdOut.get()).splitAllowingEmptyEntries('\n');
+
+ if (lines.size() < 3) {
+ WTFLogAlways("Error scanning plugin %s, too few lines of output provided", argv[2]);
+ return false;
+ }
+
+ result.name.swap(lines[0]);
+ result.description.swap(lines[1]);
+ result.mimeDescription.swap(lines[2]);
+ return !result.mimeDescription.isEmpty();
+}
+#endif // PLUGIN_ARCHITECTURE(UNIX)
+
+} // namespace WebKit
+
+#endif // ENABLE(PLUGIN_PROCESS)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebPageProxy.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/WebPageProxy.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebPageProxy.cpp 2022-08-24 04:51:35.411875700 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/WebPageProxy.cpp 2022-08-26 14:18:15.001022440 -0500
@@ -81,6 +81,8 @@
#include "NotificationPermissionRequest.h"
#include "NotificationPermissionRequestManager.h"
#include "PageClient.h"
+#include "PluginInformation.h"
+#include "PluginProcessManager.h"
#include "PrintInfo.h"
#include "ProcessThrottler.h"
#include "ProvisionalPageProxy.h"
@@ -1905,6 +1907,13 @@ bool WebPageProxy::canShowMIMEType(const
if (MIMETypeRegistry::canShowMIMEType(mimeType))
return true;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ String newMimeType = mimeType;
+ PluginModuleInfo plugin = m_process->processPool().pluginInfoStore().findPlugin(newMimeType, URL());
+ if (!plugin.path.isNull() && m_preferences->pluginsEnabled())
+ return true;
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
#if PLATFORM(COCOA)
// On Mac, we can show PDFs.
if (MIMETypeRegistry::isPDFOrPostScriptMIMEType(mimeType) && !WebProcessPool::omitPDFSupport())
@@ -3026,6 +3035,64 @@ WebPreferencesStore WebPageProxy::prefer
return m_preferences->store();
}
+#if ENABLE(NETSCAPE_PLUGIN_API)
+void WebPageProxy::findPlugin(const String& mimeType, const String& urlString, const String& frameURLString, const String& pageURLString, bool allowOnlyApplicationPlugins, Messages::WebPageProxy::FindPlugin::DelayedReply&& reply)
+{
+ PageClientProtector protector(pageClient());
+
+ MESSAGE_CHECK_URL(m_process, urlString);
+
+ URL pluginURL = URL { URL(), urlString };
+ String newMimeType = mimeType.convertToASCIILowercase();
+
+ PluginData::AllowedPluginTypes allowedPluginTypes = allowOnlyApplicationPlugins ? PluginData::OnlyApplicationPlugins : PluginData::AllPlugins;
+
+ URL pageURL = URL { URL(), pageURLString };
+ if (!m_process->processPool().pluginInfoStore().isSupportedPlugin(mimeType, pluginURL, frameURLString, pageURL)) {
+ reply(0, newMimeType, PluginModuleLoadNormally, { }, true);
+ return;
+ }
+
+ PluginModuleInfo plugin = m_process->processPool().pluginInfoStore().findPlugin(newMimeType, pluginURL, allowedPluginTypes);
+ if (!plugin.path) {
+ reply(0, newMimeType, PluginModuleLoadNormally, { }, false);
+ return;
+ }
+
+ uint32_t pluginLoadPolicy = PluginInfoStore::defaultLoadPolicyForPlugin(plugin);
+
+#if PLATFORM(COCOA)
+ auto pluginInformation = createPluginInformationDictionary(plugin, frameURLString, String(), pageURLString, String(), String());
+#endif
+
+ auto findPluginCompletion = [reply = WTFMove(reply), newMimeType = WTFMove(newMimeType), plugin = WTFMove(plugin)] (uint32_t pluginLoadPolicy, const String& unavailabilityDescription) mutable {
+ PluginProcessSandboxPolicy pluginProcessSandboxPolicy = PluginProcessSandboxPolicy::Normal;
+ switch (pluginLoadPolicy) {
+ case PluginModuleLoadNormally:
+ pluginProcessSandboxPolicy = PluginProcessSandboxPolicy::Normal;
+ break;
+ case PluginModuleLoadUnsandboxed:
+ pluginProcessSandboxPolicy = PluginProcessSandboxPolicy::Unsandboxed;
+ break;
+
+ case PluginModuleBlockedForSecurity:
+ case PluginModuleBlockedForCompatibility:
+ reply(0, newMimeType, pluginLoadPolicy, unavailabilityDescription, false);
+ return;
+ }
+
+ reply(PluginProcessManager::singleton().pluginProcessToken(plugin, pluginProcessSandboxPolicy), newMimeType, pluginLoadPolicy, unavailabilityDescription, false);
+ };
+
+#if PLATFORM(COCOA)
+ m_navigationClient->decidePolicyForPluginLoad(*this, static_cast<PluginModuleLoadPolicy>(pluginLoadPolicy), pluginInformation.get(), WTFMove(findPluginCompletion));
+#else
+ findPluginCompletion(pluginLoadPolicy, { });
+#endif
+}
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
#if ENABLE(TOUCH_EVENTS)
static TrackingType mergeTrackingTypes(TrackingType a, TrackingType b)
@@ -6112,6 +6179,39 @@ void WebPageProxy::mouseDidMoveOverEleme
setToolTip(hitTestResultData.toolTipText);
}
+#if ENABLE(NETSCAPE_PLUGIN_API)
+void WebPageProxy::unavailablePluginButtonClicked(uint32_t opaquePluginUnavailabilityReason, const String& mimeType, const String& pluginURLString, const String& pluginspageAttributeURLString, const String& frameURLString, const String& pageURLString)
+{
+ MESSAGE_CHECK_URL(m_process, pluginURLString);
+ MESSAGE_CHECK_URL(m_process, pluginspageAttributeURLString);
+ MESSAGE_CHECK_URL(m_process, frameURLString);
+ MESSAGE_CHECK_URL(m_process, pageURLString);
+
+ String newMimeType = mimeType;
+ PluginModuleInfo plugin = m_process->processPool().pluginInfoStore().findPlugin(newMimeType, URL(URL(), pluginURLString));
+ auto pluginInformation = createPluginInformationDictionary(plugin, frameURLString, mimeType, pageURLString, pluginspageAttributeURLString, pluginURLString);
+
+ WKPluginUnavailabilityReason pluginUnavailabilityReason = kWKPluginUnavailabilityReasonPluginMissing;
+ switch (static_cast<RenderEmbeddedObject::PluginUnavailabilityReason>(opaquePluginUnavailabilityReason)) {
+ case RenderEmbeddedObject::PluginMissing:
+ pluginUnavailabilityReason = kWKPluginUnavailabilityReasonPluginMissing;
+ break;
+ case RenderEmbeddedObject::InsecurePluginVersion:
+ pluginUnavailabilityReason = kWKPluginUnavailabilityReasonInsecurePluginVersion;
+ break;
+ case RenderEmbeddedObject::PluginCrashed:
+ pluginUnavailabilityReason = kWKPluginUnavailabilityReasonPluginCrashed;
+ break;
+ case RenderEmbeddedObject::PluginBlockedByContentSecurityPolicy:
+ case RenderEmbeddedObject::UnsupportedPlugin:
+ case RenderEmbeddedObject::PluginTooSmall:
+ ASSERT_NOT_REACHED();
+ }
+
+ m_uiClient->unavailablePluginButtonClicked(*this, pluginUnavailabilityReason, pluginInformation.get());
+}
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
#if ENABLE(WEBGL)
void WebPageProxy::webGLPolicyForURL(URL&& url, Messages::WebPageProxy::WebGLPolicyForURL::DelayedReply&& reply)
{
@@ -8954,6 +9054,22 @@ Color WebPageProxy::platformUnderPageBac
#endif // !PLATFORM(COCOA)
+#if ENABLE(NETSCAPE_PLUGIN_API)
+void WebPageProxy::didFailToInitializePlugin(const String& mimeType, const String& frameURLString, const String& pageURLString)
+{
+ m_navigationClient->didFailToInitializePlugIn(*this, createPluginInformationDictionary(mimeType, frameURLString, pageURLString).get());
+}
+
+void WebPageProxy::didBlockInsecurePluginVersion(const String& mimeType, const String& pluginURLString, const String& frameURLString, const String& pageURLString, bool replacementObscured)
+{
+ String newMimeType = mimeType;
+ PluginModuleInfo plugin = m_process->processPool().pluginInfoStore().findPlugin(newMimeType, URL(URL(), pluginURLString));
+ auto pluginInformation = createPluginInformationDictionary(plugin, frameURLString, mimeType, pageURLString, String(), String(), replacementObscured);
+
+ m_navigationClient->didBlockInsecurePluginVersion(*this, pluginInformation.get());
+}
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
bool WebPageProxy::willHandleHorizontalScrollEvents() const
{
return !m_canShortCircuitHorizontalWheelEvents;
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebPageProxy.h webkitgtk-2.36.7/Source/WebKit/UIProcess/WebPageProxy.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebPageProxy.h 2022-07-01 06:23:00.615084000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/WebPageProxy.h 2022-08-26 14:18:15.001022440 -0500
@@ -47,6 +47,7 @@
#include "PDFPluginIdentifier.h"
#include "PageLoadState.h"
#include "PasteboardAccessIntent.h"
+#include "PluginProcessAttributes.h"
#include "PolicyDecision.h"
#include "ProcessTerminationReason.h"
#include "ProcessThrottler.h"
@@ -962,6 +963,8 @@ public:
#if PLATFORM(COCOA)
void windowAndViewFramesChanged(const WebCore::FloatRect& viewFrameInWindowCoordinates, const WebCore::FloatPoint& accessibilityViewCoordinates);
void setMainFrameIsScrollable(bool);
+
+ void sendComplexTextInputToPlugin(uint64_t pluginComplexTextInputIdentifier, const String& textInput);
bool shouldDelayWindowOrderingForEvent(const WebMouseEvent&);
void setRemoteLayerTreeRootNode(RemoteLayerTreeNode*);
@@ -2193,6 +2196,9 @@ private:
void setStatusText(const String&);
void mouseDidMoveOverElement(WebHitTestResultData&&, uint32_t modifiers, UserData&&);
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ void unavailablePluginButtonClicked(uint32_t opaquePluginUnavailabilityReason, const String& mimeType, const String& pluginURLString, const String& pluginsPageURLString, const String& frameURLString, const String& pageURLString);
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
#if ENABLE(WEBGL)
void webGLPolicyForURL(URL&&, Messages::WebPageProxy::WebGLPolicyForURLDelayedReply&&);
void resolveWebGLPolicyForURL(URL&&, Messages::WebPageProxy::ResolveWebGLPolicyForURLDelayedReply&&);
@@ -2251,6 +2257,10 @@ private:
void pageExtendedBackgroundColorDidChange(const WebCore::Color&);
void sampledPageTopColorChanged(const WebCore::Color&);
WebCore::Color platformUnderPageBackgroundColor() const;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ void didFailToInitializePlugin(const String& mimeType, const String& frameURLString, const String& pageURLString);
+ void didBlockInsecurePluginVersion(const String& mimeType, const String& pluginURLString, const String& frameURLString, const String& pageURLString, bool replacementObscured);
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
void setCanShortCircuitHorizontalWheelEvents(bool canShortCircuitHorizontalWheelEvents) { m_canShortCircuitHorizontalWheelEvents = canShortCircuitHorizontalWheelEvents; }
enum class ProcessLaunchReason {
@@ -2398,6 +2408,11 @@ private:
void didFinishLoadingDataForCustomContentProvider(const String& suggestedFilename, const IPC::DataReference&);
+#if PLATFORM(COCOA)
+ void pluginFocusOrWindowFocusChanged(uint64_t pluginComplexTextInputIdentifier, bool pluginHasFocusAndWindowHasFocus);
+ void setPluginComplexTextInputState(uint64_t pluginComplexTextInputIdentifier, uint64_t complexTextInputState);
+#endif
+
#if USE(AUTOMATIC_TEXT_REPLACEMENT)
void toggleSmartInsertDelete();
void toggleAutomaticQuoteSubstitution();
@@ -2457,6 +2472,12 @@ private:
void setRenderTreeSize(uint64_t treeSize) { m_renderTreeSize = treeSize; }
+#if PLATFORM(X11) && ENABLE(NETSCAPE_PLUGIN_API)
+ void createPluginContainer(CompletionHandler<void(uint64_t)>&&);
+ void windowedPluginGeometryDidChange(const WebCore::IntRect& frameRect, const WebCore::IntRect& clipRect, uint64_t windowID);
+ void windowedPluginVisibilityDidChange(bool isVisible, uint64_t windowID);
+#endif
+
void sendWheelEvent(const WebWheelEvent&);
WebWheelEventCoalescer& wheelEventCoalescer();
@@ -2472,6 +2493,10 @@ private:
WebCore::TrackingType touchEventTrackingType(const WebTouchEvent&) const;
#endif
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ void findPlugin(const String& mimeType, const String& urlString, const String& frameURLString, const String& pageURLString, bool allowOnlyApplicationPlugins, Messages::WebPageProxy::FindPluginDelayedReply&&);
+#endif
+
#if USE(QUICK_LOOK)
void didStartLoadForQuickLookDocumentInMainFrame(const String& fileName, const String& uti);
void didFinishLoadForQuickLookDocumentInMainFrame(const ShareableResource::Handle&);
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebPageProxy.messages.in webkitgtk-2.36.7/Source/WebKit/UIProcess/WebPageProxy.messages.in
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebPageProxy.messages.in 2022-06-30 04:49:37.896179200 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/WebPageProxy.messages.in 2022-08-26 14:18:15.001022440 -0500
@@ -30,6 +30,9 @@ messages -> WebPageProxy {
RunJavaScriptPrompt(WebCore::FrameIdentifier frameID, struct WebKit::FrameInfoData frameInfo, String message, String defaultValue) -> (String result) Synchronous
MouseDidMoveOverElement(struct WebKit::WebHitTestResultData hitTestResultData, uint32_t modifiers, WebKit::UserData userData)
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ UnavailablePluginButtonClicked(uint32_t pluginUnavailabilityReason, String mimeType, String pluginURLString, String pluginspageAttributeURLString, String frameURLString, String pageURLString)
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
#if ENABLE(WEBGL)
WebGLPolicyForURL(URL url) -> (enum:uint8_t WebCore::WebGLLoadPolicy loadPolicy) Synchronous
ResolveWebGLPolicyForURL(URL url) -> (enum:uint8_t WebCore::WebGLLoadPolicy loadPolicy) Synchronous
@@ -78,6 +81,10 @@ messages -> WebPageProxy {
ThemeColorChanged(WebCore::Color themeColor)
PageExtendedBackgroundColorDidChange(WebCore::Color backgroundColor)
SampledPageTopColorChanged(WebCore::Color sampledPageTopColor)
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ DidFailToInitializePlugin(String mimeType, String frameURLString, String pageURLString)
+ DidBlockInsecurePluginVersion(String mimeType, String pluginURLString, String frameURLString, String pageURLString, bool replacementObscured)
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
SetCanShortCircuitHorizontalWheelEvents(bool canShortCircuitHorizontalWheelEvents)
DidChangeContentSize(WebCore::IntSize newSize)
@@ -327,6 +334,10 @@ messages -> WebPageProxy {
# Remote accessibility messages
RegisterWebProcessAccessibilityToken(IPC::DataReference data)
+ # Plug-in complex text input support messages
+ PluginFocusOrWindowFocusChanged(uint64_t pluginComplexTextInputIdentifier, bool pluginHasFocusAndWindowHasFocus)
+ SetPluginComplexTextInputState(uint64_t pluginComplexTextInputIdentifier, uint64_t complexTextInputState)
+
# Speech messages
GetIsSpeaking() -> (bool isSpeaking) Synchronous
Speak(String string)
@@ -377,6 +388,13 @@ messages -> WebPageProxy {
DictationAlternatives(WebCore::DictationContext dictationContext) -> (Vector<String> alternatives) Synchronous
#endif
+#if PLATFORM(X11) && ENABLE(NETSCAPE_PLUGIN_API)
+ # X11 windowed plugin messages
+ CreatePluginContainer() -> (uint64_t windowID) Synchronous
+ WindowedPluginGeometryDidChange(WebCore::IntRect frameRect, WebCore::IntRect clipRect, uint64_t windowID)
+ WindowedPluginVisibilityDidChange(bool isVisible, uint64_t windowID)
+#endif
+
#if PLATFORM(IOS_FAMILY)
CouldNotRestorePageState()
RestorePageState(std::optional<WebCore::FloatPoint> scrollPosition, WebCore::FloatPoint scrollOrigin, WebCore::RectEdges<float> obscuredInsetsOnSave, double scale)
@@ -424,6 +442,10 @@ messages -> WebPageProxy {
ShowPDFContextMenu(struct WebKit::PDFContextMenu contextMenu, WebKit::PDFPluginIdentifier identifier) -> (std::optional<int32_t> selectedItem) Synchronous
#endif
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ FindPlugin(String mimeType, String urlString, String frameURLString, String pageURLString, bool allowOnlyApplicationPlugins) -> (uint64_t pluginProcessToken, String newMIMEType, uint32_t pluginLoadPolicy, String unavailabilityDescription, bool isUnsupported) Synchronous
+#endif
+
DidUpdateActivityState()
#if ENABLE(WEB_CRYPTO)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebProcessPool.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/WebProcessPool.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebProcessPool.cpp 2022-08-24 04:51:35.411875700 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/WebProcessPool.cpp 2022-08-26 14:18:15.005022462 -0500
@@ -51,6 +51,7 @@
#include "NetworkProcessMessages.h"
#include "NetworkProcessProxy.h"
#include "PerActivityStateCPUUsageSampler.h"
+#include "PluginProcessManager.h"
#include "SandboxExtension.h"
#include "TextChecker.h"
#include "UIGamepad.h"
@@ -403,6 +404,9 @@ void WebProcessPool::sendMemoryPressureE
sendToAllProcesses(Messages::AuxiliaryProcess::DidReceiveMemoryPressureEvent(isCritical));
for (auto networkProcess : NetworkProcessProxy::allNetworkProcesses())
networkProcess->send(Messages::AuxiliaryProcess::DidReceiveMemoryPressureEvent(isCritical), 0);
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ PluginProcessManager::singleton().sendMemoryPressureEvent(isCritical);
+#endif
}
#endif
@@ -877,6 +881,8 @@ void WebProcessPool::initializeNewWebPro
parameters.shouldAlwaysUseComplexTextCodePath = m_alwaysUsesComplexTextCodePath;
parameters.shouldUseFontSmoothing = m_shouldUseFontSmoothing;
+ parameters.terminationTimeout = 0_s;
+
parameters.textCheckerState = TextChecker::state();
parameters.fullKeyboardAccessEnabled = WebProcessProxy::fullKeyboardAccessEnabled();
@@ -1328,6 +1334,23 @@ void WebProcessPool::handleMemoryPressur
ASSERT(!m_prewarmedProcess);
}
+#if ENABLE(NETSCAPE_PLUGIN_API)
+void WebProcessPool::setAdditionalPluginsDirectory(const String& directory)
+{
+ Vector<String> directories;
+ directories.append(directory);
+
+ m_pluginInfoStore.setAdditionalPluginsDirectories(directories);
+}
+
+void WebProcessPool::refreshPlugins()
+{
+ m_pluginInfoStore.refresh();
+ sendToAllProcesses(Messages::WebProcess::RefreshPlugins());
+}
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
ProcessID WebProcessPool::prewarmedProcessIdentifier()
{
return m_prewarmedProcess ? m_prewarmedProcess->processIdentifier() : 0;
@@ -1761,14 +1784,21 @@ void WebProcessPool::setJavaScriptGarbag
void WebProcessPool::addSupportedPlugin(String&& matchingDomain, String&& name, HashSet<String>&& mimeTypes, HashSet<String> extensions)
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ m_pluginInfoStore.addSupportedPlugin(WTFMove(matchingDomain), WTFMove(name), WTFMove(mimeTypes), WTFMove(extensions));
+#else
UNUSED_PARAM(matchingDomain);
UNUSED_PARAM(name);
UNUSED_PARAM(mimeTypes);
UNUSED_PARAM(extensions);
+#endif
}
void WebProcessPool::clearSupportedPlugins()
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ m_pluginInfoStore.clearSupportedPlugins();
+#endif
}
void WebProcessPool::setMemoryCacheDisabled(bool disabled)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebProcessPool.h webkitgtk-2.36.7/Source/WebKit/UIProcess/WebProcessPool.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebProcessPool.h 2022-06-30 04:49:37.896179200 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/WebProcessPool.h 2022-08-26 14:18:15.005022462 -0500
@@ -34,6 +34,7 @@
#include "MessageReceiver.h"
#include "MessageReceiverMap.h"
#include "NetworkProcessProxy.h"
+#include "PluginInfoStore.h"
#include "ProcessThrottler.h"
#include "VisitedLinkStore.h"
#include "WebContextClient.h"
@@ -240,6 +241,13 @@ public:
void handleMemoryPressureWarning(Critical);
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ void setAdditionalPluginsDirectory(const String&);
+ void refreshPlugins();
+
+ PluginInfoStore& pluginInfoStore() { return m_pluginInfoStore; }
+#endif
+
#if HAVE(CVDISPLAYLINK)
std::optional<WebCore::FramesPerSecond> nominalFramesPerSecondForDisplay(WebCore::PlatformDisplayID);
void startDisplayLink(IPC::Connection&, DisplayLinkObserverID, WebCore::PlatformDisplayID, WebCore::FramesPerSecond);
@@ -650,6 +658,9 @@ private:
RefPtr<WebAutomationSession> m_automationSession;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ PluginInfoStore m_pluginInfoStore;
+#endif
Ref<VisitedLinkStore> m_visitedLinkStore;
bool m_visitedLinksPopulated { false };
@@ -727,6 +738,7 @@ private:
#if PLATFORM(COCOA)
RetainPtr<NSMutableDictionary> m_bundleParameters;
+ ProcessSuppressionDisabledToken m_pluginProcessManagerProcessSuppressionDisabledToken;
mutable RetainPtr<NSSet> m_classesForParameterCoder;
#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebProcessProxy.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/WebProcessProxy.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebProcessProxy.cpp 2022-08-24 04:51:35.411875700 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/WebProcessProxy.cpp 2022-08-26 14:18:15.005022462 -0500
@@ -34,6 +34,8 @@
#include "LoadParameters.h"
#include "Logging.h"
#include "NotificationManagerMessageHandlerMessages.h"
+#include "PluginInfoStore.h"
+#include "PluginProcessManager.h"
#include "ProvisionalPageProxy.h"
#include "ServiceWorkerNotificationHandler.h"
#include "SpeechRecognitionPermissionRequest.h"
@@ -812,6 +814,40 @@ void WebProcessProxy::updateBackForwardI
}
}
+#if ENABLE(NETSCAPE_PLUGIN_API)
+void WebProcessProxy::getPlugins(bool refresh, CompletionHandler<void(Vector<PluginInfo>&& plugins, Vector<PluginInfo>&& applicationPlugins, std::optional<Vector<WebCore::SupportedPluginIdentifier>>&& supportedPluginIdentifiers)>&& completionHandler)
+{
+ if (refresh)
+ m_processPool->pluginInfoStore().refresh();
+
+ auto supportedPluginIdentifiers = m_processPool->pluginInfoStore().supportedPluginIdentifiers();
+
+ Vector<PluginInfo> plugins;
+ Vector<PluginModuleInfo> pluginModules = m_processPool->pluginInfoStore().plugins();
+ for (size_t i = 0; i < pluginModules.size(); ++i)
+ plugins.append(pluginModules[i].info);
+
+ Vector<PluginInfo> applicationPlugins;
+#if ENABLE(PDFKIT_PLUGIN)
+ // Add built-in PDF last, so that it's not used when a real plug-in is installed.
+ if (!m_processPool->omitPDFSupport()) {
+ plugins.append(PDFPlugin::pluginInfo());
+ applicationPlugins.append(PDFPlugin::pluginInfo());
+ }
+#endif
+ completionHandler(WTFMove(plugins), WTFMove(applicationPlugins), WTFMove(supportedPluginIdentifiers));
+}
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+void WebProcessProxy::getPluginProcessConnection(uint64_t pluginProcessToken, Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply&& reply)
+{
+ MESSAGE_CHECK(HashSet<uint64_t>::isValidValue(pluginProcessToken));
+ bool success = PluginProcessManager::singleton().getPluginProcessConnection(pluginProcessToken, WTFMove(reply));
+ MESSAGE_CHECK(success);
+}
+#endif
+
void WebProcessProxy::getNetworkProcessConnection(Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply&& reply)
{
websiteDataStore().getNetworkProcessConnection(*this, WTFMove(reply));
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebProcessProxy.h webkitgtk-2.36.7/Source/WebKit/UIProcess/WebProcessProxy.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebProcessProxy.h 2022-08-24 04:51:35.411875700 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/WebProcessProxy.h 2022-08-26 14:18:15.005022462 -0500
@@ -31,6 +31,7 @@
#include "DisplayLinkObserverID.h"
#include "MessageReceiverMap.h"
#include "NetworkProcessProxy.h"
+#include "PluginInfoStore.h"
#include "ProcessLauncher.h"
#include "ProcessTerminationReason.h"
#include "ProcessThrottler.h"
@@ -474,6 +475,14 @@ private:
bool hasProvisionalPageWithID(WebPageProxyIdentifier) const;
bool isAllowedToUpdateBackForwardItem(WebBackForwardListItem&) const;
+
+ // Plugins
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ void getPlugins(bool refresh, CompletionHandler<void(Vector<WebCore::PluginInfo>&& plugins, Vector<WebCore::PluginInfo>&& applicationPlugins, std::optional<Vector<WebCore::SupportedPluginIdentifier>>&&)>&&);
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ void getPluginProcessConnection(uint64_t pluginProcessToken, Messages::WebProcessProxy::GetPluginProcessConnectionDelayedReply&&);
+#endif
void getNetworkProcessConnection(Messages::WebProcessProxy::GetNetworkProcessConnectionDelayedReply&&);
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebProcessProxy.messages.in webkitgtk-2.36.7/Source/WebKit/UIProcess/WebProcessProxy.messages.in
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebProcessProxy.messages.in 2022-06-30 04:49:37.899512500 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/WebProcessProxy.messages.in 2022-08-26 14:18:15.005022462 -0500
@@ -31,6 +31,11 @@ messages -> WebProcessProxy LegacyReceiv
EnableSuddenTermination()
DisableSuddenTermination()
+ # Plugin messages.
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ GetPlugins(bool refresh) -> (Vector<WebCore::PluginInfo> plugins, Vector<WebCore::PluginInfo> applicationPlugins, struct std::optional<Vector<WebCore::SupportedPluginIdentifier>> supportedPluginIdentifiers) Synchronous
+ GetPluginProcessConnection(uint64_t pluginProcessToken) -> (IPC::Attachment connectionHandle, bool supportsAsynchronousInitialization) Synchronous
+#endif
GetNetworkProcessConnection() -> (struct WebKit::NetworkProcessConnectionInfo connectionInfo) Synchronous
#if ENABLE(GPU_PROCESS)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebsiteData/WebsiteDataRecord.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/WebsiteData/WebsiteDataRecord.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebsiteData/WebsiteDataRecord.cpp 2022-06-30 04:49:37.899512500 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/WebsiteData/WebsiteDataRecord.cpp 2022-08-26 14:18:15.005022462 -0500
@@ -90,6 +90,14 @@ void WebsiteDataRecord::addCookieHostNam
cookieHostNames.add(hostName);
}
+#if ENABLE(NETSCAPE_PLUGIN_API)
+void WebsiteDataRecord::addPluginDataHostName(const String& hostName)
+{
+ types.add(WebsiteDataType::PlugInData);
+ pluginDataHostNames.add(hostName);
+}
+#endif
+
void WebsiteDataRecord::addHSTSCacheHostname(const String& hostName)
{
types.add(WebsiteDataType::HSTSCache);
@@ -152,6 +160,12 @@ String WebsiteDataRecord::topPrivatelyCo
if (!origins.isEmpty())
return WebCore::topPrivatelyControlledDomain(origins.takeAny().securityOrigin().get().host());
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ if (!pluginDataHostNames.isEmpty())
+ return WebCore::topPrivatelyControlledDomain(pluginDataHostNames.takeAny());
+#endif
+
#endif // ENABLE(PUBLIC_SUFFIX_LIST)
return emptyString();
@@ -165,6 +179,9 @@ WebsiteDataRecord WebsiteDataRecord::iso
size,
crossThreadCopy(origins),
crossThreadCopy(cookieHostNames),
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ crossThreadCopy(pluginDataHostNames),
+#endif
crossThreadCopy(HSTSCacheHostNames),
crossThreadCopy(alternativeServicesHostNames),
#if ENABLE(INTELLIGENT_TRACKING_PREVENTION)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebsiteData/WebsiteDataRecord.h webkitgtk-2.36.7/Source/WebKit/UIProcess/WebsiteData/WebsiteDataRecord.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebsiteData/WebsiteDataRecord.h 2022-06-30 04:49:37.899512500 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/WebsiteData/WebsiteDataRecord.h 2022-08-26 14:18:15.005022462 -0500
@@ -49,6 +49,9 @@ struct WebsiteDataRecord {
void add(WebsiteDataType, const WebCore::SecurityOriginData&);
void addCookieHostName(const String& hostName);
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ void addPluginDataHostName(const String& hostName);
+#endif
void addHSTSCacheHostname(const String& hostName);
void addAlternativeServicesHostname(const String& hostName);
#if ENABLE(INTELLIGENT_TRACKING_PREVENTION)
@@ -71,6 +74,9 @@ struct WebsiteDataRecord {
HashSet<WebCore::SecurityOriginData> origins;
HashSet<String> cookieHostNames;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ HashSet<String> pluginDataHostNames;
+#endif
HashSet<String> HSTSCacheHostNames;
HashSet<String> alternativeServicesHostNames;
#if ENABLE(INTELLIGENT_TRACKING_PREVENTION)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp webkitgtk-2.36.7/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp 2022-08-08 06:13:37.349459400 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp 2022-08-26 14:19:08.749306162 -0500
@@ -72,6 +72,10 @@
#include <wtf/spi/darwin/OSVariantSPI.h>
#endif
+#if ENABLE(NETSCAPE_PLUGIN_API)
+#include "PluginProcessManager.h"
+#endif
+
#if HAVE(SEC_KEY_PROXY)
#include "SecKeyProxyStore.h"
#endif
@@ -382,6 +386,20 @@ void WebsiteDataStore::fetchDataAndApply
record.addCookieHostName(hostName);
}
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ for (auto& hostName : websiteData.hostNamesWithPluginData) {
+ auto displayName = WebsiteDataRecord::displayNameForHostName(hostName);
+ if (!displayName)
+ continue;
+
+ auto& record = m_websiteDataRecords.add(displayName, WebsiteDataRecord { }).iterator->value;
+ if (!record.displayName)
+ record.displayName = WTFMove(displayName);
+
+ record.addPluginDataHostName(hostName);
+ }
+#endif
+
for (auto& hostName : websiteData.hostNamesWithHSTSCache) {
auto displayName = WebsiteDataRecord::displayNameForHostName(hostName);
if (!displayName)
@@ -506,6 +524,57 @@ private:
callbackAggregator->addWebsiteData(WTFMove(websiteData));
});
}
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ if (dataTypes.contains(WebsiteDataType::PlugInData) && isPersistent()) {
+ class State {
+ public:
+ static void fetchData(Ref<CallbackAggregator>&& callbackAggregator, Vector<PluginModuleInfo>&& plugins)
+ {
+ new State(WTFMove(callbackAggregator), WTFMove(plugins));
+ }
+
+ private:
+ State(Ref<CallbackAggregator>&& callbackAggregator, Vector<PluginModuleInfo>&& plugins)
+ : m_callbackAggregator(WTFMove(callbackAggregator))
+ , m_plugins(WTFMove(plugins))
+ {
+ fetchWebsiteDataForNextPlugin();
+ }
+
+ ~State()
+ {
+ ASSERT(m_plugins.isEmpty());
+ }
+
+ void fetchWebsiteDataForNextPlugin()
+ {
+ if (m_plugins.isEmpty()) {
+ WebsiteData websiteData;
+ websiteData.hostNamesWithPluginData = WTFMove(m_hostNames);
+
+ m_callbackAggregator->addWebsiteData(WTFMove(websiteData));
+
+ delete this;
+ return;
+ }
+
+ auto plugin = m_plugins.takeLast();
+ PluginProcessManager::singleton().fetchWebsiteData(plugin, m_callbackAggregator->fetchOptions(), [this](Vector<String> hostNames) {
+ for (auto& hostName : hostNames)
+ m_hostNames.add(WTFMove(hostName));
+ fetchWebsiteDataForNextPlugin();
+ });
+ }
+
+ Ref<CallbackAggregator> m_callbackAggregator;
+ Vector<PluginModuleInfo> m_plugins;
+ HashSet<String> m_hostNames;
+ };
+
+ State::fetchData(callbackAggregator.copyRef(), plugins());
+ }
+#endif
}
#if ENABLE(INTELLIGENT_TRACKING_PREVENTION)
@@ -633,6 +702,51 @@ void WebsiteDataStore::removeData(Option
});
}
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ if (dataTypes.contains(WebsiteDataType::PlugInData) && isPersistent()) {
+ class State {
+ public:
+ static void deleteData(Ref<MainRunLoopCallbackAggregator>&& callbackAggregator, Vector<PluginModuleInfo>&& plugins, WallTime modifiedSince)
+ {
+ new State(WTFMove(callbackAggregator), WTFMove(plugins), modifiedSince);
+ }
+
+ private:
+ State(Ref<MainRunLoopCallbackAggregator>&& callbackAggregator, Vector<PluginModuleInfo>&& plugins, WallTime modifiedSince)
+ : m_callbackAggregator(WTFMove(callbackAggregator))
+ , m_plugins(WTFMove(plugins))
+ , m_modifiedSince(modifiedSince)
+ {
+ deleteWebsiteDataForNextPlugin();
+ }
+
+ ~State()
+ {
+ ASSERT(m_plugins.isEmpty());
+ }
+
+ void deleteWebsiteDataForNextPlugin()
+ {
+ if (m_plugins.isEmpty()) {
+ delete this;
+ return;
+ }
+
+ auto plugin = m_plugins.takeLast();
+ PluginProcessManager::singleton().deleteWebsiteData(plugin, m_modifiedSince, [this] {
+ deleteWebsiteDataForNextPlugin();
+ });
+ }
+
+ Ref<MainRunLoopCallbackAggregator> m_callbackAggregator;
+ Vector<PluginModuleInfo> m_plugins;
+ WallTime m_modifiedSince;
+ };
+
+ State::deleteData(callbackAggregator.copyRef(), plugins(), modifiedSince);
+ }
+#endif
+
#if ENABLE(INTELLIGENT_TRACKING_PREVENTION)
if (dataTypes.contains(WebsiteDataType::ResourceLoadStatistics)) {
if (!didNotifyNetworkProcessToDeleteWebsiteData)
@@ -757,6 +871,59 @@ void WebsiteDataStore::removeData(Option
removeMediaKeys(mediaKeysStorageDirectory, origins);
});
}
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ if (dataTypes.contains(WebsiteDataType::PlugInData) && isPersistent()) {
+ Vector<String> hostNames;
+ for (const auto& dataRecord : dataRecords) {
+ for (const auto& hostName : dataRecord.pluginDataHostNames)
+ hostNames.append(hostName);
+ }
+
+
+ class State {
+ public:
+ static void deleteData(Ref<MainRunLoopCallbackAggregator>&& callbackAggregator, Vector<PluginModuleInfo>&& plugins, Vector<String>&& hostNames)
+ {
+ new State(WTFMove(callbackAggregator), WTFMove(plugins), WTFMove(hostNames));
+ }
+
+ private:
+ State(Ref<MainRunLoopCallbackAggregator>&& callbackAggregator, Vector<PluginModuleInfo>&& plugins, Vector<String>&& hostNames)
+ : m_callbackAggregator(WTFMove(callbackAggregator))
+ , m_plugins(WTFMove(plugins))
+ , m_hostNames(WTFMove(hostNames))
+ {
+ deleteWebsiteDataForNextPlugin();
+ }
+
+ ~State()
+ {
+ ASSERT(m_plugins.isEmpty());
+ }
+
+ void deleteWebsiteDataForNextPlugin()
+ {
+ if (m_plugins.isEmpty()) {
+ delete this;
+ return;
+ }
+
+ auto plugin = m_plugins.takeLast();
+ PluginProcessManager::singleton().deleteWebsiteDataForHostNames(plugin, m_hostNames, [this] {
+ deleteWebsiteDataForNextPlugin();
+ });
+ }
+
+ Ref<MainRunLoopCallbackAggregator> m_callbackAggregator;
+ Vector<PluginModuleInfo> m_plugins;
+ Vector<String> m_hostNames;
+ };
+
+ if (!hostNames.isEmpty())
+ State::deleteData(callbackAggregator.copyRef(), plugins(), WTFMove(hostNames));
+ }
+#endif
}
void WebsiteDataStore::setServiceWorkerTimeoutForTesting(Seconds seconds)
@@ -1424,6 +1591,20 @@ HashSet<RefPtr<WebProcessPool>> WebsiteD
return processPools;
}
+#if ENABLE(NETSCAPE_PLUGIN_API)
+Vector<PluginModuleInfo> WebsiteDataStore::plugins() const
+{
+ Vector<PluginModuleInfo> plugins;
+
+ for (auto& processPool : ensureProcessPools()) {
+ for (auto& plugin : processPool->pluginInfoStore().plugins())
+ plugins.append(plugin);
+ }
+
+ return plugins;
+}
+#endif
+
static String computeMediaKeyFile(const String& mediaKeyDirectory)
{
return FileSystem::pathByAppendingComponent(mediaKeyDirectory, "SecureStop.plist");
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h webkitgtk-2.36.7/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h
--- webkitgtk-2.36.7.orig/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h 2022-06-30 04:49:37.902845900 -0500
+++ webkitgtk-2.36.7/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h 2022-08-26 14:18:15.005022462 -0500
@@ -108,6 +108,10 @@ enum class StorageAccessStatus : uint8_t
enum class StorageAccessPromptStatus;
#endif
+#if ENABLE(NETSCAPE_PLUGIN_API)
+struct PluginModuleInfo;
+#endif
+
class WebsiteDataStore : public API::ObjectImpl<API::Object::Type::WebsiteDataStore>, public Identified<WebsiteDataStore>, public CanMakeWeakPtr<WebsiteDataStore> {
public:
static Ref<WebsiteDataStore> defaultDataStore();
@@ -403,6 +407,10 @@ private:
// Will create a temporary process pool is none exists yet.
HashSet<RefPtr<WebProcessPool>> ensureProcessPools() const;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ Vector<PluginModuleInfo> plugins() const;
+#endif
+
static Vector<WebCore::SecurityOriginData> mediaKeyOrigins(const String& mediaKeysStorageDirectory);
static void removeMediaKeys(const String& mediaKeysStorageDirectory, WallTime modifiedSince);
static void removeMediaKeys(const String& mediaKeysStorageDirectory, const HashSet<WebCore::SecurityOriginData>&);
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/webkitglib-symbols.map webkitgtk-2.36.7/Source/WebKit/webkitglib-symbols.map
--- webkitgtk-2.36.7.orig/Source/WebKit/webkitglib-symbols.map 2022-08-08 16:28:31.878647800 -0500
+++ webkitgtk-2.36.7/Source/WebKit/webkitglib-symbols.map 2022-08-26 14:18:15.005022462 -0500
@@ -5,6 +5,7 @@ global:
extern "C++" {
"bmalloc::vmPageSize()::cached";
"WebKit::NetworkProcessMain(int, char**)";
+ "WebKit::PluginProcessMain(int, char**)";
"WebKit::WebKitExtensionManager::initialize(WebKit::InjectedBundle*, API::Object*)";
"WebKit::WebKitExtensionManager::singleton()";
"WebKit::WebProcessMain(int, char**)";
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/JSNPMethod.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/JSNPMethod.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/JSNPMethod.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/JSNPMethod.cpp 2022-08-26 14:18:15.005022462 -0500
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2010-2018 Apple 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 INC. 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 INC. 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 "config.h"
+#include "JSNPMethod.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "JSNPObject.h"
+#include <JavaScriptCore/Error.h>
+#include <JavaScriptCore/FunctionPrototype.h>
+#include <JavaScriptCore/IsoSubspacePerVM.h>
+#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>
+#include <JavaScriptCore/JSGlobalObjectInlines.h>
+#include <JavaScriptCore/JSObject.h>
+#include <WebCore/JSHTMLElement.h>
+#include <WebCore/JSPluginElementFunctions.h>
+
+namespace WebKit {
+using namespace JSC;
+using namespace WebCore;
+
+STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(JSNPMethod);
+
+const ClassInfo JSNPMethod::s_info = { "NPMethod", &InternalFunction::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSNPMethod) };
+
+static JSC_DECLARE_HOST_FUNCTION(callMethod);
+
+JSNPMethod::JSNPMethod(JSGlobalObject* globalObject, Structure* structure, NPIdentifier npIdentifier)
+ : InternalFunction(globalObject->vm(), structure, callMethod, nullptr)
+ , m_npIdentifier(npIdentifier)
+{
+}
+
+void JSNPMethod::finishCreation(VM& vm, const String& name)
+{
+ Base::finishCreation(vm, 0, name);
+ ASSERT(inherits(vm, info()));
+}
+
+GCClient::IsoSubspace* JSNPMethod::subspaceForImpl(VM& vm)
+{
+ static NeverDestroyed<IsoSubspacePerVM> perVM([] (Heap& heap) { return ISO_SUBSPACE_PARAMETERS(heap.cellHeapCellType, JSNPMethod); });
+ return &perVM.get().clientIsoSubspaceforVM(vm);
+}
+
+JSC_DEFINE_HOST_FUNCTION(callMethod, (JSGlobalObject* globalObject, CallFrame* callFrame))
+{
+ VM& vm = globalObject->vm();
+ auto scope = DECLARE_THROW_SCOPE(vm);
+
+ JSNPMethod* jsNPMethod = jsCast<JSNPMethod*>(callFrame->jsCallee());
+
+ JSValue thisValue = callFrame->thisValue();
+
+ // Check if we're calling a method on the plug-in script object.
+ if (thisValue.inherits<JSHTMLElement>(vm)) {
+ JSHTMLElement* element = jsCast<JSHTMLElement*>(asObject(thisValue));
+
+ // Try to get the script object from the element
+ if (JSObject* scriptObject = pluginScriptObject(globalObject, element))
+ thisValue = scriptObject;
+ }
+
+ if (thisValue.inherits<JSNPObject>(vm)) {
+ JSNPObject* jsNPObject = jsCast<JSNPObject*>(asObject(thisValue));
+
+ return JSValue::encode(jsNPObject->callMethod(globalObject, callFrame, jsNPMethod->npIdentifier()));
+ }
+
+ return throwVMTypeError(globalObject, scope);
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/JSNPMethod.h webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/JSNPMethod.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/JSNPMethod.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/JSNPMethod.h 2022-08-26 14:18:15.005022462 -0500
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2010-2018 Apple 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 INC. 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 INC. 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.
+ */
+
+#ifndef JSNPMethod_h
+#define JSNPMethod_h
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include <JavaScriptCore/FunctionPrototype.h>
+#include <JavaScriptCore/InternalFunction.h>
+#include <JavaScriptCore/JSGlobalObject.h>
+
+typedef void* NPIdentifier;
+
+namespace WebKit {
+
+// A JSObject that wraps an NPMethod.
+class JSNPMethod final : public JSC::InternalFunction {
+public:
+ using Base = JSC::InternalFunction;
+
+ template<typename CellType, JSC::SubspaceAccess>
+ static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+ {
+ return subspaceForImpl(vm);
+ }
+
+ static JSNPMethod* create(JSC::JSGlobalObject* globalObject, const String& name, NPIdentifier npIdent)
+ {
+ JSC::VM& vm = globalObject->vm();
+ JSC::Structure* structure = createStructure(globalObject->vm(), globalObject, globalObject->functionPrototype());
+ JSNPMethod* method = new (JSC::allocateCell<JSNPMethod>(vm)) JSNPMethod(globalObject, structure, npIdent);
+ method->finishCreation(vm, name);
+ return method;
+ }
+
+ DECLARE_INFO;
+
+ NPIdentifier npIdentifier() const { return m_npIdentifier; }
+
+private:
+ static JSC::GCClient::IsoSubspace* subspaceForImpl(JSC::VM&);
+
+ JSNPMethod(JSC::JSGlobalObject*, JSC::Structure*, NPIdentifier);
+ void finishCreation(JSC::VM&, const String& name);
+
+ static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+ {
+ return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+ }
+
+ NPIdentifier m_npIdentifier;
+};
+
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif // JSNPMethod_h
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/JSNPObject.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/JSNPObject.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/JSNPObject.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/JSNPObject.cpp 2022-08-26 14:18:15.005022462 -0500
@@ -0,0 +1,549 @@
+/*
+ * Copyright (C) 2010-2019 Apple 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 INC. 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 INC. 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 "config.h"
+#include "JSNPObject.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "JSNPMethod.h"
+#include "NPJSObject.h"
+#include "NPRuntimeObjectMap.h"
+#include "NPRuntimeUtilities.h"
+#include <JavaScriptCore/AuxiliaryBarrierInlines.h>
+#include <JavaScriptCore/Error.h>
+#include <JavaScriptCore/IdentifierInlines.h>
+#include <JavaScriptCore/IsoSubspacePerVM.h>
+#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>
+#include <JavaScriptCore/JSGlobalObject.h>
+#include <JavaScriptCore/JSLock.h>
+#include <JavaScriptCore/ObjectPrototype.h>
+#include <WebCore/CommonVM.h>
+#include <WebCore/DOMWindow.h>
+#include <WebCore/IdentifierRep.h>
+#include <WebCore/JSDOMWindowBase.h>
+#include <wtf/Assertions.h>
+#include <wtf/text/WTFString.h>
+
+namespace WebKit {
+using namespace JSC;
+using namespace WebCore;
+
+static JSC_DECLARE_CUSTOM_GETTER(propertyGetter);
+static JSC_DECLARE_CUSTOM_GETTER(methodGetter);
+
+static NPIdentifier npIdentifierFromIdentifier(PropertyName propertyName)
+{
+ String name(propertyName.publicName());
+ // If the propertyName is Symbol.
+ if (name.isNull())
+ return nullptr;
+ return static_cast<NPIdentifier>(IdentifierRep::get(name.utf8().data()));
+}
+
+static JSC::Exception* throwInvalidAccessError(JSGlobalObject* lexicalGlobalObject, ThrowScope& scope)
+{
+ return throwException(lexicalGlobalObject, scope, createReferenceError(lexicalGlobalObject, "Trying to access object from destroyed plug-in."));
+}
+
+const ClassInfo JSNPObject::s_info = { "NPObject", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSNPObject) };
+
+JSNPObject::JSNPObject(JSGlobalObject* globalObject, Structure* structure, NPRuntimeObjectMap* objectMap, NPObject* npObject)
+ : JSDestructibleObject(globalObject->vm(), structure)
+ , m_objectMap(objectMap)
+ , m_npObject(npObject)
+{
+ ASSERT(globalObject == structure->globalObject());
+}
+
+void JSNPObject::finishCreation(JSGlobalObject* globalObject)
+{
+ VM& vm = globalObject->vm();
+ Base::finishCreation(vm);
+ ASSERT(inherits(vm, info()));
+
+ // We should never have an NPJSObject inside a JSNPObject.
+ ASSERT(!NPJSObject::isNPJSObject(m_npObject));
+
+ retainNPObject(m_npObject);
+}
+
+JSNPObject::~JSNPObject()
+{
+ if (m_npObject)
+ invalidate();
+}
+
+void JSNPObject::destroy(JSCell* cell)
+{
+ static_cast<JSNPObject*>(cell)->JSNPObject::~JSNPObject();
+}
+
+void JSNPObject::invalidate()
+{
+ ASSERT(m_npObject);
+
+ releaseNPObject(m_npObject);
+ m_npObject = 0;
+}
+
+NPObject* JSNPObject::leakNPObject()
+{
+ ASSERT(m_npObject);
+
+ NPObject* object = m_npObject;
+ m_npObject = 0;
+ return object;
+}
+
+JSValue JSNPObject::callMethod(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame, NPIdentifier methodName)
+{
+ VM& vm = lexicalGlobalObject->vm();
+ auto scope = DECLARE_THROW_SCOPE(vm);
+
+ ASSERT_THIS_GC_OBJECT_INHERITS(info());
+ if (!m_npObject)
+ return throwInvalidAccessError(lexicalGlobalObject, scope);
+
+ // If the propertyName is symbol.
+ if (!methodName)
+ return jsUndefined();
+
+ size_t argumentCount = callFrame->argumentCount();
+ Vector<NPVariant, 8> arguments(argumentCount);
+
+ // Convert all arguments to NPVariants.
+ for (size_t i = 0; i < argumentCount; ++i)
+ m_objectMap->convertJSValueToNPVariant(lexicalGlobalObject, callFrame->uncheckedArgument(i), arguments[i]);
+
+ // Calling NPClass::invoke will call into plug-in code, and there's no telling what the plug-in can do.
+ // (including destroying the plug-in). Because of this, we make sure to keep the plug-in alive until
+ // the call has finished.
+ NPRuntimeObjectMap::PluginProtector protector(m_objectMap);
+
+ bool returnValue;
+ NPVariant result;
+ VOID_TO_NPVARIANT(result);
+
+ {
+ JSLock::DropAllLocks dropAllLocks(commonVM());
+ returnValue = m_npObject->_class->invoke(m_npObject, methodName, arguments.data(), argumentCount, &result);
+ NPRuntimeObjectMap::moveGlobalExceptionToExecState(lexicalGlobalObject);
+ }
+
+ // Release all arguments.
+ for (size_t i = 0; i < argumentCount; ++i)
+ releaseNPVariantValue(&arguments[i]);
+
+ if (!returnValue)
+ throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Error calling method on NPObject."));
+
+ JSValue propertyValue = m_objectMap->convertNPVariantToJSValue(globalObject(), result);
+ releaseNPVariantValue(&result);
+ return propertyValue;
+}
+
+JSC::JSValue JSNPObject::callObject(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
+{
+ VM& vm = lexicalGlobalObject->vm();
+ auto scope = DECLARE_THROW_SCOPE(vm);
+
+ ASSERT_THIS_GC_OBJECT_INHERITS(info());
+ if (!m_npObject)
+ return throwInvalidAccessError(lexicalGlobalObject, scope);
+
+ size_t argumentCount = callFrame->argumentCount();
+ Vector<NPVariant, 8> arguments(argumentCount);
+
+ // Convert all arguments to NPVariants.
+ for (size_t i = 0; i < argumentCount; ++i)
+ m_objectMap->convertJSValueToNPVariant(lexicalGlobalObject, callFrame->uncheckedArgument(i), arguments[i]);
+
+ // Calling NPClass::invokeDefault will call into plug-in code, and there's no telling what the plug-in can do.
+ // (including destroying the plug-in). Because of this, we make sure to keep the plug-in alive until
+ // the call has finished.
+ NPRuntimeObjectMap::PluginProtector protector(m_objectMap);
+
+ bool returnValue;
+ NPVariant result;
+ VOID_TO_NPVARIANT(result);
+
+ {
+ JSLock::DropAllLocks dropAllLocks(commonVM());
+ returnValue = m_npObject->_class->invokeDefault(m_npObject, arguments.data(), argumentCount, &result);
+ NPRuntimeObjectMap::moveGlobalExceptionToExecState(lexicalGlobalObject);
+ }
+
+ // Release all arguments;
+ for (size_t i = 0; i < argumentCount; ++i)
+ releaseNPVariantValue(&arguments[i]);
+
+ if (!returnValue)
+ throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Error calling method on NPObject."));
+
+ JSValue propertyValue = m_objectMap->convertNPVariantToJSValue(globalObject(), result);
+ releaseNPVariantValue(&result);
+ return propertyValue;
+}
+
+JSValue JSNPObject::callConstructor(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
+{
+ VM& vm = lexicalGlobalObject->vm();
+ auto scope = DECLARE_THROW_SCOPE(vm);
+
+ ASSERT_THIS_GC_OBJECT_INHERITS(info());
+ if (!m_npObject)
+ return throwInvalidAccessError(lexicalGlobalObject, scope);
+
+ size_t argumentCount = callFrame->argumentCount();
+ Vector<NPVariant, 8> arguments(argumentCount);
+
+ // Convert all arguments to NPVariants.
+ for (size_t i = 0; i < argumentCount; ++i)
+ m_objectMap->convertJSValueToNPVariant(lexicalGlobalObject, callFrame->uncheckedArgument(i), arguments[i]);
+
+ // Calling NPClass::construct will call into plug-in code, and there's no telling what the plug-in can do.
+ // (including destroying the plug-in). Because of this, we make sure to keep the plug-in alive until
+ // the call has finished.
+ NPRuntimeObjectMap::PluginProtector protector(m_objectMap);
+
+ bool returnValue;
+ NPVariant result;
+ VOID_TO_NPVARIANT(result);
+
+ {
+ JSLock::DropAllLocks dropAllLocks(commonVM());
+ returnValue = m_npObject->_class->construct(m_npObject, arguments.data(), argumentCount, &result);
+ NPRuntimeObjectMap::moveGlobalExceptionToExecState(lexicalGlobalObject);
+ }
+
+ if (!returnValue)
+ throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Error calling method on NPObject."));
+
+ JSValue value = m_objectMap->convertNPVariantToJSValue(globalObject(), result);
+ releaseNPVariantValue(&result);
+ return value;
+}
+
+static JSC_DECLARE_HOST_FUNCTION(callNPJSObject);
+static JSC_DECLARE_HOST_FUNCTION(constructWithConstructor);
+
+JSC_DEFINE_HOST_FUNCTION(callNPJSObject, (JSGlobalObject* globalObject, CallFrame* callFrame))
+{
+ JSObject* object = callFrame->jsCallee();
+ ASSERT_UNUSED(globalObject, object->inherits<JSNPObject>(globalObject->vm()));
+
+ return JSValue::encode(jsCast<JSNPObject*>(object)->callObject(globalObject, callFrame));
+}
+
+CallData JSNPObject::getCallData(JSCell* cell)
+{
+ CallData callData;
+ JSNPObject* thisObject = JSC::jsCast<JSNPObject*>(cell);
+ ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+ if (thisObject->m_npObject && thisObject->m_npObject->_class->invokeDefault) {
+ callData.type = CallData::Type::Native;
+ callData.native.function = callNPJSObject;
+ }
+ return callData;
+}
+
+JSC_DEFINE_HOST_FUNCTION(constructWithConstructor, (JSGlobalObject* globalObject, CallFrame* callFrame))
+{
+ JSObject* constructor = callFrame->jsCallee();
+ ASSERT_UNUSED(globalObject, constructor->inherits<JSNPObject>(globalObject->vm()));
+
+ return JSValue::encode(jsCast<JSNPObject*>(constructor)->callConstructor(globalObject, callFrame));
+}
+
+CallData JSNPObject::getConstructData(JSCell* cell)
+{
+ CallData constructData;
+
+ JSNPObject* thisObject = JSC::jsCast<JSNPObject*>(cell);
+ ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+ if (thisObject->m_npObject && thisObject->m_npObject->_class->construct) {
+ constructData.type = CallData::Type::Native;
+ constructData.native.function = constructWithConstructor;
+ }
+
+ return constructData;
+}
+
+bool JSNPObject::getOwnPropertySlot(JSObject* object, JSGlobalObject* lexicalGlobalObject, PropertyName propertyName, PropertySlot& slot)
+{
+ VM& vm = lexicalGlobalObject->vm();
+ auto scope = DECLARE_THROW_SCOPE(vm);
+
+ JSNPObject* thisObject = JSC::jsCast<JSNPObject*>(object);
+ ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+ if (!thisObject->m_npObject) {
+ throwInvalidAccessError(lexicalGlobalObject, scope);
+ return false;
+ }
+
+ NPIdentifier npIdentifier = npIdentifierFromIdentifier(propertyName);
+ // If the propertyName is symbol.
+ if (!npIdentifier)
+ return false;
+
+ // Calling NPClass::invoke will call into plug-in code, and there's no telling what the plug-in can do.
+ // (including destroying the plug-in). Because of this, we make sure to keep the plug-in alive until
+ // the call has finished.
+ NPRuntimeObjectMap::PluginProtector protector(thisObject->m_objectMap);
+
+ // First, check if the NPObject has a property with this name.
+ if (thisObject->m_npObject->_class->hasProperty && thisObject->m_npObject->_class->hasProperty(thisObject->m_npObject, npIdentifier)) {
+ slot.setCustom(thisObject, static_cast<unsigned>(JSC::PropertyAttribute::DontDelete), propertyGetter);
+ return true;
+ }
+
+ // Second, check if the NPObject has a method with this name.
+ if (thisObject->m_npObject->_class->hasMethod && thisObject->m_npObject->_class->hasMethod(thisObject->m_npObject, npIdentifier)) {
+ slot.setCustom(thisObject, JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly, methodGetter);
+ return true;
+ }
+
+ return false;
+}
+
+bool JSNPObject::put(JSCell* cell, JSGlobalObject* lexicalGlobalObject, PropertyName propertyName, JSValue value, PutPropertySlot&)
+{
+ VM& vm = lexicalGlobalObject->vm();
+ auto scope = DECLARE_THROW_SCOPE(vm);
+
+ JSNPObject* thisObject = JSC::jsCast<JSNPObject*>(cell);
+ ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+ if (!thisObject->m_npObject) {
+ throwInvalidAccessError(lexicalGlobalObject, scope);
+ return false;
+ }
+
+ NPIdentifier npIdentifier = npIdentifierFromIdentifier(propertyName);
+ // If the propertyName is symbol.
+ if (!npIdentifier)
+ return false;
+
+ if (!thisObject->m_npObject->_class->hasProperty || !thisObject->m_npObject->_class->hasProperty(thisObject->m_npObject, npIdentifier)) {
+ // FIXME: Should we throw an exception here?
+ return false;
+ }
+
+ if (!thisObject->m_npObject->_class->setProperty)
+ return false;
+
+ NPVariant variant;
+ thisObject->m_objectMap->convertJSValueToNPVariant(lexicalGlobalObject, value, variant);
+
+ // Calling NPClass::setProperty will call into plug-in code, and there's no telling what the plug-in can do.
+ // (including destroying the plug-in). Because of this, we make sure to keep the plug-in alive until
+ // the call has finished.
+ NPRuntimeObjectMap::PluginProtector protector(thisObject->m_objectMap);
+
+ bool result = false;
+ {
+ JSLock::DropAllLocks dropAllLocks(commonVM());
+ result = thisObject->m_npObject->_class->setProperty(thisObject->m_npObject, npIdentifier, &variant);
+
+ NPRuntimeObjectMap::moveGlobalExceptionToExecState(lexicalGlobalObject);
+
+ // FIXME: Should we throw an exception if setProperty returns false?
+ }
+
+ releaseNPVariantValue(&variant);
+ return result;
+}
+
+bool JSNPObject::deleteProperty(JSCell* cell, JSGlobalObject* lexicalGlobalObject, PropertyName propertyName, DeletePropertySlot& slot)
+{
+ return jsCast<JSNPObject*>(cell)->deleteProperty(lexicalGlobalObject, npIdentifierFromIdentifier(propertyName));
+}
+
+bool JSNPObject::deletePropertyByIndex(JSCell* cell, JSGlobalObject* lexicalGlobalObject, unsigned propertyName)
+{
+ return jsCast<JSNPObject*>(cell)->deleteProperty(lexicalGlobalObject, static_cast<NPIdentifier>(IdentifierRep::get(propertyName)));
+}
+
+bool JSNPObject::deleteProperty(JSGlobalObject* lexicalGlobalObject, NPIdentifier propertyName)
+{
+ VM& vm = lexicalGlobalObject->vm();
+ auto scope = DECLARE_THROW_SCOPE(vm);
+
+ ASSERT_THIS_GC_OBJECT_INHERITS(info());
+
+ // If the propertyName is symbol.
+ if (!propertyName)
+ return false;
+
+ if (!m_npObject) {
+ throwInvalidAccessError(lexicalGlobalObject, scope);
+ return false;
+ }
+
+ if (!m_npObject->_class->removeProperty) {
+ // FIXME: Should we throw an exception here?
+ return false;
+ }
+
+ // Calling NPClass::setProperty will call into plug-in code, and there's no telling what the plug-in can do.
+ // (including destroying the plug-in). Because of this, we make sure to keep the plug-in alive until
+ // the call has finished.
+ NPRuntimeObjectMap::PluginProtector protector(m_objectMap);
+
+ {
+ JSLock::DropAllLocks dropAllLocks(commonVM());
+
+ // FIXME: Should we throw an exception if removeProperty returns false?
+ if (!m_npObject->_class->removeProperty(m_npObject, propertyName))
+ return false;
+
+ NPRuntimeObjectMap::moveGlobalExceptionToExecState(lexicalGlobalObject);
+ }
+
+ return true;
+}
+
+void JSNPObject::getOwnPropertyNames(JSObject* object, JSGlobalObject* lexicalGlobalObject, PropertyNameArray& propertyNameArray, DontEnumPropertiesMode)
+{
+ VM& vm = lexicalGlobalObject->vm();
+ auto scope = DECLARE_THROW_SCOPE(vm);
+
+ JSNPObject* thisObject = jsCast<JSNPObject*>(object);
+ ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+ if (!thisObject->m_npObject) {
+ throwInvalidAccessError(lexicalGlobalObject, scope);
+ return;
+ }
+
+ if (!NP_CLASS_STRUCT_VERSION_HAS_ENUM(thisObject->m_npObject->_class) || !thisObject->m_npObject->_class->enumerate)
+ return;
+
+ NPIdentifier* identifiers = 0;
+ uint32_t identifierCount = 0;
+
+ // Calling NPClass::enumerate will call into plug-in code, and there's no telling what the plug-in can do.
+ // (including destroying the plug-in). Because of this, we make sure to keep the plug-in alive until
+ // the call has finished.
+ NPRuntimeObjectMap::PluginProtector protector(thisObject->m_objectMap);
+
+ {
+ JSLock::DropAllLocks dropAllLocks(commonVM());
+
+ // FIXME: Should we throw an exception if enumerate returns false?
+ if (!thisObject->m_npObject->_class->enumerate(thisObject->m_npObject, &identifiers, &identifierCount))
+ return;
+
+ NPRuntimeObjectMap::moveGlobalExceptionToExecState(lexicalGlobalObject);
+ }
+
+ for (uint32_t i = 0; i < identifierCount; ++i) {
+ IdentifierRep* identifierRep = static_cast<IdentifierRep*>(identifiers[i]);
+
+ Identifier identifier;
+ if (identifierRep->isString()) {
+ const char* string = identifierRep->string();
+ int length = strlen(string);
+
+ identifier = Identifier::fromString(vm, String::fromUTF8WithLatin1Fallback(string, length));
+ } else
+ identifier = Identifier::from(vm, identifierRep->number());
+
+ propertyNameArray.add(identifier);
+ }
+
+ npnMemFree(identifiers);
+}
+
+JSC_DEFINE_CUSTOM_GETTER(propertyGetter, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName propertyName))
+{
+ VM& vm = lexicalGlobalObject->vm();
+ auto scope = DECLARE_THROW_SCOPE(vm);
+
+ JSNPObject* thisObj = jsCast<JSNPObject*>(JSValue::decode(thisValue));
+ ASSERT_GC_OBJECT_INHERITS(thisObj, JSNPObject::info());
+
+ if (!thisObj->npObject())
+ return JSValue::encode(throwInvalidAccessError(lexicalGlobalObject, scope));
+
+ if (!thisObj->npObject()->_class->getProperty)
+ return JSValue::encode(jsUndefined());
+
+ NPVariant result;
+ VOID_TO_NPVARIANT(result);
+
+ // Calling NPClass::getProperty will call into plug-in code, and there's no telling what the plug-in can do.
+ // (including destroying the plug-in). Because of this, we make sure to keep the plug-in alive until
+ // the call has finished.
+ NPRuntimeObjectMap::PluginProtector protector(thisObj->objectMap());
+
+ bool returnValue;
+ {
+ JSLock::DropAllLocks dropAllLocks(commonVM());
+ NPIdentifier npIdentifier = npIdentifierFromIdentifier(propertyName);
+ // If the propertyName is symbol.
+ if (!npIdentifier)
+ return JSValue::encode(jsUndefined());
+
+ returnValue = thisObj->npObject()->_class->getProperty(thisObj->npObject(), npIdentifier, &result);
+
+ NPRuntimeObjectMap::moveGlobalExceptionToExecState(lexicalGlobalObject);
+ }
+
+ if (!returnValue)
+ return JSValue::encode(jsUndefined());
+
+ JSValue propertyValue = thisObj->objectMap()->convertNPVariantToJSValue(thisObj->globalObject(), result);
+ releaseNPVariantValue(&result);
+ return JSValue::encode(propertyValue);
+}
+
+JSC_DEFINE_CUSTOM_GETTER(methodGetter, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName propertyName))
+{
+ VM& vm = lexicalGlobalObject->vm();
+ auto scope = DECLARE_THROW_SCOPE(vm);
+
+ JSNPObject* thisObj = jsCast<JSNPObject*>(JSValue::decode(thisValue));
+ ASSERT_GC_OBJECT_INHERITS(thisObj, JSNPObject::info());
+
+ if (!thisObj->npObject())
+ return JSValue::encode(throwInvalidAccessError(lexicalGlobalObject, scope));
+
+ NPIdentifier npIdentifier = npIdentifierFromIdentifier(propertyName);
+ // If the propertyName is symbol.
+ if (!npIdentifier)
+ return JSValue::encode(throwInvalidAccessError(lexicalGlobalObject, scope));
+
+ return JSValue::encode(JSNPMethod::create(thisObj->globalObject(), propertyName.publicName(), npIdentifier));
+}
+
+GCClient::IsoSubspace* JSNPObject::subspaceForImpl(VM& vm)
+{
+ static NeverDestroyed<IsoSubspacePerVM> perVM([] (Heap& heap) { return ISO_SUBSPACE_PARAMETERS(heap.destructibleObjectHeapCellType, JSNPObject); });
+ return &perVM.get().clientIsoSubspaceforVM(vm);
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/JSNPObject.h webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/JSNPObject.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/JSNPObject.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/JSNPObject.h 2022-08-26 14:18:15.005022462 -0500
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2010-2019 Apple 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 INC. 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 INC. 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.
+ */
+
+#ifndef JSNPObject_h
+#define JSNPObject_h
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include <JavaScriptCore/JSGlobalObject.h>
+#include <JavaScriptCore/JSObject.h>
+#include <JavaScriptCore/ObjectPrototype.h>
+
+typedef void* NPIdentifier;
+struct NPObject;
+
+namespace WebKit {
+
+class NPRuntimeObjectMap;
+
+// JSNPObject is a JSObject that wraps an NPObject.
+
+class JSNPObject final : public JSC::JSDestructibleObject {
+public:
+ using Base = JSC::JSDestructibleObject;
+ static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetOwnPropertyNames | JSC::OverridesGetCallData | JSC::OverridesPut | JSC::GetOwnPropertySlotMayBeWrongAboutDontEnum;
+
+ template<typename CellType, JSC::SubspaceAccess>
+ static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+ {
+ return subspaceForImpl(vm);
+ }
+
+ static JSNPObject* create(JSC::JSGlobalObject* globalObject, NPRuntimeObjectMap* objectMap, NPObject* npObject)
+ {
+ JSC::Structure* structure = createStructure(globalObject->vm(), globalObject, globalObject->objectPrototype());
+ JSNPObject* object = new (JSC::allocateCell<JSNPObject>(globalObject->vm())) JSNPObject(globalObject, structure, objectMap, npObject);
+ object->finishCreation(globalObject);
+ return object;
+ }
+
+ ~JSNPObject();
+ static void destroy(JSCell*);
+
+ void invalidate();
+
+ // Used to invalidate an NPObject asynchronously.
+ NPObject* leakNPObject();
+
+ JSC::JSValue callMethod(JSC::JSGlobalObject*, JSC::CallFrame*, NPIdentifier methodName);
+ JSC::JSValue callObject(JSC::JSGlobalObject*, JSC::CallFrame*);
+ JSC::JSValue callConstructor(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+ DECLARE_INFO;
+
+ NPObject* npObject() const { return m_npObject; }
+ NPRuntimeObjectMap* objectMap() const { return m_objectMap; }
+
+private:
+ static JSC::GCClient::IsoSubspace* subspaceForImpl(JSC::VM&);
+
+ JSNPObject(JSC::JSGlobalObject*, JSC::Structure*, NPRuntimeObjectMap*, NPObject*);
+ void finishCreation(JSC::JSGlobalObject*);
+
+ static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+ {
+ return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+ }
+
+ static JSC::CallData getCallData(JSC::JSCell*);
+ static JSC::CallData getConstructData(JSC::JSCell*);
+
+ static bool getOwnPropertySlot(JSC::JSObject*, JSC::JSGlobalObject*, JSC::PropertyName, JSC::PropertySlot&);
+ static bool put(JSC::JSCell*, JSC::JSGlobalObject*, JSC::PropertyName, JSC::JSValue, JSC::PutPropertySlot&);
+
+ static bool deleteProperty(JSC::JSCell*, JSC::JSGlobalObject*, JSC::PropertyName, JSC::DeletePropertySlot&);
+ static bool deletePropertyByIndex(JSC::JSCell*, JSC::JSGlobalObject*, unsigned propertyName);
+
+ bool deleteProperty(JSC::JSGlobalObject*, NPIdentifier propertyName);
+
+ static void getOwnPropertyNames(JSC::JSObject*, JSC::JSGlobalObject*, JSC::PropertyNameArray&, JSC::DontEnumPropertiesMode);
+
+ NPRuntimeObjectMap* m_objectMap;
+ NPObject* m_npObject;
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif // JSNPObject_h
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NetscapeBrowserFuncs.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NetscapeBrowserFuncs.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NetscapeBrowserFuncs.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NetscapeBrowserFuncs.cpp 2022-08-26 14:18:15.009022482 -0500
@@ -0,0 +1,1049 @@
+/*
+ * Copyright (C) 2010-2018 Apple 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 INC. 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 INC. 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 "config.h"
+#include "NetscapeBrowserFuncs.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "NPRuntimeUtilities.h"
+#include "NetscapePlugin.h"
+#include "PluginController.h"
+#include <WebCore/HTTPHeaderMap.h>
+#include <WebCore/HTTPHeaderNames.h>
+#include <WebCore/IdentifierRep.h>
+#include <WebCore/NotImplemented.h>
+#include <WebCore/ProtectionSpace.h>
+#include <WebCore/SharedBuffer.h>
+#include <memory>
+#include <utility>
+#include <wtf/text/StringBuilder.h>
+#include <wtf/text/StringToIntegerConversion.h>
+
+#if PLATFORM(COCOA)
+#include <wtf/MachSendRight.h>
+#endif
+
+#if PLATFORM(X11)
+#include <WebCore/PlatformDisplayX11.h>
+#endif
+
+namespace WebKit {
+using namespace WebCore;
+
+// Helper class for delaying destruction of a plug-in.
+class PluginDestructionProtector {
+public:
+ explicit PluginDestructionProtector(NetscapePlugin* plugin)
+ {
+ if (plugin)
+ m_protector = makeUnique<PluginController::PluginDestructionProtector>(static_cast<Plugin*>(plugin)->controller());
+ }
+
+private:
+ std::unique_ptr<PluginController::PluginDestructionProtector> m_protector;
+};
+
+static bool startsWithBlankLine(const char* bytes, unsigned length)
+{
+ return length > 0 && bytes[0] == '\n';
+}
+
+static int locationAfterFirstBlankLine(const char* bytes, unsigned length)
+{
+ for (unsigned i = 0; i < length - 4; i++) {
+ // Support for Acrobat. It sends "\n\n".
+ if (bytes[i] == '\n' && bytes[i + 1] == '\n')
+ return i + 2;
+
+ // Returns the position after 2 CRLF's or 1 CRLF if it is the first line.
+ if (bytes[i] == '\r' && bytes[i + 1] == '\n') {
+ i += 2;
+ if (i == 2)
+ return i;
+
+ if (bytes[i] == '\n') {
+ // Support for Director. It sends "\r\n\n" (3880387).
+ return i + 1;
+ }
+
+ if (bytes[i] == '\r' && bytes[i + 1] == '\n') {
+ // Support for Flash. It sends "\r\n\r\n" (3758113).
+ return i + 2;
+ }
+ }
+ }
+
+ return -1;
+}
+
+static const char* findEndOfLine(const char* bytes, unsigned length)
+{
+ // According to the HTTP specification EOL is defined as
+ // a CRLF pair. Unfortunately, some servers will use LF
+ // instead. Worse yet, some servers will use a combination
+ // of both (e.g. <header>CRLFLF<body>), so findEOL needs
+ // to be more forgiving. It will now accept CRLF, LF or
+ // CR.
+ //
+ // It returns 0 if EOLF is not found or it will return
+ // a pointer to the first terminating character.
+ for (unsigned i = 0; i < length; i++) {
+ if (bytes[i] == '\n')
+ return bytes + i;
+ if (bytes[i] == '\r') {
+ // Check to see if spanning buffer bounds
+ // (CRLF is across reads). If so, wait for
+ // next read.
+ if (i + 1 == length)
+ break;
+
+ return bytes + i;
+ }
+ }
+
+ return 0;
+}
+
+static String capitalizeRFC822HeaderFieldName(const String& name)
+{
+ bool capitalizeCharacter = true;
+ StringBuilder result;
+ for (unsigned i = 0; i < name.length(); i++) {
+ result.append(capitalizeCharacter ? toASCIIUpper(name[i]) : toASCIILower(name[i]));
+ if (name[i] == '-')
+ capitalizeCharacter = true;
+ else
+ capitalizeCharacter = false;
+ }
+ return result.toString();
+}
+
+static HTTPHeaderMap parseRFC822HeaderFields(const char* bytes, unsigned length)
+{
+ String lastHeaderKey;
+ HTTPHeaderMap headerFields;
+
+ // Loop over lines until we're past the header, or we can't find any more end-of-lines
+ while (const char* endOfLine = findEndOfLine(bytes, length)) {
+ const char* line = bytes;
+ int lineLength = endOfLine - bytes;
+
+ // Move bytes to the character after the terminator as returned by findEndOfLine.
+ bytes = endOfLine + 1;
+ if ((*endOfLine == '\r') && (*bytes == '\n'))
+ bytes++; // Safe since findEndOfLine won't return a spanning CRLF.
+
+ length -= (bytes - line);
+ if (!lineLength) {
+ // Blank line; we're at the end of the header
+ break;
+ }
+
+ if (*line == ' ' || *line == '\t') {
+ // Continuation of the previous header
+ if (lastHeaderKey.isNull()) {
+ // malformed header; ignore it and continue
+ continue;
+ }
+
+ // Merge the continuation of the previous header
+ String currentValue = headerFields.get(lastHeaderKey);
+ String newValue(line, lineLength);
+
+ headerFields.set(lastHeaderKey, currentValue + newValue);
+ } else {
+ // Brand new header
+ const char* colon = line;
+ while (*colon != ':' && colon != endOfLine)
+ colon++;
+
+ if (colon == endOfLine) {
+ // malformed header; ignore it and continue
+ continue;
+ }
+
+ lastHeaderKey = capitalizeRFC822HeaderFieldName(String(line, colon - line));
+ String value;
+
+ for (colon++; colon != endOfLine; colon++) {
+ if (*colon != ' ' && *colon != '\t')
+ break;
+ }
+ if (colon == endOfLine)
+ value = emptyString();
+ else
+ value = String(colon, endOfLine - colon);
+
+ String oldValue = headerFields.get(lastHeaderKey);
+ if (!oldValue.isNull())
+ value = oldValue + ", " + value;
+
+ headerFields.set(lastHeaderKey, value);
+ }
+ }
+
+ return headerFields;
+}
+
+static NPError parsePostBuffer(bool isFile, const char *buffer, uint32_t length, bool parseHeaders, HTTPHeaderMap& headerFields, Vector<uint8_t>& bodyData)
+{
+ RefPtr<SharedBuffer> fileContents;
+ const char* postBuffer = 0;
+ uint32_t postBufferSize = 0;
+
+ if (isFile) {
+ fileContents = SharedBuffer::createWithContentsOfFile(String::fromUTF8(buffer));
+ if (!fileContents)
+ return NPERR_FILE_NOT_FOUND;
+
+ postBuffer = fileContents->dataAsCharPtr();
+ postBufferSize = fileContents->size();
+
+ // FIXME: The NPAPI spec states that the file should be deleted here.
+ } else {
+ postBuffer = buffer;
+ postBufferSize = length;
+ }
+
+ if (parseHeaders) {
+ if (startsWithBlankLine(postBuffer, postBufferSize)) {
+ postBuffer++;
+ postBufferSize--;
+ } else {
+ int location = locationAfterFirstBlankLine(postBuffer, postBufferSize);
+ if (location != -1) {
+ // If the blank line is somewhere in the middle of the buffer, everything before is the header
+ headerFields = parseRFC822HeaderFields(postBuffer, location);
+ unsigned dataLength = postBufferSize - location;
+
+ // Sometimes plugins like to set Content-Length themselves when they post,
+ // but WebFoundation does not like that. So we will remove the header
+ // and instead truncate the data to the requested length.
+ String contentLength = headerFields.get(HTTPHeaderName::ContentLength);
+
+ if (!contentLength.isNull())
+ dataLength = std::min(parseIntegerAllowingTrailingJunk<unsigned>(contentLength).value_or(0), dataLength);
+ headerFields.remove(HTTPHeaderName::ContentLength);
+
+ postBuffer += location;
+ postBufferSize = dataLength;
+ }
+ }
+ }
+
+ ASSERT(bodyData.isEmpty());
+ bodyData.append(postBuffer, postBufferSize);
+
+ return NPERR_NO_ERROR;
+}
+
+static String makeURLString(const char* url)
+{
+ String urlString(url);
+
+ // Strip return characters.
+ urlString.replaceWithLiteral('\r', "");
+ urlString.replaceWithLiteral('\n', "");
+
+ return urlString;
+}
+
+static NPError NPN_GetURL(NPP npp, const char* url, const char* target)
+{
+ if (!url)
+ return NPERR_GENERIC_ERROR;
+
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ plugin->loadURL("GET", makeURLString(url), target, HTTPHeaderMap(), Vector<uint8_t>(), false, 0);
+
+ return NPERR_GENERIC_ERROR;
+}
+
+static NPError NPN_PostURL(NPP npp, const char* url, const char* target, uint32_t len, const char* buf, NPBool file)
+{
+ HTTPHeaderMap headerFields;
+ Vector<uint8_t> postData;
+
+ // NPN_PostURL only allows headers if the post buffer points to a file.
+ bool parseHeaders = file;
+
+ NPError error = parsePostBuffer(file, buf, len, parseHeaders, headerFields, postData);
+ if (error != NPERR_NO_ERROR)
+ return error;
+
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ plugin->loadURL("POST", makeURLString(url), target, WTFMove(headerFields), postData, false, 0);
+ return NPERR_NO_ERROR;
+}
+
+static NPError NPN_RequestRead(NPStream*, NPByteRange*)
+{
+ notImplemented();
+ return NPERR_GENERIC_ERROR;
+}
+
+static NPError NPN_NewStream(NPP, NPMIMEType, const char*, NPStream**)
+{
+ notImplemented();
+ return NPERR_GENERIC_ERROR;
+}
+
+static int32_t NPN_Write(NPP, NPStream*, int32_t, void*)
+{
+ notImplemented();
+ return -1;
+}
+
+static NPError NPN_DestroyStream(NPP npp, NPStream* stream, NPReason reason)
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+
+ return plugin->destroyStream(stream, reason);
+}
+
+static void NPN_Status(NPP npp, const char* message)
+{
+ String statusbarText;
+ if (!message)
+ statusbarText = emptyString();
+ else
+ statusbarText = String::fromUTF8WithLatin1Fallback(message, strlen(message));
+
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ plugin->setStatusbarText(statusbarText);
+}
+
+static const char* NPN_UserAgent(NPP npp)
+{
+ return NetscapePlugin::userAgent(npp);
+}
+
+static void* NPN_MemAlloc(uint32_t size)
+{
+ return npnMemAlloc(size);
+}
+
+static void NPN_MemFree(void* ptr)
+{
+ npnMemFree(ptr);
+}
+
+static uint32_t NPN_MemFlush(uint32_t)
+{
+ return 0;
+}
+
+static void NPN_ReloadPlugins(NPBool)
+{
+ notImplemented();
+}
+
+static JRIEnv* NPN_GetJavaEnv(void)
+{
+ notImplemented();
+ return 0;
+}
+
+static jref NPN_GetJavaPeer(NPP)
+{
+ notImplemented();
+ return 0;
+}
+
+static NPError NPN_GetURLNotify(NPP npp, const char* url, const char* target, void* notifyData)
+{
+ if (!url)
+ return NPERR_GENERIC_ERROR;
+
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ plugin->loadURL("GET", makeURLString(url), target, HTTPHeaderMap(), Vector<uint8_t>(), true, notifyData);
+
+ return NPERR_NO_ERROR;
+}
+
+static NPError NPN_PostURLNotify(NPP npp, const char* url, const char* target, uint32_t len, const char* buf, NPBool file, void* notifyData)
+{
+ HTTPHeaderMap headerFields;
+ Vector<uint8_t> postData;
+ NPError error = parsePostBuffer(file, buf, len, true, headerFields, postData);
+ if (error != NPERR_NO_ERROR)
+ return error;
+
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ plugin->loadURL("POST", makeURLString(url), target, headerFields, postData, true, notifyData);
+ return NPERR_NO_ERROR;
+}
+
+#if PLATFORM(COCOA)
+// Whether the browser supports compositing of Core Animation plug-ins.
+static const unsigned WKNVSupportsCompositingCoreAnimationPluginsBool = 74656;
+
+// Whether the browser expects a non-retained Core Animation layer.
+static const unsigned WKNVExpectsNonretainedLayer = 74657;
+
+// 74658 and 74659 are no longer implemented.
+
+#endif
+
+static NPError NPN_GetValue(NPP npp, NPNVariable variable, void *value)
+{
+ switch (static_cast<unsigned>(variable)) {
+ case NPNVWindowNPObject: {
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ PluginDestructionProtector protector(plugin.get());
+
+ NPObject* windowNPObject = plugin->windowScriptNPObject();
+ if (!windowNPObject)
+ return NPERR_GENERIC_ERROR;
+
+ *(NPObject**)value = windowNPObject;
+ break;
+ }
+ case NPNVPluginElementNPObject: {
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ PluginDestructionProtector protector(plugin.get());
+
+ NPObject* pluginElementNPObject = plugin->pluginElementNPObject();
+ *(NPObject**)value = pluginElementNPObject;
+ break;
+ }
+ case NPNVprivateModeBool: {
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+
+ *(NPBool*)value = plugin->isPrivateBrowsingEnabled();
+ break;
+ }
+
+ case NPNVmuteAudioBool: {
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ *(NPBool*)value = plugin->isMuted();
+ break;
+ }
+#if PLATFORM(COCOA)
+ case NPNVsupportsCoreGraphicsBool:
+ // Always claim to support the Core Graphics drawing model.
+ *(NPBool*)value = true;
+ break;
+
+ case WKNVSupportsCompositingCoreAnimationPluginsBool:
+ case NPNVsupportsCoreAnimationBool: {
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+
+ *(NPBool*)value = plugin->isAcceleratedCompositingEnabled();
+ break;
+ }
+ case NPNVcontentsScaleFactor: {
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+
+ *(double*)value = plugin->contentsScaleFactor();
+ break;
+ }
+ case NPNVsupportsCocoaBool:
+ // Always claim to support the Cocoa event model.
+ *(NPBool*)value = true;
+ break;
+
+ case NPNVsupportsUpdatedCocoaTextInputBool: {
+ // The plug-in is asking whether we support the updated Cocoa text input model.
+ // If we haven't yet delivered a key down event to the plug-in, we can opt into the updated
+ // model and say that we support it. Otherwise, we'll just fall back and say that we don't support it.
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+
+ bool supportsUpdatedTextInput = !plugin->hasHandledAKeyDownEvent();
+ if (supportsUpdatedTextInput)
+ plugin->setPluginWantsLegacyCocoaTextInput(false);
+
+ *reinterpret_cast<NPBool*>(value) = supportsUpdatedTextInput;
+ break;
+ }
+
+ case WKNVCALayerRenderServerPort: {
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+
+ *(mach_port_t*)value = plugin->compositingRenderServerPort().sendRight();
+ break;
+ }
+
+ case WKNVExpectsNonretainedLayer: {
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+
+ // Asking for this will make us expect a non-retained layer from the plug-in.
+ plugin->setPluginReturnsNonretainedLayer(true);
+ *(NPBool*)value = true;
+ break;
+ }
+#elif PLATFORM(X11)
+ case NPNVxDisplay: {
+ if (!npp)
+ return NPERR_GENERIC_ERROR;
+ auto& display = PlatformDisplay::sharedDisplay();
+ if (display.type() != PlatformDisplay::Type::X11)
+ return NPERR_GENERIC_ERROR;
+ *reinterpret_cast<Display**>(value) = downcast<PlatformDisplayX11>(display).native();
+ break;
+ }
+ case NPNVSupportsXEmbedBool:
+ *static_cast<NPBool*>(value) = PlatformDisplay::sharedDisplay().type() == PlatformDisplay::Type::X11;
+ break;
+ case NPNVSupportsWindowless:
+ *static_cast<NPBool*>(value) = true;
+ break;
+
+ case NPNVToolkit: {
+ // Gtk based plugins need to be assured about the toolkit version.
+ const uint32_t expectedGtkToolKitVersion = 2;
+ *reinterpret_cast<uint32_t*>(value) = expectedGtkToolKitVersion;
+ break;
+ }
+
+ // TODO: implement NPNVnetscapeWindow once we want to support windowed plugins.
+#endif
+ default:
+ notImplemented();
+ return NPERR_GENERIC_ERROR;
+ }
+
+ return NPERR_NO_ERROR;
+}
+
+static NPError NPN_SetValue(NPP npp, NPPVariable variable, void *value)
+{
+ switch (variable) {
+#if PLATFORM(COCOA)
+ case NPPVpluginDrawingModel: {
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+
+ NPDrawingModel drawingModel = static_cast<NPDrawingModel>(reinterpret_cast<uintptr_t>(value));
+ return plugin->setDrawingModel(drawingModel);
+ }
+
+ case NPPVpluginEventModel: {
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+
+ NPEventModel eventModel = static_cast<NPEventModel>(reinterpret_cast<uintptr_t>(value));
+ return plugin->setEventModel(eventModel);
+ }
+#endif
+
+ case NPPVpluginWindowBool: {
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ plugin->setIsWindowed(value);
+ return NPERR_NO_ERROR;
+ }
+
+ case NPPVpluginTransparentBool: {
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ plugin->setIsTransparent(value);
+ return NPERR_NO_ERROR;
+ }
+
+ case NPPVpluginIsPlayingAudio: {
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ plugin->setIsPlayingAudio(value);
+ return NPERR_NO_ERROR;
+ }
+
+ default:
+ notImplemented();
+ return NPERR_GENERIC_ERROR;
+ }
+}
+
+static void NPN_InvalidateRect(NPP npp, NPRect* invalidRect)
+{
+#if PLUGIN_ARCHITECTURE(UNIX)
+ // NSPluginWrapper, a plugin wrapper binary that allows running 32-bit plugins
+ // on 64-bit architectures typically used in X11, will sometimes give us a null NPP here.
+ if (!npp)
+ return;
+#endif
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ plugin->invalidate(invalidRect);
+}
+
+static void NPN_InvalidateRegion(NPP npp, NPRegion)
+{
+ // FIXME: We could at least figure out the bounding rectangle of the invalid region.
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ plugin->invalidate(0);
+}
+
+static void NPN_ForceRedraw(NPP)
+{
+ notImplemented();
+}
+
+static NPIdentifier NPN_GetStringIdentifier(const NPUTF8 *name)
+{
+ return static_cast<NPIdentifier>(IdentifierRep::get(name));
+}
+
+static void NPN_GetStringIdentifiers(const NPUTF8 **names, int32_t nameCount, NPIdentifier *identifiers)
+{
+ ASSERT(names);
+ ASSERT(identifiers);
+
+ if (!names || !identifiers)
+ return;
+
+ for (int32_t i = 0; i < nameCount; ++i)
+ identifiers[i] = NPN_GetStringIdentifier(names[i]);
+}
+
+static NPIdentifier NPN_GetIntIdentifier(int32_t intid)
+{
+ return static_cast<NPIdentifier>(IdentifierRep::get(intid));
+}
+
+static bool NPN_IdentifierIsString(NPIdentifier identifier)
+{
+ return static_cast<IdentifierRep*>(identifier)->isString();
+}
+
+static NPUTF8 *NPN_UTF8FromIdentifier(NPIdentifier identifier)
+{
+ const char* string = static_cast<IdentifierRep*>(identifier)->string();
+ if (!string)
+ return 0;
+
+ uint32_t stringLength = strlen(string);
+ char* utf8String = npnMemNewArray<char>(stringLength + 1);
+ memcpy(utf8String, string, stringLength);
+ utf8String[stringLength] = '\0';
+
+ return utf8String;
+}
+
+static int32_t NPN_IntFromIdentifier(NPIdentifier identifier)
+{
+ return static_cast<IdentifierRep*>(identifier)->number();
+}
+
+static NPObject* NPN_CreateObject(NPP npp, NPClass *npClass)
+{
+ return createNPObject(npp, npClass);
+}
+
+static NPObject *NPN_RetainObject(NPObject *npObject)
+{
+ retainNPObject(npObject);
+ return npObject;
+}
+
+static void NPN_ReleaseObject(NPObject *npObject)
+{
+ releaseNPObject(npObject);
+}
+
+static bool NPN_Invoke(NPP npp, NPObject *npObject, NPIdentifier methodName, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ PluginDestructionProtector protector(plugin.get());
+
+ if (npObject->_class->invoke)
+ return npObject->_class->invoke(npObject, methodName, arguments, argumentCount, result);
+
+ return false;
+}
+
+static bool NPN_InvokeDefault(NPP npp, NPObject *npObject, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ PluginDestructionProtector protector(plugin.get());
+
+ if (npObject->_class->invokeDefault)
+ return npObject->_class->invokeDefault(npObject, arguments, argumentCount, result);
+
+ return false;
+}
+
+static bool NPN_Evaluate(NPP npp, NPObject *npObject, NPString *script, NPVariant* result)
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ PluginDestructionProtector protector(plugin.get());
+
+ String scriptString = String::fromUTF8WithLatin1Fallback(script->UTF8Characters, script->UTF8Length);
+
+ return plugin->evaluate(npObject, scriptString, result);
+}
+
+static bool NPN_GetProperty(NPP npp, NPObject* npObject, NPIdentifier propertyName, NPVariant* result)
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ PluginDestructionProtector protector(plugin.get());
+
+ if (npObject->_class->getProperty)
+ return npObject->_class->getProperty(npObject, propertyName, result);
+
+ return false;
+}
+
+static bool NPN_SetProperty(NPP npp, NPObject* npObject, NPIdentifier propertyName, const NPVariant* value)
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ PluginDestructionProtector protector(plugin.get());
+
+ if (npObject->_class->setProperty)
+ return npObject->_class->setProperty(npObject, propertyName, value);
+
+ return false;
+}
+
+static bool NPN_RemoveProperty(NPP npp, NPObject* npObject, NPIdentifier propertyName)
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ PluginDestructionProtector protector(plugin.get());
+
+ if (npObject->_class->removeProperty)
+ return npObject->_class->removeProperty(npObject, propertyName);
+
+ return false;
+}
+
+static bool NPN_HasProperty(NPP npp, NPObject* npObject, NPIdentifier propertyName)
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ PluginDestructionProtector protector(plugin.get());
+
+ if (npObject->_class->hasProperty)
+ return npObject->_class->hasProperty(npObject, propertyName);
+
+ return false;
+}
+
+static bool NPN_HasMethod(NPP npp, NPObject* npObject, NPIdentifier methodName)
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ PluginDestructionProtector protector(plugin.get());
+
+ if (npObject->_class->hasMethod)
+ return npObject->_class->hasMethod(npObject, methodName);
+
+ return false;
+}
+
+static void NPN_ReleaseVariantValue(NPVariant* variant)
+{
+ releaseNPVariantValue(variant);
+}
+
+static void NPN_SetException(NPObject*, const NPUTF8* message)
+{
+ NetscapePlugin::setException(message);
+}
+
+static void NPN_PushPopupsEnabledState(NPP npp, NPBool enabled)
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ plugin->pushPopupsEnabledState(enabled);
+}
+
+static void NPN_PopPopupsEnabledState(NPP npp)
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ plugin->popPopupsEnabledState();
+}
+
+static bool NPN_Enumerate(NPP npp, NPObject* npObject, NPIdentifier** identifiers, uint32_t* identifierCount)
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ PluginDestructionProtector protector(plugin.get());
+
+ if (NP_CLASS_STRUCT_VERSION_HAS_ENUM(npObject->_class) && npObject->_class->enumerate)
+ return npObject->_class->enumerate(npObject, identifiers, identifierCount);
+
+ return false;
+}
+
+static void NPN_PluginThreadAsyncCall(NPP npp, void (*function)(void*), void* userData)
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+
+ plugin->pluginThreadAsyncCall(function, userData);
+}
+
+static bool NPN_Construct(NPP npp, NPObject* npObject, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ PluginDestructionProtector protector(plugin.get());
+
+ if (NP_CLASS_STRUCT_VERSION_HAS_CTOR(npObject->_class) && npObject->_class->construct)
+ return npObject->_class->construct(npObject, arguments, argumentCount, result);
+
+ return false;
+}
+
+static NPError copyCString(const CString& string, char** value, uint32_t* len)
+{
+ ASSERT(!string.isNull());
+ ASSERT(value);
+ ASSERT(len);
+
+ *value = npnMemNewArray<char>(string.length());
+ if (!*value)
+ return NPERR_GENERIC_ERROR;
+
+ memcpy(*value, string.data(), string.length());
+ *len = string.length();
+ return NPERR_NO_ERROR;
+}
+
+static NPError NPN_GetValueForURL(NPP npp, NPNURLVariable variable, const char* url, char** value, uint32_t* len)
+{
+ if (!value || !len)
+ return NPERR_GENERIC_ERROR;
+
+ switch (variable) {
+ case NPNURLVCookie: {
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ PluginDestructionProtector protector(plugin.get());
+
+ String cookies = plugin->cookiesForURL(makeURLString(url));
+ if (cookies.isNull())
+ return NPERR_GENERIC_ERROR;
+
+ return copyCString(cookies.utf8(), value, len);
+ }
+
+ case NPNURLVProxy: {
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ PluginDestructionProtector protector(plugin.get());
+
+ String proxies = plugin->proxiesForURL(makeURLString(url));
+ if (proxies.isNull())
+ return NPERR_GENERIC_ERROR;
+
+ return copyCString(proxies.utf8(), value, len);
+ }
+ default:
+ notImplemented();
+ return NPERR_GENERIC_ERROR;
+ }
+}
+
+static NPError NPN_SetValueForURL(NPP npp, NPNURLVariable variable, const char* url, const char* value, uint32_t len)
+{
+ switch (variable) {
+ case NPNURLVCookie: {
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ PluginDestructionProtector protector(plugin.get());
+
+ plugin->setCookiesForURL(makeURLString(url), String(value, len));
+ return NPERR_NO_ERROR;
+ }
+
+ case NPNURLVProxy:
+ // Can't set the proxy for a URL.
+ return NPERR_GENERIC_ERROR;
+
+ default:
+ notImplemented();
+ return NPERR_GENERIC_ERROR;
+ }
+}
+
+static bool initializeProtectionSpace(const char* protocol, const char* host, int port, const char* scheme, const char* realm, ProtectionSpace& protectionSpace)
+{
+ ProtectionSpace::ServerType serverType;
+ if (equalLettersIgnoringASCIICase(protocol, "http"))
+ serverType = ProtectionSpace::ServerType::HTTP;
+ else if (equalLettersIgnoringASCIICase(protocol, "https"))
+ serverType = ProtectionSpace::ServerType::HTTPS;
+ else {
+ // We only care about http and https.
+ return false;
+ }
+
+ ProtectionSpace::AuthenticationScheme authenticationScheme = ProtectionSpace::AuthenticationScheme::Default;
+ if (serverType == ProtectionSpace::ServerType::HTTP) {
+ if (equalLettersIgnoringASCIICase(scheme, "basic"))
+ authenticationScheme = ProtectionSpace::AuthenticationScheme::HTTPBasic;
+ else if (equalLettersIgnoringASCIICase(scheme, "digest"))
+ authenticationScheme = ProtectionSpace::AuthenticationScheme::HTTPDigest;
+ }
+
+ protectionSpace = ProtectionSpace(host, port, serverType, realm, authenticationScheme);
+ return true;
+}
+
+static NPError NPN_GetAuthenticationInfo(NPP npp, const char* protocol, const char* host, int32_t port, const char* scheme,
+ const char* realm, char** username, uint32_t* usernameLength, char** password, uint32_t* passwordLength)
+{
+ if (!protocol || !host || !scheme || !realm || !username || !usernameLength || !password || !passwordLength)
+ return NPERR_GENERIC_ERROR;
+
+ ProtectionSpace protectionSpace;
+ if (!initializeProtectionSpace(protocol, host, port, scheme, realm, protectionSpace))
+ return NPERR_GENERIC_ERROR;
+
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+ String usernameString;
+ String passwordString;
+ if (!plugin->getAuthenticationInfo(protectionSpace, usernameString, passwordString))
+ return NPERR_GENERIC_ERROR;
+
+ NPError result = copyCString(usernameString.utf8(), username, usernameLength);
+ if (result != NPERR_NO_ERROR)
+ return result;
+
+ result = copyCString(passwordString.utf8(), password, passwordLength);
+ if (result != NPERR_NO_ERROR) {
+ npnMemFree(*username);
+ return result;
+ }
+
+ return NPERR_NO_ERROR;
+}
+
+static uint32_t NPN_ScheduleTimer(NPP npp, uint32_t interval, NPBool repeat, void (*timerFunc)(NPP npp, uint32_t timerID))
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+
+ return plugin->scheduleTimer(interval, repeat, timerFunc);
+}
+
+static void NPN_UnscheduleTimer(NPP npp, uint32_t timerID)
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+
+ plugin->unscheduleTimer(timerID);
+}
+
+#if PLATFORM(COCOA)
+static NPError NPN_PopUpContextMenu(NPP npp, NPMenu* menu)
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+
+ return plugin->popUpContextMenu(menu);
+}
+
+static NPBool NPN_ConvertPoint(NPP npp, double sourceX, double sourceY, NPCoordinateSpace sourceSpace, double* destX, double* destY, NPCoordinateSpace destSpace)
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+
+ double destinationX;
+ double destinationY;
+
+ bool returnValue = plugin->convertPoint(sourceX, sourceY, sourceSpace, destinationX, destinationY, destSpace);
+
+ if (destX)
+ *destX = destinationX;
+ if (destY)
+ *destY = destinationY;
+
+ return returnValue;
+}
+#endif
+
+static void NPN_URLRedirectResponse(NPP npp, void* notifyData, NPBool allow)
+{
+ RefPtr<NetscapePlugin> plugin = NetscapePlugin::fromNPP(npp);
+
+ plugin->urlRedirectResponse(notifyData, allow);
+}
+
+static void initializeBrowserFuncs(NPNetscapeFuncs &netscapeFuncs)
+{
+ netscapeFuncs.size = sizeof(NPNetscapeFuncs);
+ netscapeFuncs.version = (NP_VERSION_MAJOR << 8) | NP_VERSION_MINOR;
+
+ netscapeFuncs.geturl = NPN_GetURL;
+ netscapeFuncs.posturl = NPN_PostURL;
+ netscapeFuncs.requestread = NPN_RequestRead;
+ netscapeFuncs.newstream = NPN_NewStream;
+ netscapeFuncs.write = NPN_Write;
+ netscapeFuncs.destroystream = NPN_DestroyStream;
+ netscapeFuncs.status = NPN_Status;
+ netscapeFuncs.uagent = NPN_UserAgent;
+ netscapeFuncs.memalloc = NPN_MemAlloc;
+ netscapeFuncs.memfree = NPN_MemFree;
+ netscapeFuncs.memflush = NPN_MemFlush;
+ netscapeFuncs.reloadplugins = NPN_ReloadPlugins;
+ netscapeFuncs.getJavaEnv = NPN_GetJavaEnv;
+ netscapeFuncs.getJavaPeer = NPN_GetJavaPeer;
+ netscapeFuncs.geturlnotify = NPN_GetURLNotify;
+ netscapeFuncs.posturlnotify = NPN_PostURLNotify;
+ netscapeFuncs.getvalue = NPN_GetValue;
+ netscapeFuncs.setvalue = NPN_SetValue;
+ netscapeFuncs.invalidaterect = NPN_InvalidateRect;
+ netscapeFuncs.invalidateregion = NPN_InvalidateRegion;
+ netscapeFuncs.forceredraw = NPN_ForceRedraw;
+
+ netscapeFuncs.getstringidentifier = NPN_GetStringIdentifier;
+ netscapeFuncs.getstringidentifiers = NPN_GetStringIdentifiers;
+ netscapeFuncs.getintidentifier = NPN_GetIntIdentifier;
+ netscapeFuncs.identifierisstring = NPN_IdentifierIsString;
+ netscapeFuncs.utf8fromidentifier = NPN_UTF8FromIdentifier;
+ netscapeFuncs.intfromidentifier = NPN_IntFromIdentifier;
+ netscapeFuncs.createobject = NPN_CreateObject;
+ netscapeFuncs.retainobject = NPN_RetainObject;
+ netscapeFuncs.releaseobject = NPN_ReleaseObject;
+ netscapeFuncs.invoke = NPN_Invoke;
+ netscapeFuncs.invokeDefault = NPN_InvokeDefault;
+ netscapeFuncs.evaluate = NPN_Evaluate;
+ netscapeFuncs.getproperty = NPN_GetProperty;
+ netscapeFuncs.setproperty = NPN_SetProperty;
+ netscapeFuncs.removeproperty = NPN_RemoveProperty;
+ netscapeFuncs.hasproperty = NPN_HasProperty;
+ netscapeFuncs.hasmethod = NPN_HasMethod;
+ netscapeFuncs.releasevariantvalue = NPN_ReleaseVariantValue;
+ netscapeFuncs.setexception = NPN_SetException;
+ netscapeFuncs.pushpopupsenabledstate = NPN_PushPopupsEnabledState;
+ netscapeFuncs.poppopupsenabledstate = NPN_PopPopupsEnabledState;
+ netscapeFuncs.enumerate = NPN_Enumerate;
+ netscapeFuncs.pluginthreadasynccall = NPN_PluginThreadAsyncCall;
+ netscapeFuncs.construct = NPN_Construct;
+ netscapeFuncs.getvalueforurl = NPN_GetValueForURL;
+ netscapeFuncs.setvalueforurl = NPN_SetValueForURL;
+ netscapeFuncs.getauthenticationinfo = NPN_GetAuthenticationInfo;
+ netscapeFuncs.scheduletimer = NPN_ScheduleTimer;
+ netscapeFuncs.unscheduletimer = NPN_UnscheduleTimer;
+#if PLATFORM(COCOA)
+ netscapeFuncs.popupcontextmenu = NPN_PopUpContextMenu;
+ netscapeFuncs.convertpoint = NPN_ConvertPoint;
+#else
+ netscapeFuncs.popupcontextmenu = 0;
+ netscapeFuncs.convertpoint = 0;
+#endif
+ netscapeFuncs.urlredirectresponse = NPN_URLRedirectResponse;
+}
+
+NPNetscapeFuncs* netscapeBrowserFuncs()
+{
+ static NPNetscapeFuncs netscapeFuncs;
+ static bool initialized = false;
+
+ if (!initialized) {
+ initializeBrowserFuncs(netscapeFuncs);
+ initialized = true;
+ }
+
+ return &netscapeFuncs;
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NetscapeBrowserFuncs.h webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NetscapeBrowserFuncs.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NetscapeBrowserFuncs.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NetscapeBrowserFuncs.h 2022-08-26 14:18:15.009022482 -0500
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+ */
+
+#ifndef NetscapeBrowserFuncs_h
+#define NetscapeBrowserFuncs_h
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include <WebCore/npfunctions.h>
+
+namespace WebKit {
+
+#if PLUGIN_ARCHITECTURE(MAC)
+// The Core Animation render server port.
+static const unsigned WKNVCALayerRenderServerPort = 71879;
+#endif
+
+NPNetscapeFuncs* netscapeBrowserFuncs();
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif // NetscapeBrowserFuncs_h
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePlugin.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePlugin.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePlugin.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePlugin.cpp 2022-08-26 14:18:15.009022482 -0500
@@ -0,0 +1,1149 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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 "config.h"
+#include "NetscapePlugin.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "NPRuntimeObjectMap.h"
+#include "NPRuntimeUtilities.h"
+#include "NetscapePluginStream.h"
+#include "PluginController.h"
+#include "ShareableBitmap.h"
+#include <JavaScriptCore/JSObject.h>
+#include <WebCore/GraphicsContext.h>
+#include <WebCore/HTTPHeaderMap.h>
+#include <WebCore/IntRect.h>
+#include <WebCore/SharedBuffer.h>
+#include <utility>
+#include <wtf/URL.h>
+#include <wtf/text/CString.h>
+
+#if PLUGIN_ARCHITECTURE(UNIX)
+#include "NetscapePluginUnix.h"
+#endif
+
+#if PLATFORM(COCOA)
+#include "LayerHostingContext.h"
+#include "LayerTreeContext.h"
+#endif
+
+namespace WebKit {
+using namespace WebCore;
+
+// The plug-in that we're currently calling NPP_New for.
+static NetscapePlugin* currentNPPNewPlugin;
+
+RefPtr<NetscapePlugin> NetscapePlugin::create(RefPtr<NetscapePluginModule>&& pluginModule)
+{
+ if (!pluginModule)
+ return nullptr;
+
+ return adoptRef(*new NetscapePlugin(pluginModule.releaseNonNull()));
+}
+
+NetscapePlugin::NetscapePlugin(Ref<NetscapePluginModule>&& pluginModule)
+ : Plugin(NetscapePluginType)
+ , m_nextRequestID(0)
+ , m_pluginModule(WTFMove(pluginModule))
+ , m_npWindow()
+ , m_isStarted(false)
+#if PLATFORM(COCOA)
+ , m_isWindowed(false)
+#else
+ , m_isWindowed(true)
+#endif
+ , m_isTransparent(false)
+ , m_inNPPNew(false)
+ , m_shouldUseManualLoader(false)
+ , m_hasCalledSetWindow(false)
+ , m_isVisible(false)
+ , m_nextTimerID(0)
+#if PLATFORM(COCOA)
+ , m_drawingModel(static_cast<NPDrawingModel>(-1))
+ , m_eventModel(static_cast<NPEventModel>(-1))
+ , m_pluginReturnsNonretainedLayer(!m_pluginModule->pluginQuirks().contains(PluginQuirks::ReturnsRetainedCoreAnimationLayer))
+ , m_layerHostingMode(LayerHostingMode::InProcess)
+ , m_currentMouseEvent(0)
+ , m_pluginHasFocus(false)
+ , m_windowHasFocus(false)
+ , m_pluginWantsLegacyCocoaTextInput(true)
+ , m_isComplexTextInputEnabled(false)
+ , m_hasHandledAKeyDownEvent(false)
+ , m_ignoreNextKeyUpEventCounter(0)
+#endif
+{
+ m_npp.ndata = this;
+ m_npp.pdata = 0;
+
+ m_pluginModule->incrementLoadCount();
+}
+
+NetscapePlugin::~NetscapePlugin()
+{
+ ASSERT(!m_isStarted);
+ ASSERT(m_timers.isEmpty());
+
+ m_pluginModule->decrementLoadCount();
+}
+
+RefPtr<NetscapePlugin> NetscapePlugin::fromNPP(NPP npp)
+{
+ if (!npp)
+ return nullptr;
+
+ return static_cast<NetscapePlugin*>(npp->ndata);
+}
+
+void NetscapePlugin::invalidate(const NPRect* invalidRect)
+{
+ IntRect rect;
+
+ if (!invalidRect)
+ rect = IntRect(0, 0, m_pluginSize.width(), m_pluginSize.height());
+ else
+ rect = IntRect(invalidRect->left, invalidRect->top, invalidRect->right - invalidRect->left, invalidRect->bottom - invalidRect->top);
+
+ if (platformInvalidate(rect))
+ return;
+
+ controller()->invalidate(rect);
+}
+
+const char* NetscapePlugin::userAgent(NPP npp)
+{
+ if (npp)
+ return fromNPP(npp)->userAgent();
+
+ if (currentNPPNewPlugin)
+ return currentNPPNewPlugin->userAgent();
+
+ return 0;
+}
+
+const char* NetscapePlugin::userAgent()
+{
+ if (m_userAgent.isNull()) {
+ String userAgent = controller()->userAgent();
+ ASSERT(!userAgent.isNull());
+
+#if PLUGIN_ARCHITECTURE(MAC)
+ if (quirks().contains(PluginQuirks::AppendVersion3UserAgent))
+ userAgent.append(" Version/3.2.1");
+#endif
+
+ m_userAgent = userAgent.utf8();
+ }
+ return m_userAgent.data();
+}
+
+void NetscapePlugin::loadURL(const String& method, const String& urlString, const String& target, const HTTPHeaderMap& headerFields, const Vector<uint8_t>& httpBody,
+ bool sendNotification, void* notificationData)
+{
+ uint64_t requestID = ++m_nextRequestID;
+
+ controller()->loadURL(requestID, method, urlString, target, headerFields, httpBody, allowPopups());
+
+ if (target.isNull()) {
+ // The browser is going to send the data in a stream, create a plug-in stream.
+ auto pluginStream = NetscapePluginStream::create(*this, requestID, urlString, sendNotification, notificationData);
+ ASSERT(!m_streams.contains(requestID));
+
+ m_streams.set(requestID, WTFMove(pluginStream));
+ return;
+ }
+
+ if (sendNotification) {
+ // Eventually we are going to get a frameDidFinishLoading or frameDidFail call for this request.
+ // Keep track of the notification data so we can call NPP_URLNotify.
+ ASSERT(!m_pendingURLNotifications.contains(requestID));
+ m_pendingURLNotifications.set(requestID, std::make_pair(urlString, notificationData));
+ }
+}
+
+NPError NetscapePlugin::destroyStream(NPStream* stream, NPReason reason)
+{
+ NetscapePluginStream* pluginStream = 0;
+
+ for (StreamsMap::const_iterator it = m_streams.begin(), end = m_streams.end(); it != end; ++it) {
+ if (it->value->npStream() == stream) {
+ pluginStream = it->value.get();
+ break;
+ }
+ }
+
+ if (!pluginStream)
+ return NPERR_INVALID_INSTANCE_ERROR;
+
+ return pluginStream->destroy(reason);
+}
+
+void NetscapePlugin::setIsWindowed(bool isWindowed)
+{
+ // Once the plugin has started, it's too late to change whether the plugin is windowed or not.
+ // (This is true in Firefox and Chrome, too.) Disallow setting m_isWindowed in that case to
+ // keep our internal state consistent.
+ if (m_isStarted)
+ return;
+
+ m_isWindowed = isWindowed;
+}
+
+void NetscapePlugin::setIsTransparent(bool isTransparent)
+{
+ m_isTransparent = isTransparent;
+}
+
+void NetscapePlugin::setStatusbarText(const String& statusbarText)
+{
+ controller()->setStatusbarText(statusbarText);
+}
+
+static void (*setExceptionFunction)(const String&);
+
+void NetscapePlugin::setSetExceptionFunction(void (*function)(const String&))
+{
+ ASSERT(!setExceptionFunction || setExceptionFunction == function);
+ setExceptionFunction = function;
+}
+
+void NetscapePlugin::setException(const String& exceptionString)
+{
+ ASSERT(setExceptionFunction);
+ setExceptionFunction(exceptionString);
+}
+
+bool NetscapePlugin::evaluate(NPObject* npObject, const String& scriptString, NPVariant* result)
+{
+ return controller()->evaluate(npObject, scriptString, result, allowPopups());
+}
+
+bool NetscapePlugin::isPrivateBrowsingEnabled()
+{
+ return controller()->isPrivateBrowsingEnabled();
+}
+
+bool NetscapePlugin::isMuted() const
+{
+ return controller()->isMuted();
+}
+
+NPObject* NetscapePlugin::windowScriptNPObject()
+{
+ return controller()->windowScriptNPObject();
+}
+
+NPObject* NetscapePlugin::pluginElementNPObject()
+{
+ return controller()->pluginElementNPObject();
+}
+
+void NetscapePlugin::cancelStreamLoad(NetscapePluginStream* pluginStream)
+{
+ if (pluginStream == m_manualStream) {
+ controller()->cancelManualStreamLoad();
+ return;
+ }
+
+ // Ask the plug-in controller to cancel this stream load.
+ controller()->cancelStreamLoad(pluginStream->streamID());
+}
+
+void NetscapePlugin::removePluginStream(NetscapePluginStream* pluginStream)
+{
+ if (pluginStream == m_manualStream) {
+ m_manualStream = nullptr;
+ return;
+ }
+
+ ASSERT(m_streams.get(pluginStream->streamID()) == pluginStream);
+ m_streams.remove(pluginStream->streamID());
+}
+
+bool NetscapePlugin::isAcceleratedCompositingEnabled()
+{
+ return controller()->isAcceleratedCompositingEnabled();
+}
+
+void NetscapePlugin::pushPopupsEnabledState(bool state)
+{
+ m_popupEnabledStates.append(state);
+}
+
+void NetscapePlugin::popPopupsEnabledState()
+{
+ ASSERT(!m_popupEnabledStates.isEmpty());
+
+ m_popupEnabledStates.removeLast();
+}
+
+void NetscapePlugin::pluginThreadAsyncCall(void (*function)(void*), void* userData)
+{
+ RunLoop::main().dispatch([protectedThis = Ref { *this }, function, userData] {
+ if (!protectedThis->m_isStarted)
+ return;
+
+ function(userData);
+ });
+}
+
+NetscapePlugin::Timer::Timer(NetscapePlugin* netscapePlugin, unsigned timerID, unsigned interval, bool repeat, TimerFunc timerFunc)
+ : m_netscapePlugin(netscapePlugin)
+ , m_timerID(timerID)
+ , m_interval(interval)
+ , m_repeat(repeat)
+ , m_timerFunc(timerFunc)
+ , m_timer(RunLoop::main(), this, &Timer::timerFired)
+{
+}
+
+NetscapePlugin::Timer::~Timer()
+{
+}
+
+void NetscapePlugin::Timer::start()
+{
+ Seconds timeInterval = 1_ms * m_interval;
+
+ if (m_repeat)
+ m_timer.startRepeating(timeInterval);
+ else
+ m_timer.startOneShot(timeInterval);
+}
+
+void NetscapePlugin::Timer::stop()
+{
+ m_timer.stop();
+}
+
+void NetscapePlugin::Timer::timerFired()
+{
+ m_timerFunc(&m_netscapePlugin->m_npp, m_timerID);
+
+ if (!m_repeat)
+ m_netscapePlugin->unscheduleTimer(m_timerID);
+}
+
+uint32_t NetscapePlugin::scheduleTimer(unsigned interval, bool repeat, void (*timerFunc)(NPP, unsigned timerID))
+{
+ if (!timerFunc)
+ return 0;
+
+ // FIXME: Handle wrapping around.
+ unsigned timerID = ++m_nextTimerID;
+
+ auto timer = makeUnique<Timer>(this, timerID, interval, repeat, timerFunc);
+
+ // FIXME: Based on the plug-in visibility, figure out if we should throttle the timer, or if we should start it at all.
+ timer->start();
+ m_timers.set(timerID, WTFMove(timer));
+
+ return timerID;
+}
+
+void NetscapePlugin::unscheduleTimer(unsigned timerID)
+{
+ if (auto timer = m_timers.take(timerID))
+ timer->stop();
+}
+
+double NetscapePlugin::contentsScaleFactor()
+{
+ return controller()->contentsScaleFactor();
+}
+
+String NetscapePlugin::proxiesForURL(const String& urlString)
+{
+ return controller()->proxiesForURL(urlString);
+}
+
+String NetscapePlugin::cookiesForURL(const String& urlString)
+{
+ return controller()->cookiesForURL(urlString);
+}
+
+void NetscapePlugin::setCookiesForURL(const String& urlString, const String& cookieString)
+{
+ controller()->setCookiesForURL(urlString, cookieString);
+}
+
+bool NetscapePlugin::getAuthenticationInfo(const ProtectionSpace& protectionSpace, String& username, String& password)
+{
+ return controller()->getAuthenticationInfo(protectionSpace, username, password);
+}
+
+void NetscapePlugin::registerRedirect(NetscapePluginStream* stream, const URL& requestURL, int redirectResponseStatus, void* notificationData)
+{
+ // NPP_URLRedirectNotify may synchronously request this stream back out, so set it first
+ m_redirects.set(notificationData, std::make_pair(stream, requestURL.string()));
+ if (!NPP_URLRedirectNotify(requestURL.string().utf8().data(), redirectResponseStatus, notificationData)) {
+ m_redirects.take(notificationData);
+ controller()->continueStreamLoad(stream->streamID());
+ }
+}
+
+void NetscapePlugin::urlRedirectResponse(void* notifyData, bool allow)
+{
+ if (!m_redirects.contains(notifyData))
+ return;
+
+ auto redirect = m_redirects.take(notifyData);
+ if (!redirect.first)
+ return;
+
+ RefPtr<NetscapePluginStream> stream = redirect.first;
+ if (!allow) {
+ controller()->cancelStreamLoad(stream->streamID());
+ stream->stop(NPRES_USER_BREAK);
+ } else {
+ stream->setURL(redirect.second);
+ controller()->continueStreamLoad(stream->streamID());
+ }
+}
+
+void NetscapePlugin::setIsPlayingAudio(bool isPlayingAudio)
+{
+ controller()->setPluginIsPlayingAudio(isPlayingAudio);
+}
+
+NPError NetscapePlugin::NPP_New(NPMIMEType pluginType, uint16_t mode, int16_t argc, char* argn[], char* argv[], NPSavedData* savedData)
+{
+ return m_pluginModule->pluginFuncs().newp(pluginType, &m_npp, mode, argc, argn, argv, savedData);
+}
+
+NPError NetscapePlugin::NPP_Destroy(NPSavedData** savedData)
+{
+ return m_pluginModule->pluginFuncs().destroy(&m_npp, savedData);
+}
+
+NPError NetscapePlugin::NPP_SetWindow(NPWindow* npWindow)
+{
+ return m_pluginModule->pluginFuncs().setwindow(&m_npp, npWindow);
+}
+
+NPError NetscapePlugin::NPP_NewStream(NPMIMEType mimeType, NPStream* stream, NPBool seekable, uint16_t* streamType)
+{
+ return m_pluginModule->pluginFuncs().newstream(&m_npp, mimeType, stream, seekable, streamType);
+}
+
+NPError NetscapePlugin::NPP_DestroyStream(NPStream* stream, NPReason reason)
+{
+ return m_pluginModule->pluginFuncs().destroystream(&m_npp, stream, reason);
+}
+
+void NetscapePlugin::NPP_StreamAsFile(NPStream* stream, const char* filename)
+{
+ return m_pluginModule->pluginFuncs().asfile(&m_npp, stream, filename);
+}
+
+int32_t NetscapePlugin::NPP_WriteReady(NPStream* stream)
+{
+ return m_pluginModule->pluginFuncs().writeready(&m_npp, stream);
+}
+
+int32_t NetscapePlugin::NPP_Write(NPStream* stream, int32_t offset, int32_t len, void* buffer)
+{
+ return m_pluginModule->pluginFuncs().write(&m_npp, stream, offset, len, buffer);
+}
+
+int16_t NetscapePlugin::NPP_HandleEvent(void* event)
+{
+ return m_pluginModule->pluginFuncs().event(&m_npp, event);
+}
+
+void NetscapePlugin::NPP_URLNotify(const char* url, NPReason reason, void* notifyData)
+{
+ m_pluginModule->pluginFuncs().urlnotify(&m_npp, url, reason, notifyData);
+}
+
+bool NetscapePlugin::NPP_URLRedirectNotify(const char* url, int32_t status, void* notifyData)
+{
+ if (!m_pluginModule->pluginFuncs().urlredirectnotify)
+ return false;
+
+ m_pluginModule->pluginFuncs().urlredirectnotify(&m_npp, url, status, notifyData);
+ return true;
+}
+
+NPError NetscapePlugin::NPP_GetValue(NPPVariable variable, void *value)
+{
+ if (!m_pluginModule->pluginFuncs().getvalue)
+ return NPERR_GENERIC_ERROR;
+
+ return m_pluginModule->pluginFuncs().getvalue(&m_npp, variable, value);
+}
+
+NPError NetscapePlugin::NPP_SetValue(NPNVariable variable, void *value)
+{
+ if (!m_pluginModule->pluginFuncs().setvalue)
+ return NPERR_GENERIC_ERROR;
+
+ return m_pluginModule->pluginFuncs().setvalue(&m_npp, variable, value);
+}
+
+void NetscapePlugin::callSetWindow()
+{
+ if (wantsPluginRelativeNPWindowCoordinates()) {
+ m_npWindow.x = 0;
+ m_npWindow.y = 0;
+ m_npWindow.clipRect.top = m_clipRect.y();
+ m_npWindow.clipRect.left = m_clipRect.x();
+ } else {
+ IntPoint pluginLocationInRootViewCoordinates = convertToRootView(IntPoint());
+ IntPoint clipRectInRootViewCoordinates = convertToRootView(m_clipRect.location());
+
+ m_npWindow.x = pluginLocationInRootViewCoordinates.x();
+ m_npWindow.y = pluginLocationInRootViewCoordinates.y();
+ m_npWindow.clipRect.top = clipRectInRootViewCoordinates.y();
+ m_npWindow.clipRect.left = clipRectInRootViewCoordinates.x();
+ }
+
+ m_npWindow.width = m_pluginSize.width();
+ m_npWindow.height = m_pluginSize.height();
+ m_npWindow.clipRect.right = m_npWindow.clipRect.left + m_clipRect.width();
+ m_npWindow.clipRect.bottom = m_npWindow.clipRect.top + m_clipRect.height();
+
+ NPP_SetWindow(&m_npWindow);
+ m_hasCalledSetWindow = true;
+}
+
+void NetscapePlugin::callSetWindowInvisible()
+{
+ NPWindow invisibleWindow = m_npWindow;
+
+ invisibleWindow.window = 0;
+ invisibleWindow.clipRect.top = 0;
+ invisibleWindow.clipRect.left = 0;
+ invisibleWindow.clipRect.bottom = 0;
+ invisibleWindow.clipRect.right = 0;
+
+ NPP_SetWindow(&invisibleWindow);
+ m_hasCalledSetWindow = true;
+}
+
+bool NetscapePlugin::shouldLoadSrcURL()
+{
+#if PLATFORM(X11)
+ // Flash crashes when NPP_GetValue is called for NPPVpluginCancelSrcStream in windowed mode.
+ if (m_isWindowed && m_pluginModule->pluginQuirks().contains(PluginQuirks::DoNotCancelSrcStreamInWindowedMode))
+ return true;
+#endif
+
+ // Check if we should cancel the load
+ NPBool cancelSrcStream = false;
+
+ if (NPP_GetValue(NPPVpluginCancelSrcStream, &cancelSrcStream) != NPERR_NO_ERROR)
+ return true;
+
+ return !cancelSrcStream;
+}
+
+NetscapePluginStream* NetscapePlugin::streamFromID(uint64_t streamID)
+{
+ return m_streams.get(streamID);
+}
+
+void NetscapePlugin::stopAllStreams()
+{
+ for (auto& stream : copyToVector(m_streams.values()))
+ stream->stop(NPRES_USER_BREAK);
+}
+
+bool NetscapePlugin::allowPopups() const
+{
+ if (m_pluginModule->pluginFuncs().version >= NPVERS_HAS_POPUPS_ENABLED_STATE) {
+ if (!m_popupEnabledStates.isEmpty())
+ return m_popupEnabledStates.last();
+ }
+
+ // FIXME: Check if the current event is a user gesture.
+ // Really old versions of Flash required this for popups to work, but all newer versions
+ // support NPN_PushPopupEnabledState/NPN_PopPopupEnabledState.
+ return false;
+}
+
+#if PLUGIN_ARCHITECTURE(MAC)
+static bool isTransparentSilverlightBackgroundValue(const String& lowercaseBackgroundValue)
+{
+ // This checks if the background color value is transparent, according to
+ // the format documented at http://msdn.microsoft.com/en-us/library/cc838148(VS.95).aspx
+ if (lowercaseBackgroundValue.startsWith('#')) {
+ if (lowercaseBackgroundValue.length() == 5 && lowercaseBackgroundValue[1] != 'f') {
+ // An 8-bit RGB value with alpha transparency, in the form #ARGB.
+ return true;
+ }
+
+ if (lowercaseBackgroundValue.length() == 9 && !(lowercaseBackgroundValue[1] == 'f' && lowercaseBackgroundValue[2] == 'f')) {
+ // A 16-bit RGB value with alpha transparency, in the form #AARRGGBB.
+ return true;
+ }
+ } else if (lowercaseBackgroundValue.startsWith("sc#")) {
+ Vector<String> components = lowercaseBackgroundValue.substring(3).split(',');
+
+ // An ScRGB value with alpha transparency, in the form sc#A,R,G,B.
+ if (components.size() == 4) {
+ if (components[0].toDouble() < 1)
+ return true;
+ }
+ } else if (lowercaseBackgroundValue == "transparent")
+ return true;
+
+ // This is an opaque color.
+ return false;
+}
+#endif
+
+bool NetscapePlugin::initialize(const Parameters& parameters)
+{
+ uint16_t mode = parameters.isFullFramePlugin ? NP_FULL : NP_EMBED;
+
+ m_shouldUseManualLoader = parameters.shouldUseManualLoader;
+
+ CString mimeTypeCString = parameters.mimeType.utf8();
+
+ ASSERT(parameters.names.size() == parameters.values.size());
+
+ Vector<CString> paramNames;
+ Vector<CString> paramValues;
+ for (size_t i = 0; i < parameters.names.size(); ++i) {
+ String parameterName = parameters.names[i];
+
+#if PLUGIN_ARCHITECTURE(MAC)
+ if (m_pluginModule->pluginQuirks().contains(PluginQuirks::WantsLowercaseParameterNames))
+ parameterName = parameterName.convertToASCIILowercase();
+#endif
+
+ paramNames.append(parameterName.utf8());
+ paramValues.append(parameters.values[i].utf8());
+ }
+
+#if PLATFORM(X11)
+ if (equalLettersIgnoringASCIICase(parameters.mimeType, "application/x-shockwave-flash")) {
+ size_t wmodeIndex = parameters.names.find("wmode");
+ if (wmodeIndex != notFound) {
+ // Transparent window mode is not supported by X11 backend.
+ if (equalLettersIgnoringASCIICase(parameters.values[wmodeIndex], "transparent")
+ || (m_pluginModule->pluginQuirks().contains(PluginQuirks::ForceFlashWindowlessMode) && equalLettersIgnoringASCIICase(parameters.values[wmodeIndex], "window")))
+ paramValues[wmodeIndex] = "opaque";
+ } else if (m_pluginModule->pluginQuirks().contains(PluginQuirks::ForceFlashWindowlessMode)) {
+ paramNames.append("wmode");
+ paramValues.append("opaque");
+ }
+ }
+#endif
+
+ if (equalLettersIgnoringASCIICase(parameters.mimeType, "application/x-webkit-test-netscape")) {
+ paramNames.append("windowedPlugin");
+ paramValues.append("false");
+ }
+
+ // The strings that these pointers point to are kept alive by paramNames and paramValues.
+ Vector<const char*> names;
+ Vector<const char*> values;
+ for (size_t i = 0; i < paramNames.size(); ++i) {
+ names.append(paramNames[i].data());
+ values.append(paramValues[i].data());
+ }
+
+#if PLUGIN_ARCHITECTURE(MAC)
+ if (m_pluginModule->pluginQuirks().contains(PluginQuirks::MakeOpaqueUnlessTransparentSilverlightBackgroundAttributeExists)) {
+ for (size_t i = 0; i < parameters.names.size(); ++i) {
+ if (equalLettersIgnoringASCIICase(parameters.names[i], "background")) {
+ setIsTransparent(isTransparentSilverlightBackgroundValue(parameters.values[i].convertToASCIILowercase()));
+ break;
+ }
+ }
+ }
+
+ m_layerHostingMode = parameters.layerHostingMode;
+#endif
+
+ platformPreInitialize();
+
+ NetscapePlugin* previousNPPNewPlugin = currentNPPNewPlugin;
+
+ m_inNPPNew = true;
+ currentNPPNewPlugin = this;
+
+ NPError error = NPP_New(const_cast<char*>(mimeTypeCString.data()), mode, names.size(),
+ const_cast<char**>(names.data()), const_cast<char**>(values.data()), 0);
+
+ m_inNPPNew = false;
+ currentNPPNewPlugin = previousNPPNewPlugin;
+
+ if (error != NPERR_NO_ERROR)
+ return false;
+
+ m_isStarted = true;
+
+ // FIXME: This is not correct in all cases.
+ m_npWindow.type = NPWindowTypeDrawable;
+
+ if (!platformPostInitialize()) {
+ destroy();
+ return false;
+ }
+
+ // Load the src URL if needed.
+ if (!parameters.shouldUseManualLoader && !parameters.url.isEmpty() && shouldLoadSrcURL())
+ loadURL("GET", parameters.url.string(), String(), HTTPHeaderMap(), Vector<uint8_t>(), false, 0);
+
+ return true;
+}
+
+void NetscapePlugin::destroy()
+{
+ ASSERT(m_isStarted);
+
+ // Stop all streams.
+ stopAllStreams();
+
+#if !PLUGIN_ARCHITECTURE(MAC) && !PLUGIN_ARCHITECTURE(UNIX)
+ m_npWindow.window = 0;
+ callSetWindow();
+#endif
+
+ NPP_Destroy(0);
+
+ m_isStarted = false;
+
+ platformDestroy();
+
+ m_timers.clear();
+}
+
+void NetscapePlugin::paint(GraphicsContext& context, const IntRect& dirtyRect)
+{
+ ASSERT(m_isStarted);
+
+ platformPaint(context, dirtyRect);
+}
+
+RefPtr<ShareableBitmap> NetscapePlugin::snapshot()
+{
+ if (!supportsSnapshotting() || m_pluginSize.isEmpty())
+ return nullptr;
+
+ ASSERT(m_isStarted);
+
+ IntSize backingStoreSize = m_pluginSize;
+ backingStoreSize.scale(contentsScaleFactor());
+
+ auto bitmap = ShareableBitmap::createShareable(backingStoreSize, { });
+ auto context = bitmap->createGraphicsContext();
+ if (!context)
+ return nullptr;
+
+ // FIXME: We should really call applyDeviceScaleFactor instead of scale, but that ends up calling into WKSI
+ // which we currently don't have initiated in the plug-in process.
+ context->scale(contentsScaleFactor());
+
+ platformPaint(*context, IntRect(IntPoint(), m_pluginSize), true);
+
+ return bitmap;
+}
+
+bool NetscapePlugin::isTransparent()
+{
+ return m_isTransparent;
+}
+
+bool NetscapePlugin::wantsWheelEvents()
+{
+ return m_pluginModule->pluginQuirks().contains(PluginQuirks::WantsWheelEvents);
+}
+
+void NetscapePlugin::geometryDidChange(const IntSize& pluginSize, const IntRect& clipRect, const AffineTransform& pluginToRootViewTransform)
+{
+ ASSERT(m_isStarted);
+
+ if (pluginSize == m_pluginSize && m_clipRect == clipRect && m_pluginToRootViewTransform == pluginToRootViewTransform) {
+ // Nothing to do.
+ return;
+ }
+
+ bool shouldCallSetWindow = true;
+
+ // If the plug-in doesn't want window relative coordinates, we don't need to call setWindow unless its size or clip rect changes.
+ if (m_hasCalledSetWindow && wantsPluginRelativeNPWindowCoordinates() && m_pluginSize == pluginSize && m_clipRect == clipRect)
+ shouldCallSetWindow = false;
+
+ m_pluginSize = pluginSize;
+ m_clipRect = clipRect;
+ m_pluginToRootViewTransform = pluginToRootViewTransform;
+
+#if PLUGIN_ARCHITECTURE(UNIX)
+ IntPoint frameRectLocationInWindowCoordinates = m_pluginToRootViewTransform.mapPoint(IntPoint());
+ m_frameRectInWindowCoordinates = IntRect(frameRectLocationInWindowCoordinates, m_pluginSize);
+#endif
+
+ platformGeometryDidChange();
+
+ if (!shouldCallSetWindow)
+ return;
+
+ callSetWindow();
+}
+
+void NetscapePlugin::visibilityDidChange(bool isVisible)
+{
+ ASSERT(m_isStarted);
+
+ if (m_isVisible == isVisible)
+ return;
+
+ m_isVisible = isVisible;
+ platformVisibilityDidChange();
+}
+
+void NetscapePlugin::frameDidFinishLoading(uint64_t requestID)
+{
+ ASSERT(m_isStarted);
+
+ auto notification = m_pendingURLNotifications.take(requestID);
+ if (notification.first.isEmpty())
+ return;
+
+ NPP_URLNotify(notification.first.utf8().data(), NPRES_DONE, notification.second);
+}
+
+void NetscapePlugin::frameDidFail(uint64_t requestID, bool wasCancelled)
+{
+ ASSERT(m_isStarted);
+
+ auto notification = m_pendingURLNotifications.take(requestID);
+ if (notification.first.isNull())
+ return;
+
+ NPP_URLNotify(notification.first.utf8().data(), wasCancelled ? NPRES_USER_BREAK : NPRES_NETWORK_ERR, notification.second);
+}
+
+void NetscapePlugin::didEvaluateJavaScript(uint64_t requestID, const String& result)
+{
+ ASSERT(m_isStarted);
+
+ if (NetscapePluginStream* pluginStream = streamFromID(requestID))
+ pluginStream->sendJavaScriptStream(result);
+}
+
+void NetscapePlugin::streamWillSendRequest(uint64_t streamID, const URL& requestURL, const URL& redirectResponseURL, int redirectResponseStatus)
+{
+ ASSERT(m_isStarted);
+
+ if (NetscapePluginStream* pluginStream = streamFromID(streamID))
+ pluginStream->willSendRequest(requestURL, redirectResponseURL, redirectResponseStatus);
+}
+
+void NetscapePlugin::streamDidReceiveResponse(uint64_t streamID, const URL& responseURL, uint32_t streamLength,
+ uint32_t lastModifiedTime, const String& mimeType, const String& headers, const String& /* suggestedFileName */)
+{
+ ASSERT(m_isStarted);
+
+ if (NetscapePluginStream* pluginStream = streamFromID(streamID))
+ pluginStream->didReceiveResponse(responseURL, streamLength, lastModifiedTime, mimeType, headers);
+}
+
+void NetscapePlugin::streamDidReceiveData(uint64_t streamID, const WebCore::SharedBuffer& buffer)
+{
+ ASSERT(m_isStarted);
+
+ if (NetscapePluginStream* pluginStream = streamFromID(streamID))
+ pluginStream->didReceiveData(buffer.data(), buffer.size());
+}
+
+void NetscapePlugin::streamDidFinishLoading(uint64_t streamID)
+{
+ ASSERT(m_isStarted);
+
+ if (NetscapePluginStream* pluginStream = streamFromID(streamID))
+ pluginStream->didFinishLoading();
+}
+
+void NetscapePlugin::streamDidFail(uint64_t streamID, bool wasCancelled)
+{
+ ASSERT(m_isStarted);
+
+ if (NetscapePluginStream* pluginStream = streamFromID(streamID))
+ pluginStream->didFail(wasCancelled);
+}
+
+void NetscapePlugin::manualStreamDidReceiveResponse(const URL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime,
+ const String& mimeType, const String& headers, const String& /* suggestedFileName */)
+{
+ ASSERT(m_isStarted);
+ ASSERT(m_shouldUseManualLoader);
+ ASSERT(!m_manualStream);
+
+ m_manualStream = NetscapePluginStream::create(*this, 0, responseURL.string(), false, 0);
+ m_manualStream->didReceiveResponse(responseURL, streamLength, lastModifiedTime, mimeType, headers);
+}
+
+void NetscapePlugin::manualStreamDidReceiveData(const WebCore::SharedBuffer& buffer)
+{
+ ASSERT(m_isStarted);
+ ASSERT(m_shouldUseManualLoader);
+ ASSERT(m_manualStream);
+
+ m_manualStream->didReceiveData(buffer.data(), buffer.size());
+}
+
+void NetscapePlugin::manualStreamDidFinishLoading()
+{
+ ASSERT(m_isStarted);
+ ASSERT(m_shouldUseManualLoader);
+ ASSERT(m_manualStream);
+
+ m_manualStream->didFinishLoading();
+}
+
+void NetscapePlugin::manualStreamDidFail(bool wasCancelled)
+{
+ ASSERT(m_isStarted);
+ ASSERT(m_shouldUseManualLoader);
+
+ if (!m_manualStream)
+ return;
+ m_manualStream->didFail(wasCancelled);
+}
+
+bool NetscapePlugin::handleMouseEvent(const WebMouseEvent& mouseEvent)
+{
+ ASSERT(m_isStarted);
+
+ return platformHandleMouseEvent(mouseEvent);
+}
+
+bool NetscapePlugin::handleWheelEvent(const WebWheelEvent& wheelEvent)
+{
+ ASSERT(m_isStarted);
+
+ return platformHandleWheelEvent(wheelEvent);
+}
+
+bool NetscapePlugin::handleMouseEnterEvent(const WebMouseEvent& mouseEvent)
+{
+ ASSERT(m_isStarted);
+
+ return platformHandleMouseEnterEvent(mouseEvent);
+}
+
+bool NetscapePlugin::handleMouseLeaveEvent(const WebMouseEvent& mouseEvent)
+{
+ ASSERT(m_isStarted);
+
+ return platformHandleMouseLeaveEvent(mouseEvent);
+}
+
+bool NetscapePlugin::handleContextMenuEvent(const WebMouseEvent&)
+{
+ // We don't know if the plug-in has handled mousedown event by displaying a context menu, so we never want WebKit to show a default one.
+ return true;
+}
+
+bool NetscapePlugin::handleKeyboardEvent(const WebKeyboardEvent& keyboardEvent)
+{
+ ASSERT(m_isStarted);
+
+ return platformHandleKeyboardEvent(keyboardEvent);
+}
+
+bool NetscapePlugin::handleEditingCommand(const String& /* commandName */, const String& /* argument */)
+{
+ return false;
+}
+
+bool NetscapePlugin::isEditingCommandEnabled(const String& /* commandName */)
+{
+ return false;
+}
+
+bool NetscapePlugin::shouldAllowScripting()
+{
+ return true;
+}
+
+bool NetscapePlugin::shouldAllowNavigationFromDrags()
+{
+ return false;
+}
+
+bool NetscapePlugin::handlesPageScaleFactor() const
+{
+ return false;
+}
+
+void NetscapePlugin::setFocus(bool hasFocus)
+{
+ ASSERT(m_isStarted);
+
+ platformSetFocus(hasFocus);
+}
+
+NPObject* NetscapePlugin::pluginScriptableNPObject()
+{
+ ASSERT(m_isStarted);
+ NPObject* scriptableNPObject = 0;
+
+ if (NPP_GetValue(NPPVpluginScriptableNPObject, &scriptableNPObject) != NPERR_NO_ERROR)
+ return 0;
+
+#if PLUGIN_ARCHITECTURE(MAC)
+ if (m_pluginModule->pluginQuirks().contains(PluginQuirks::ReturnsNonRetainedScriptableNPObject))
+ retainNPObject(scriptableNPObject);
+#endif
+
+ return scriptableNPObject;
+}
+
+unsigned NetscapePlugin::countFindMatches(const String&, WebCore::FindOptions, unsigned)
+{
+ return 0;
+}
+
+bool NetscapePlugin::findString(const String&, WebCore::FindOptions, unsigned)
+{
+ return false;
+}
+
+void NetscapePlugin::contentsScaleFactorChanged(float scaleFactor)
+{
+ ASSERT(m_isStarted);
+
+#if PLUGIN_ARCHITECTURE(MAC)
+ double contentsScaleFactor = scaleFactor;
+ NPP_SetValue(NPNVcontentsScaleFactor, &contentsScaleFactor);
+#else
+ UNUSED_PARAM(scaleFactor);
+#endif
+}
+
+void NetscapePlugin::storageBlockingStateChanged(bool storageBlockingEnabled)
+{
+ if (m_storageBlockingState != storageBlockingEnabled) {
+ m_storageBlockingState = storageBlockingEnabled;
+ updateNPNPrivateMode();
+ }
+}
+
+void NetscapePlugin::privateBrowsingStateChanged(bool privateBrowsingEnabled)
+{
+ if (m_privateBrowsingState != privateBrowsingEnabled) {
+ m_privateBrowsingState = privateBrowsingEnabled;
+ updateNPNPrivateMode();
+ }
+}
+
+void NetscapePlugin::updateNPNPrivateMode()
+{
+ ASSERT(m_isStarted);
+
+ // From https://wiki.mozilla.org/Plugins:PrivateMode
+ // When the browser turns private mode on or off it will call NPP_SetValue for "NPNVprivateModeBool"
+ // (assigned enum value 18) with a pointer to an NPBool value on all applicable instances.
+ // Plugins should check the boolean value pointed to, not the pointer itself.
+ // The value will be true when private mode is on.
+ NPBool value = m_privateBrowsingState || m_storageBlockingState;
+ NPP_SetValue(NPNVprivateModeBool, &value);
+}
+
+bool NetscapePlugin::getFormValue(String& formValue)
+{
+ ASSERT(m_isStarted);
+
+ char* formValueString = 0;
+ if (NPP_GetValue(NPPVformValue, &formValueString) != NPERR_NO_ERROR)
+ return false;
+
+ formValue = String::fromUTF8(formValueString);
+
+ // The plug-in allocates the form value string with NPN_MemAlloc so it needs to be freed with NPN_MemFree.
+ npnMemFree(formValueString);
+ return true;
+}
+
+bool NetscapePlugin::handleScroll(ScrollDirection, ScrollGranularity)
+{
+ return false;
+}
+
+Scrollbar* NetscapePlugin::horizontalScrollbar()
+{
+ return 0;
+}
+
+Scrollbar* NetscapePlugin::verticalScrollbar()
+{
+ return 0;
+}
+
+bool NetscapePlugin::supportsSnapshotting() const
+{
+#if PLATFORM(COCOA)
+ return m_pluginModule->pluginQuirks().contains(PluginQuirks::SupportsSnapshotting);
+#endif
+ return false;
+}
+
+RefPtr<WebCore::FragmentedSharedBuffer> NetscapePlugin::liveResourceData() const
+{
+ return nullptr;
+}
+
+IntPoint NetscapePlugin::convertToRootView(const IntPoint& pointInPluginCoordinates) const
+{
+ return m_pluginToRootViewTransform.mapPoint(pointInPluginCoordinates);
+}
+
+bool NetscapePlugin::convertFromRootView(const IntPoint& pointInRootViewCoordinates, IntPoint& pointInPluginCoordinates)
+{
+ if (auto inverse = m_pluginToRootViewTransform.inverse()) {
+ pointInPluginCoordinates = inverse.value().mapPoint(pointInRootViewCoordinates);
+ return true;
+ }
+ return false;
+}
+
+void NetscapePlugin::mutedStateChanged(bool muted)
+{
+ NPBool value = muted;
+ NPP_SetValue(NPNVmuteAudioBool, &value);
+}
+
+#if !PLATFORM(COCOA)
+
+void NetscapePlugin::windowFocusChanged(bool)
+{
+}
+
+void NetscapePlugin::windowVisibilityChanged(bool)
+{
+}
+
+#endif
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePlugin.h webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePlugin.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePlugin.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePlugin.h 2022-08-26 14:18:15.009022482 -0500
@@ -0,0 +1,380 @@
+/*
+ * Copyright (C) 2010-2018 Apple 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 INC. 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 INC. 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.
+ */
+
+#pragma once
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "NetscapePluginModule.h"
+#include "Plugin.h"
+#include <WebCore/AffineTransform.h>
+#include <WebCore/GraphicsLayer.h>
+#include <WebCore/IntRect.h>
+#include <wtf/HashMap.h>
+#include <wtf/RunLoop.h>
+#include <wtf/text/CString.h>
+#include <wtf/text/StringHash.h>
+
+namespace WTF {
+class MachSendRight;
+}
+
+namespace WebCore {
+class Element;
+class HTTPHeaderMap;
+class ProtectionSpace;
+class SharedBuffer;
+}
+
+namespace WebKit {
+
+class NetscapePluginStream;
+class NetscapePluginUnix;
+
+class NetscapePlugin : public Plugin {
+public:
+ static RefPtr<NetscapePlugin> create(RefPtr<NetscapePluginModule>&&);
+ virtual ~NetscapePlugin();
+
+ static RefPtr<NetscapePlugin> fromNPP(NPP);
+
+#if PLATFORM(COCOA)
+ NPError setDrawingModel(NPDrawingModel);
+ NPError setEventModel(NPEventModel);
+ NPBool convertPoint(double sourceX, double sourceY, NPCoordinateSpace sourceSpace, double& destX, double& destY, NPCoordinateSpace destSpace);
+ NPError popUpContextMenu(NPMenu*);
+
+ void setPluginReturnsNonretainedLayer(bool pluginReturnsNonretainedLayer) { m_pluginReturnsNonretainedLayer = pluginReturnsNonretainedLayer; }
+ void setPluginWantsLegacyCocoaTextInput(bool pluginWantsLegacyCocoaTextInput) { m_pluginWantsLegacyCocoaTextInput = pluginWantsLegacyCocoaTextInput; }
+
+ bool hasHandledAKeyDownEvent() const { return m_hasHandledAKeyDownEvent; }
+
+ const WTF::MachSendRight& compositingRenderServerPort();
+
+ // Computes an affine transform from the given coordinate space to the screen coordinate space.
+ bool getScreenTransform(NPCoordinateSpace sourceSpace, WebCore::AffineTransform&);
+#endif
+
+#if PLUGIN_ARCHITECTURE(UNIX)
+ const WebCore::IntRect& frameRectInWindowCoordinates() const { return m_frameRectInWindowCoordinates; }
+#endif
+ const WebCore::IntRect& clipRect() const { return m_clipRect; }
+ const WebCore::IntSize& size() const { return m_pluginSize; }
+
+ PluginQuirks quirks() const { return m_pluginModule->pluginQuirks(); }
+
+ void invalidate(const NPRect*);
+ static const char* userAgent(NPP);
+ void loadURL(const String& method, const String& urlString, const String& target, const WebCore::HTTPHeaderMap& headerFields,
+ const Vector<uint8_t>& httpBody, bool sendNotification, void* notificationData);
+ NPError destroyStream(NPStream*, NPReason);
+ void setIsWindowed(bool);
+ void setIsTransparent(bool);
+ void setStatusbarText(const String&);
+ static void setException(const String&);
+ bool evaluate(NPObject*, const String&scriptString, NPVariant* result);
+ bool isPrivateBrowsingEnabled();
+ bool isMuted() const;
+ bool isWindowed() const { return m_isWindowed; }
+ bool isVisible() const { return m_isVisible; }
+
+ static void setSetExceptionFunction(void (*)(const String&));
+
+ // These return retained objects.
+ NPObject* windowScriptNPObject();
+ NPObject* pluginElementNPObject();
+
+ void cancelStreamLoad(NetscapePluginStream*);
+ void removePluginStream(NetscapePluginStream*);
+
+ bool isAcceleratedCompositingEnabled();
+
+ void pushPopupsEnabledState(bool enabled);
+ void popPopupsEnabledState();
+
+ void pluginThreadAsyncCall(void (*function)(void*), void* userData);
+
+ unsigned scheduleTimer(unsigned interval, bool repeat, void (*timerFunc)(NPP, unsigned timerID));
+ void unscheduleTimer(unsigned timerID);
+
+ double contentsScaleFactor();
+ String proxiesForURL(const String& urlString);
+ String cookiesForURL(const String& urlString);
+ void setCookiesForURL(const String& urlString, const String& cookieString);
+ bool getAuthenticationInfo(const WebCore::ProtectionSpace&, String& username, String& password);
+
+ void setIsPlayingAudio(bool);
+
+ void registerRedirect(NetscapePluginStream*, const URL& requestURL, int redirectResponseStatus, void* notificationData);
+ void urlRedirectResponse(void* notifyData, bool allow);
+
+ // Member functions for calling into the plug-in.
+ NPError NPP_New(NPMIMEType pluginType, uint16_t mode, int16_t argc, char* argn[], char* argv[], NPSavedData*);
+ NPError NPP_Destroy(NPSavedData**);
+ NPError NPP_SetWindow(NPWindow*);
+ NPError NPP_NewStream(NPMIMEType, NPStream*, NPBool seekable, uint16_t* stype);
+ NPError NPP_DestroyStream(NPStream*, NPReason);
+ void NPP_StreamAsFile(NPStream*, const char* filename);
+ int32_t NPP_WriteReady(NPStream*);
+ int32_t NPP_Write(NPStream*, int32_t offset, int32_t len, void* buffer);
+ int16_t NPP_HandleEvent(void* event);
+ void NPP_URLNotify(const char* url, NPReason, void* notifyData);
+ bool NPP_URLRedirectNotify(const char* url, int32_t status, void* notifyData);
+ NPError NPP_GetValue(NPPVariable, void *value);
+ NPError NPP_SetValue(NPNVariable, void *value);
+
+ // Convert the given point from plug-in coordinates to root view coordinates.
+ WebCore::IntPoint convertToRootView(const WebCore::IntPoint&) const override;
+
+private:
+ explicit NetscapePlugin(Ref<NetscapePluginModule>&&);
+
+ void callSetWindow();
+ void callSetWindowInvisible();
+ bool shouldLoadSrcURL();
+ NetscapePluginStream* streamFromID(uint64_t streamID);
+ void stopAllStreams();
+ bool allowPopups() const;
+
+ const char* userAgent();
+
+ void platformPreInitialize();
+ bool platformPostInitialize();
+ void platformDestroy();
+ bool platformInvalidate(const WebCore::IntRect&);
+ void platformGeometryDidChange();
+ void platformVisibilityDidChange();
+ void platformPaint(WebCore::GraphicsContext&, const WebCore::IntRect& dirtyRect, bool isSnapshot = false);
+
+ bool platformHandleMouseEvent(const WebMouseEvent&);
+ bool platformHandleWheelEvent(const WebWheelEvent&);
+ bool platformHandleMouseEnterEvent(const WebMouseEvent&);
+ bool platformHandleMouseLeaveEvent(const WebMouseEvent&);
+ bool platformHandleKeyboardEvent(const WebKeyboardEvent&);
+ void platformSetFocus(bool);
+
+ static bool wantsPluginRelativeNPWindowCoordinates();
+
+ // Plugin
+ bool initialize(const Parameters&) override;
+ void destroy() override;
+ void paint(WebCore::GraphicsContext&, const WebCore::IntRect& dirtyRect) override;
+ RefPtr<ShareableBitmap> snapshot() override;
+#if PLATFORM(COCOA)
+ PlatformLayer* pluginLayer() override;
+#endif
+ bool isTransparent() override;
+ bool wantsWheelEvents() override;
+ void geometryDidChange(const WebCore::IntSize& pluginSize, const WebCore::IntRect& clipRect, const WebCore::AffineTransform& pluginToRootViewTransform) override;
+ void visibilityDidChange(bool isVisible) override;
+ void frameDidFinishLoading(uint64_t requestID) override;
+ void frameDidFail(uint64_t requestID, bool wasCancelled) override;
+ void didEvaluateJavaScript(uint64_t requestID, const String& result) override;
+ void streamWillSendRequest(uint64_t streamID, const URL& requestURL, const URL& responseURL, int responseStatus) override;
+ void streamDidReceiveResponse(uint64_t streamID, const URL& responseURL, uint32_t streamLength,
+ uint32_t lastModifiedTime, const String& mimeType, const String& headers, const String& suggestedFileName) override;
+ void streamDidReceiveData(uint64_t streamID, const WebCore::SharedBuffer& buffer) override;
+ void streamDidFinishLoading(uint64_t streamID) override;
+ void streamDidFail(uint64_t streamID, bool wasCancelled) override;
+ void manualStreamDidReceiveResponse(const URL& responseURL, uint32_t streamLength,
+ uint32_t lastModifiedTime, const String& mimeType, const String& headers, const String& suggestedFileName) override;
+ void manualStreamDidReceiveData(const WebCore::SharedBuffer& buffer) override;
+ void manualStreamDidFinishLoading() override;
+ void manualStreamDidFail(bool wasCancelled) override;
+
+ bool handleMouseEvent(const WebMouseEvent&) override;
+ bool handleWheelEvent(const WebWheelEvent&) override;
+ bool handleMouseEnterEvent(const WebMouseEvent&) override;
+ bool handleMouseLeaveEvent(const WebMouseEvent&) override;
+ bool handleContextMenuEvent(const WebMouseEvent&) override;
+ bool handleKeyboardEvent(const WebKeyboardEvent&) override;
+ void setFocus(bool) override;
+
+ bool handleEditingCommand(const String& commandName, const String& argument) override;
+ bool isEditingCommandEnabled(const String&) override;
+
+ bool shouldAllowScripting() override;
+ bool shouldAllowNavigationFromDrags() override;
+
+ bool handlesPageScaleFactor() const override;
+
+ NPObject* pluginScriptableNPObject() override;
+
+ unsigned countFindMatches(const String&, WebCore::FindOptions, unsigned maxMatchCount) override;
+ bool findString(const String&, WebCore::FindOptions, unsigned maxMatchCount) override;
+
+ void windowFocusChanged(bool) override;
+ void windowVisibilityChanged(bool) override;
+
+#if PLATFORM(COCOA)
+ void windowAndViewFramesChanged(const WebCore::IntRect& windowFrameInScreenCoordinates, const WebCore::IntRect& viewFrameInWindowCoordinates) override;
+
+ uint64_t pluginComplexTextInputIdentifier() const override;
+ void sendComplexTextInput(const String& textInput) override;
+ void setLayerHostingMode(LayerHostingMode) override;
+
+ void pluginFocusOrWindowFocusChanged();
+ void setComplexTextInputEnabled(bool);
+
+ void updatePluginLayer();
+#endif
+
+ void contentsScaleFactorChanged(float) override;
+ void storageBlockingStateChanged(bool) override;
+ void privateBrowsingStateChanged(bool) override;
+ bool getFormValue(String& formValue) override;
+ bool handleScroll(WebCore::ScrollDirection, WebCore::ScrollGranularity) override;
+ WebCore::Scrollbar* horizontalScrollbar() override;
+ WebCore::Scrollbar* verticalScrollbar() override;
+
+ bool supportsSnapshotting() const override;
+
+ // Convert the given point from root view coordinates to plug-in coordinates. Returns false if the point can't be
+ // converted (if the transformation matrix isn't invertible).
+ bool convertFromRootView(const WebCore::IntPoint& pointInRootViewCoordinates, WebCore::IntPoint& pointInPluginCoordinates);
+
+ RefPtr<WebCore::FragmentedSharedBuffer> liveResourceData() const override;
+
+ bool performDictionaryLookupAtLocation(const WebCore::FloatPoint&) override { return false; }
+
+ String getSelectionString() const override { return String(); }
+ String getSelectionForWordAtPoint(const WebCore::FloatPoint&) const override { return String(); }
+ bool existingSelectionContainsPoint(const WebCore::FloatPoint&) const override { return false; }
+
+ void mutedStateChanged(bool) override;
+
+ void updateNPNPrivateMode();
+
+ uint64_t m_nextRequestID;
+
+ typedef HashMap<uint64_t, std::pair<String, void*>> PendingURLNotifyMap;
+ PendingURLNotifyMap m_pendingURLNotifications;
+
+ typedef HashMap<uint64_t, RefPtr<NetscapePluginStream>> StreamsMap;
+ StreamsMap m_streams;
+ HashMap<void*, std::pair<RefPtr<NetscapePluginStream>, String>> m_redirects;
+
+ Ref<NetscapePluginModule> m_pluginModule;
+ NPP_t m_npp;
+ NPWindow m_npWindow;
+
+ WebCore::IntSize m_pluginSize;
+
+ // The clip rect in plug-in coordinates.
+ WebCore::IntRect m_clipRect;
+
+ // A transform that can be used to convert from root view coordinates to plug-in coordinates.
+ WebCore::AffineTransform m_pluginToRootViewTransform;
+
+#if PLUGIN_ARCHITECTURE(UNIX)
+ WebCore::IntRect m_frameRectInWindowCoordinates;
+#endif
+
+ CString m_userAgent;
+
+ bool m_isStarted;
+ bool m_isWindowed;
+ bool m_isTransparent;
+ bool m_inNPPNew;
+ bool m_shouldUseManualLoader;
+ bool m_hasCalledSetWindow;
+ bool m_isVisible;
+
+ RefPtr<NetscapePluginStream> m_manualStream;
+ Vector<bool, 8> m_popupEnabledStates;
+
+ class Timer {
+ WTF_MAKE_FAST_ALLOCATED;
+ WTF_MAKE_NONCOPYABLE(Timer);
+
+ public:
+ typedef void (*TimerFunc)(NPP, uint32_t timerID);
+
+ Timer(NetscapePlugin*, unsigned timerID, unsigned interval, bool repeat, TimerFunc);
+ ~Timer();
+
+ void start();
+ void stop();
+
+ private:
+ void timerFired();
+
+ // This is a weak pointer since Timer objects are destroyed before the NetscapePlugin object itself is destroyed.
+ NetscapePlugin* m_netscapePlugin;
+
+ unsigned m_timerID;
+ unsigned m_interval;
+ bool m_repeat;
+ TimerFunc m_timerFunc;
+
+ RunLoop::Timer<Timer> m_timer;
+ };
+ typedef HashMap<unsigned, std::unique_ptr<Timer>> TimerMap;
+ TimerMap m_timers;
+ unsigned m_nextTimerID;
+
+ bool m_privateBrowsingState { false };
+ bool m_storageBlockingState { false };
+
+#if PLUGIN_ARCHITECTURE(MAC)
+ NPDrawingModel m_drawingModel;
+ NPEventModel m_eventModel;
+
+ RetainPtr<PlatformLayer> m_pluginLayer;
+ bool m_pluginReturnsNonretainedLayer;
+ LayerHostingMode m_layerHostingMode;
+
+ NPCocoaEvent* m_currentMouseEvent;
+
+ bool m_pluginHasFocus;
+ bool m_windowHasFocus;
+
+ // Whether the plug-in wants to use the legacy Cocoa text input handling that
+ // existed in WebKit1, or the updated Cocoa text input handling specified on
+ // https://wiki.mozilla.org/NPAPI:CocoaEventModel#Text_Input
+ bool m_pluginWantsLegacyCocoaTextInput;
+
+ // Whether complex text input is enabled.
+ bool m_isComplexTextInputEnabled;
+
+ // Whether the plug-in has handled a keydown event. This is used to determine
+ // if we can tell the plug-in that we support the updated Cocoa text input specification.
+ bool m_hasHandledAKeyDownEvent;
+
+ // The number of NPCocoaEventKeyUp events that should be ignored.
+ unsigned m_ignoreNextKeyUpEventCounter;
+
+ WebCore::IntRect m_windowFrameInScreenCoordinates;
+ WebCore::IntRect m_viewFrameInWindowCoordinates;
+#elif PLUGIN_ARCHITECTURE(UNIX)
+ std::unique_ptr<NetscapePluginUnix> m_impl;
+#endif
+};
+
+} // namespace WebKit
+
+SPECIALIZE_TYPE_TRAITS_PLUGIN(NetscapePlugin, isNetscapePlugin())
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePluginNone.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePluginNone.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePluginNone.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePluginNone.cpp 2022-08-26 14:18:15.009022482 -0500
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies)
+ *
+ * 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 INC. 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 INC. 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 "config.h"
+#if ENABLE(NETSCAPE_PLUGIN_API) && PLUGIN_ARCHITECTURE(UNSUPPORTED)
+
+#include "NetscapePlugin.h"
+
+namespace WebKit {
+using namespace WebCore;
+
+void NetscapePlugin::platformPreInitialize()
+{
+}
+
+bool NetscapePlugin::platformPostInitialize()
+{
+ return false;
+}
+
+void NetscapePlugin::platformDestroy()
+{
+}
+
+bool NetscapePlugin::platformInvalidate(const IntRect&)
+{
+ return false;
+}
+
+void NetscapePlugin::platformGeometryDidChange()
+{
+}
+
+void NetscapePlugin::platformVisibilityDidChange()
+{
+}
+
+void NetscapePlugin::platformPaint(GraphicsContext&, const IntRect&, bool)
+{
+}
+
+bool NetscapePlugin::platformHandleMouseEvent(const WebMouseEvent&)
+{
+ return false;
+}
+
+bool NetscapePlugin::platformHandleWheelEvent(const WebWheelEvent&)
+{
+ return false;
+}
+
+void NetscapePlugin::platformSetFocus(bool)
+{
+}
+
+bool NetscapePlugin::platformHandleMouseEnterEvent(const WebMouseEvent&)
+{
+ return false;
+}
+
+bool NetscapePlugin::platformHandleMouseLeaveEvent(const WebMouseEvent&)
+{
+ return false;
+}
+
+bool NetscapePlugin::platformHandleKeyboardEvent(const WebKeyboardEvent& event)
+{
+ return false;
+}
+
+bool NetscapePlugin::wantsPluginRelativeNPWindowCoordinates()
+{
+ return true;
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API) && PLUGIN_ARCHITECTURE(UNSUPPORTED)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePluginStream.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePluginStream.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePluginStream.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePluginStream.cpp 2022-08-26 14:18:15.009022482 -0500
@@ -0,0 +1,377 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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 "config.h"
+#include "NetscapePluginStream.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "NetscapePlugin.h"
+#include <utility>
+#include <wtf/Vector.h>
+
+namespace WebKit {
+using namespace WebCore;
+
+NetscapePluginStream::NetscapePluginStream(Ref<NetscapePlugin>&& plugin, uint64_t streamID, const String& requestURLString, bool sendNotification, void* notificationData)
+ : m_plugin(WTFMove(plugin))
+ , m_streamID(streamID)
+ , m_requestURLString(requestURLString)
+ , m_sendNotification(sendNotification)
+ , m_notificationData(notificationData)
+ , m_npStream()
+ , m_transferMode(NP_NORMAL)
+ , m_offset(0)
+ , m_fileHandle(FileSystem::invalidPlatformFileHandle)
+ , m_isStarted(false)
+#if ASSERT_ENABLED
+ , m_urlNotifyHasBeenCalled(false)
+#endif
+ , m_deliveryDataTimer(RunLoop::main(), this, &NetscapePluginStream::deliverDataToPlugin)
+ , m_stopStreamWhenDoneDelivering(false)
+{
+}
+
+NetscapePluginStream::~NetscapePluginStream()
+{
+ ASSERT(!m_isStarted);
+ ASSERT(!m_sendNotification || m_urlNotifyHasBeenCalled);
+ ASSERT(m_fileHandle == FileSystem::invalidPlatformFileHandle);
+}
+
+void NetscapePluginStream::willSendRequest(const URL& requestURL, const URL& redirectResponseURL, int redirectResponseStatus)
+{
+ Ref<NetscapePluginStream> protect(*this);
+
+ if (redirectResponseStatus >= 300 && redirectResponseStatus < 400)
+ m_plugin->registerRedirect(this, requestURL, redirectResponseStatus, m_notificationData);
+}
+
+void NetscapePluginStream::didReceiveResponse(const URL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime, const String& mimeType, const String& headers)
+{
+ // Starting the stream could cause the plug-in stream to go away so we keep a reference to it here.
+ Ref<NetscapePluginStream> protect(*this);
+
+ start(responseURL.string(), streamLength, lastModifiedTime, mimeType, headers);
+}
+
+void NetscapePluginStream::didReceiveData(const uint8_t* bytes, int length)
+{
+ // Delivering the data could cause the plug-in stream to go away so we keep a reference to it here.
+ Ref<NetscapePluginStream> protect(*this);
+
+ deliverData(bytes, length);
+}
+
+void NetscapePluginStream::didFinishLoading()
+{
+ // Stopping the stream could cause the plug-in stream to go away so we keep a reference to it here.
+ Ref<NetscapePluginStream> protect(*this);
+
+ stop(NPRES_DONE);
+}
+
+void NetscapePluginStream::didFail(bool wasCancelled)
+{
+ // Stopping the stream could cause the plug-in stream to go away so we keep a reference to it here.
+ Ref<NetscapePluginStream> protect(*this);
+
+ stop(wasCancelled ? NPRES_USER_BREAK : NPRES_NETWORK_ERR);
+}
+
+void NetscapePluginStream::sendJavaScriptStream(const String& result)
+{
+ // starting the stream or delivering the data to it might cause the plug-in stream to go away, so we keep
+ // a reference to it here.
+ Ref<NetscapePluginStream> protect(*this);
+
+ CString resultCString = result.utf8();
+ if (resultCString.isNull()) {
+ // There was an error evaluating the JavaScript, call NPP_URLNotify if needed and then destroy the stream.
+ notifyAndDestroyStream(NPRES_NETWORK_ERR);
+ return;
+ }
+
+ if (!start(m_requestURLString, resultCString.length(), 0, "text/plain", ""))
+ return;
+
+ deliverData(resultCString.dataAsUInt8Ptr(), resultCString.length());
+ stop(NPRES_DONE);
+}
+
+NPError NetscapePluginStream::destroy(NPReason reason)
+{
+ // It doesn't make sense to call NPN_DestroyStream on a stream that hasn't been started yet.
+ if (!m_isStarted)
+ return NPERR_GENERIC_ERROR;
+
+ // It isn't really valid for a plug-in to call NPN_DestroyStream with NPRES_DONE.
+ // (At least not for browser initiated streams, and we don't support plug-in initiated streams).
+ if (reason == NPRES_DONE)
+ return NPERR_INVALID_PARAM;
+
+ cancel();
+ stop(reason);
+ return NPERR_NO_ERROR;
+}
+
+static bool isSupportedTransferMode(uint16_t transferMode)
+{
+ switch (transferMode) {
+ case NP_ASFILEONLY:
+ case NP_ASFILE:
+ case NP_NORMAL:
+ return true;
+ // FIXME: We don't support seekable streams.
+ case NP_SEEK:
+ return false;
+ }
+
+ ASSERT_NOT_REACHED();
+ return false;
+}
+
+bool NetscapePluginStream::start(const String& responseURLString, uint32_t streamLength, uint32_t lastModifiedTime, const String& mimeType, const String& headers)
+{
+ m_responseURL = responseURLString.utf8();
+ m_mimeType = mimeType.utf8();
+ m_headers = headers.utf8();
+
+ m_npStream.ndata = this;
+ m_npStream.url = m_responseURL.data();
+ m_npStream.end = streamLength;
+ m_npStream.lastmodified = lastModifiedTime;
+ m_npStream.notifyData = m_notificationData;
+ m_npStream.headers = m_headers.length() == 0 ? 0 : m_headers.data();
+
+ NPError error = m_plugin->NPP_NewStream(const_cast<char*>(m_mimeType.data()), &m_npStream, false, &m_transferMode);
+ if (error != NPERR_NO_ERROR) {
+ // We failed to start the stream, cancel the load and destroy it.
+ cancel();
+ notifyAndDestroyStream(NPRES_NETWORK_ERR);
+ return false;
+ }
+
+ // We successfully started the stream.
+ m_isStarted = true;
+
+ if (!isSupportedTransferMode(m_transferMode)) {
+ // Cancel the load and stop the stream.
+ cancel();
+ stop(NPRES_NETWORK_ERR);
+ return false;
+ }
+
+ return true;
+}
+
+void NetscapePluginStream::deliverData(const uint8_t* bytes, int length)
+{
+ ASSERT(m_isStarted);
+
+ if (m_transferMode != NP_ASFILEONLY) {
+ if (!m_deliveryData)
+ m_deliveryData = makeUnique<Vector<uint8_t>>();
+
+ m_deliveryData->reserveCapacity(m_deliveryData->size() + length);
+ m_deliveryData->append(bytes, length);
+
+ deliverDataToPlugin();
+ }
+
+ if (m_transferMode == NP_ASFILE || m_transferMode == NP_ASFILEONLY)
+ deliverDataToFile(bytes, length);
+}
+
+void NetscapePluginStream::deliverDataToPlugin()
+{
+ ASSERT(m_isStarted);
+
+ int32_t numBytesToDeliver = m_deliveryData->size();
+ int32_t numBytesDelivered = 0;
+
+ while (numBytesDelivered < numBytesToDeliver) {
+ int32_t numBytesPluginCanHandle = m_plugin->NPP_WriteReady(&m_npStream);
+
+ // NPP_WriteReady could call NPN_DestroyStream and destroy the stream.
+ if (!m_isStarted)
+ return;
+
+ if (numBytesPluginCanHandle <= 0) {
+ // The plug-in can't handle more data, we'll send the rest later
+ m_deliveryDataTimer.startOneShot(0_s);
+ break;
+ }
+
+ // Figure out how much data to send to the plug-in.
+ int32_t dataLength = std::min(numBytesPluginCanHandle, numBytesToDeliver - numBytesDelivered);
+ uint8_t* data = m_deliveryData->data() + numBytesDelivered;
+
+ int32_t numBytesWritten = m_plugin->NPP_Write(&m_npStream, m_offset, dataLength, data);
+ if (numBytesWritten < 0) {
+ cancel();
+ stop(NPRES_NETWORK_ERR);
+ return;
+ }
+
+ // NPP_Write could call NPN_DestroyStream and destroy the stream.
+ if (!m_isStarted)
+ return;
+
+ numBytesWritten = std::min(numBytesWritten, dataLength);
+ m_offset += numBytesWritten;
+ numBytesDelivered += numBytesWritten;
+ }
+
+ // We didn't write anything.
+ if (!numBytesDelivered)
+ return;
+
+ if (numBytesDelivered < numBytesToDeliver) {
+ // Remove the bytes that we actually delivered.
+ m_deliveryData->remove(0, numBytesDelivered);
+ } else {
+ m_deliveryData->clear();
+
+ if (m_stopStreamWhenDoneDelivering)
+ stop(NPRES_DONE);
+ }
+}
+
+void NetscapePluginStream::deliverDataToFile(const uint8_t* bytes, int length)
+{
+ if (m_fileHandle == FileSystem::invalidPlatformFileHandle && m_filePath.isNull()) {
+ // Create a temporary file.
+ m_filePath = FileSystem::openTemporaryFile("WebKitPluginStream", m_fileHandle);
+
+ // We failed to open the file, stop the stream.
+ if (m_fileHandle == FileSystem::invalidPlatformFileHandle) {
+ stop(NPRES_NETWORK_ERR);
+ return;
+ }
+ }
+
+ if (!length)
+ return;
+
+ int byteCount = FileSystem::writeToFile(m_fileHandle, bytes, length);
+ if (byteCount != length) {
+ // This happens only rarely, when we are out of disk space or have a disk I/O error.
+ FileSystem::closeFile(m_fileHandle);
+
+ stop(NPRES_NETWORK_ERR);
+ }
+}
+
+void NetscapePluginStream::stop(NPReason reason)
+{
+ // The stream was stopped before it got a chance to start. This can happen if a stream is cancelled by
+ // WebKit before it received a response.
+ if (!m_isStarted) {
+ ASSERT(reason != NPRES_DONE);
+ notifyAndDestroyStream(reason);
+ return;
+ }
+
+ if (reason == NPRES_DONE && m_deliveryData && !m_deliveryData->isEmpty()) {
+ // There is still data left that the plug-in hasn't been able to consume yet.
+ ASSERT(m_deliveryDataTimer.isActive());
+
+ // Set m_stopStreamWhenDoneDelivering to true so that the next time the delivery timer fires
+ // and calls deliverDataToPlugin the stream will be closed if all the remaining data was
+ // successfully delivered.
+ m_stopStreamWhenDoneDelivering = true;
+ return;
+ }
+
+ m_deliveryData = nullptr;
+ m_deliveryDataTimer.stop();
+
+ if (m_transferMode == NP_ASFILE || m_transferMode == NP_ASFILEONLY) {
+ if (reason == NPRES_DONE) {
+ // Ensure that the file is created.
+ deliverDataToFile(0, 0);
+ if (m_fileHandle != FileSystem::invalidPlatformFileHandle)
+ FileSystem::closeFile(m_fileHandle);
+
+ ASSERT(!m_filePath.isNull());
+
+ m_plugin->NPP_StreamAsFile(&m_npStream, m_filePath.utf8().data());
+ } else {
+ // Just close the file.
+ if (m_fileHandle != FileSystem::invalidPlatformFileHandle)
+ FileSystem::closeFile(m_fileHandle);
+ }
+
+ // Delete the file after calling NPP_StreamAsFile(), instead of in the destructor. It should be OK
+ // to delete the file here -- NPP_StreamAsFile() is always called immediately before NPP_DestroyStream()
+ // (the stream destruction function), so there can be no expectation that a plugin will read the stream
+ // file asynchronously after NPP_StreamAsFile() is called.
+ FileSystem::deleteFile(m_filePath);
+ m_filePath = String();
+
+ // NPP_StreamAsFile could call NPN_DestroyStream and destroy the stream.
+ if (!m_isStarted)
+ return;
+ }
+
+ // Set m_isStarted to false before calling NPP_DestroyStream in case NPP_DestroyStream calls NPN_DestroyStream.
+ m_isStarted = false;
+
+ m_plugin->NPP_DestroyStream(&m_npStream, reason);
+
+ notifyAndDestroyStream(reason);
+}
+
+void NetscapePluginStream::setURL(const String& newURLString)
+{
+ m_requestURLString = newURLString;
+}
+
+void NetscapePluginStream::cancel()
+{
+ m_plugin->cancelStreamLoad(this);
+}
+
+void NetscapePluginStream::notifyAndDestroyStream(NPReason reason)
+{
+ ASSERT(!m_isStarted);
+ ASSERT(!m_deliveryDataTimer.isActive());
+ ASSERT(!m_urlNotifyHasBeenCalled);
+
+ if (m_sendNotification) {
+ m_plugin->NPP_URLNotify(m_requestURLString.utf8().data(), reason, m_notificationData);
+
+#if ASSERT_ENABLED
+ m_urlNotifyHasBeenCalled = true;
+#endif
+ }
+
+ m_plugin->removePluginStream(this);
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePluginStream.h webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePluginStream.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePluginStream.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NetscapePluginStream.h 2022-08-26 14:18:15.009022482 -0500
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+ */
+
+#pragma once
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include <WebCore/npruntime_internal.h>
+#include <memory>
+#include <wtf/FileSystem.h>
+#include <wtf/Forward.h>
+#include <wtf/RefCounted.h>
+#include <wtf/RefPtr.h>
+#include <wtf/RunLoop.h>
+#include <wtf/text/CString.h>
+
+namespace WebKit {
+
+class NetscapePlugin;
+
+class NetscapePluginStream : public RefCounted<NetscapePluginStream> {
+public:
+ static Ref<NetscapePluginStream> create(Ref<NetscapePlugin>&& plugin, uint64_t streamID, const String& requestURLString, bool sendNotification, void* notificationData)
+ {
+ return adoptRef(*new NetscapePluginStream(WTFMove(plugin), streamID, requestURLString, sendNotification, notificationData));
+ }
+ ~NetscapePluginStream();
+
+ uint64_t streamID() const { return m_streamID; }
+ const NPStream* npStream() const { return &m_npStream; }
+
+ void willSendRequest(const URL& requestURL, const URL& redirectResponseURL, int redirectResponseStatus);
+ void didReceiveResponse(const URL& responseURL, uint32_t streamLength,
+ uint32_t lastModifiedTime, const String& mimeType, const String& headers);
+ void didReceiveData(const uint8_t* bytes, int length);
+ void didFinishLoading();
+ void didFail(bool wasCancelled);
+
+ void sendJavaScriptStream(const String& result);
+
+ void stop(NPReason);
+ NPError destroy(NPReason);
+ void setURL(const String& newURLString);
+
+private:
+ NetscapePluginStream(Ref<NetscapePlugin>&&, uint64_t streamID, const String& requestURLString, bool sendNotification, void* notificationData);
+
+ bool start(const String& responseURLString, uint32_t streamLength,
+ uint32_t lastModifiedTime, const String& mimeType, const String& headers);
+
+ void cancel();
+ void notifyAndDestroyStream(NPReason);
+
+ void deliverData(const uint8_t* bytes, int length);
+ void deliverDataToPlugin();
+ void deliverDataToFile(const uint8_t* bytes, int length);
+
+ Ref<NetscapePlugin> m_plugin;
+ uint64_t m_streamID;
+
+ String m_requestURLString;
+ bool m_sendNotification;
+ void* m_notificationData;
+
+ NPStream m_npStream;
+ uint16_t m_transferMode;
+ int32_t m_offset;
+
+ String m_filePath;
+ FileSystem::PlatformFileHandle m_fileHandle;
+
+ // Whether NPP_NewStream has successfully been called.
+ bool m_isStarted;
+
+#if ASSERT_ENABLED
+ bool m_urlNotifyHasBeenCalled;
+#endif
+
+ CString m_responseURL;
+ CString m_mimeType;
+ CString m_headers;
+
+ RunLoop::Timer<NetscapePluginStream> m_deliveryDataTimer;
+ std::unique_ptr<Vector<uint8_t>> m_deliveryData;
+ bool m_stopStreamWhenDoneDelivering;
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NPJSObject.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NPJSObject.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NPJSObject.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NPJSObject.cpp 2022-08-26 14:18:15.009022482 -0500
@@ -0,0 +1,412 @@
+/*
+ * Copyright (C) 2010-2019 Apple 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 INC. 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 INC. 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 "config.h"
+#include "NPJSObject.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "JSNPObject.h"
+#include "NPRuntimeObjectMap.h"
+#include "NPRuntimeUtilities.h"
+#include <JavaScriptCore/CatchScope.h>
+#include <JavaScriptCore/JSCInlines.h>
+#include <JavaScriptCore/JSCellInlines.h>
+#include <JavaScriptCore/JSLock.h>
+#include <JavaScriptCore/JSObject.h>
+#include <JavaScriptCore/StrongInlines.h>
+#include <WebCore/Frame.h>
+#include <WebCore/IdentifierRep.h>
+#include <wtf/text/WTFString.h>
+
+namespace WebKit {
+using namespace JSC;
+using namespace WebCore;
+
+NPJSObject* NPJSObject::create(VM& vm, NPRuntimeObjectMap* objectMap, JSObject* jsObject)
+{
+ // We should never have a JSNPObject inside an NPJSObject.
+ ASSERT(!jsObject->inherits<JSNPObject>(vm));
+
+ NPJSObject* npJSObject = toNPJSObject(createNPObject(0, npClass()));
+ npJSObject->initialize(vm, objectMap, jsObject);
+
+ return npJSObject;
+}
+
+NPJSObject::NPJSObject()
+ : m_objectMap(0)
+{
+}
+
+NPJSObject::~NPJSObject()
+{
+ m_objectMap->npJSObjectDestroyed(this);
+}
+
+bool NPJSObject::isNPJSObject(NPObject* npObject)
+{
+ return npObject->_class == npClass();
+}
+
+void NPJSObject::initialize(VM& vm, NPRuntimeObjectMap* objectMap, JSObject* jsObject)
+{
+ ASSERT(!m_objectMap);
+ ASSERT(!m_jsObject);
+
+ m_objectMap = objectMap;
+ m_jsObject.set(vm, jsObject);
+}
+
+static Identifier identifierFromIdentifierRep(JSGlobalObject* lexicalGlobalObject, IdentifierRep* identifierRep)
+{
+ VM& vm = lexicalGlobalObject->vm();
+ ASSERT(identifierRep->isString());
+
+ const char* string = identifierRep->string();
+ int length = strlen(string);
+
+ return Identifier::fromString(vm, String::fromUTF8WithLatin1Fallback(string, length));
+}
+
+bool NPJSObject::hasMethod(NPIdentifier methodName)
+{
+ IdentifierRep* identifierRep = static_cast<IdentifierRep*>(methodName);
+
+ if (!identifierRep->isString())
+ return false;
+
+ JSGlobalObject* lexicalGlobalObject = m_objectMap->globalObject();
+ if (!lexicalGlobalObject)
+ return false;
+
+ VM& vm = lexicalGlobalObject->vm();
+ JSLockHolder lock(vm);
+ auto scope = DECLARE_CATCH_SCOPE(vm);
+
+ JSValue value = m_jsObject->get(lexicalGlobalObject, identifierFromIdentifierRep(lexicalGlobalObject, identifierRep));
+ scope.clearException();
+
+ return value.isCallable(vm);
+}
+
+bool NPJSObject::invoke(NPIdentifier methodName, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
+{
+ IdentifierRep* identifierRep = static_cast<IdentifierRep*>(methodName);
+
+ if (!identifierRep->isString())
+ return false;
+
+ JSGlobalObject* lexicalGlobalObject = m_objectMap->globalObject();
+ if (!lexicalGlobalObject)
+ return false;
+
+ JSLockHolder lock(lexicalGlobalObject);
+
+ JSValue function = m_jsObject->get(lexicalGlobalObject, identifierFromIdentifierRep(lexicalGlobalObject, identifierRep));
+ return invoke(lexicalGlobalObject, function, arguments, argumentCount, result);
+}
+
+bool NPJSObject::invokeDefault(const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
+{
+ JSGlobalObject* lexicalGlobalObject = m_objectMap->globalObject();
+ if (!lexicalGlobalObject)
+ return false;
+
+ JSLockHolder lock(lexicalGlobalObject);
+
+ JSValue function = m_jsObject.get();
+ return invoke(lexicalGlobalObject, function, arguments, argumentCount, result);
+}
+
+bool NPJSObject::hasProperty(NPIdentifier identifier)
+{
+ IdentifierRep* identifierRep = static_cast<IdentifierRep*>(identifier);
+
+ JSGlobalObject* lexicalGlobalObject = m_objectMap->globalObject();
+ if (!lexicalGlobalObject)
+ return false;
+
+ VM& vm = lexicalGlobalObject->vm();
+ JSLockHolder lock(vm);
+ auto scope = DECLARE_CATCH_SCOPE(vm);
+
+ bool result;
+ if (identifierRep->isString())
+ result = m_jsObject->hasProperty(lexicalGlobalObject, identifierFromIdentifierRep(lexicalGlobalObject, identifierRep));
+ else
+ result = m_jsObject->hasProperty(lexicalGlobalObject, static_cast<uint32_t>(identifierRep->number()));
+
+ scope.clearException();
+ return result;
+}
+
+bool NPJSObject::getProperty(NPIdentifier propertyName, NPVariant* result)
+{
+ IdentifierRep* identifierRep = static_cast<IdentifierRep*>(propertyName);
+
+ JSGlobalObject* lexicalGlobalObject = m_objectMap->globalObject();
+ if (!lexicalGlobalObject)
+ return false;
+
+ VM& vm = lexicalGlobalObject->vm();
+ JSLockHolder lock(vm);
+ auto scope = DECLARE_CATCH_SCOPE(vm);
+
+ JSValue jsResult;
+ if (identifierRep->isString())
+ jsResult = m_jsObject->get(lexicalGlobalObject, identifierFromIdentifierRep(lexicalGlobalObject, identifierRep));
+ else
+ jsResult = m_jsObject->get(lexicalGlobalObject, static_cast<uint32_t>(identifierRep->number()));
+
+ m_objectMap->convertJSValueToNPVariant(lexicalGlobalObject, jsResult, *result);
+ scope.clearException();
+ return true;
+}
+
+bool NPJSObject::setProperty(NPIdentifier propertyName, const NPVariant* value)
+{
+ IdentifierRep* identifierRep = static_cast<IdentifierRep*>(propertyName);
+
+ JSGlobalObject* lexicalGlobalObject = m_objectMap->globalObject();
+ if (!lexicalGlobalObject)
+ return false;
+
+ VM& vm = lexicalGlobalObject->vm();
+ JSLockHolder lock(vm);
+ auto scope = DECLARE_CATCH_SCOPE(vm);
+
+ JSValue jsValue = m_objectMap->convertNPVariantToJSValue(m_objectMap->globalObject(), *value);
+ if (identifierRep->isString()) {
+ PutPropertySlot slot(m_jsObject.get());
+ m_jsObject->methodTable(vm)->put(m_jsObject.get(), lexicalGlobalObject, identifierFromIdentifierRep(lexicalGlobalObject, identifierRep), jsValue, slot);
+ } else
+ m_jsObject->methodTable(vm)->putByIndex(m_jsObject.get(), lexicalGlobalObject, identifierRep->number(), jsValue, false);
+ scope.clearException();
+
+ return true;
+}
+
+bool NPJSObject::removeProperty(NPIdentifier propertyName)
+{
+ IdentifierRep* identifierRep = static_cast<IdentifierRep*>(propertyName);
+
+ JSGlobalObject* lexicalGlobalObject = m_objectMap->globalObject();
+ if (!lexicalGlobalObject)
+ return false;
+
+ VM& vm = lexicalGlobalObject->vm();
+ JSLockHolder lock(vm);
+ auto scope = DECLARE_CATCH_SCOPE(vm);
+
+ if (identifierRep->isString()) {
+ Identifier identifier = identifierFromIdentifierRep(lexicalGlobalObject, identifierRep);
+
+ if (!m_jsObject->hasProperty(lexicalGlobalObject, identifier)) {
+ scope.clearException();
+ return false;
+ }
+
+ JSCell::deleteProperty(m_jsObject.get(), lexicalGlobalObject, identifier);
+ } else {
+ if (!m_jsObject->hasProperty(lexicalGlobalObject, static_cast<uint32_t>(identifierRep->number()))) {
+ scope.clearException();
+ return false;
+ }
+
+ m_jsObject->methodTable(vm)->deletePropertyByIndex(m_jsObject.get(), lexicalGlobalObject, identifierRep->number());
+ }
+
+ scope.clearException();
+ return true;
+}
+
+bool NPJSObject::enumerate(NPIdentifier** identifiers, uint32_t* identifierCount)
+{
+ JSGlobalObject* lexicalGlobalObject = m_objectMap->globalObject();
+ if (!lexicalGlobalObject)
+ return false;
+
+ VM& vm = lexicalGlobalObject->vm();
+ JSLockHolder lock(vm);
+
+ PropertyNameArray propertyNames(vm, PropertyNameMode::Strings, PrivateSymbolMode::Exclude);
+ m_jsObject->getPropertyNames(lexicalGlobalObject, propertyNames, DontEnumPropertiesMode::Exclude);
+
+ NPIdentifier* nameIdentifiers = npnMemNewArray<NPIdentifier>(propertyNames.size());
+
+ for (size_t i = 0; i < propertyNames.size(); ++i)
+ nameIdentifiers[i] = static_cast<NPIdentifier>(IdentifierRep::get(propertyNames[i].string().utf8().data()));
+
+ *identifiers = nameIdentifiers;
+ *identifierCount = propertyNames.size();
+
+ return true;
+}
+
+bool NPJSObject::construct(const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
+{
+ JSGlobalObject* lexicalGlobalObject = m_objectMap->globalObject();
+ if (!lexicalGlobalObject)
+ return false;
+
+ VM& vm = lexicalGlobalObject->vm();
+ JSLockHolder lock(vm);
+ auto scope = DECLARE_CATCH_SCOPE(vm);
+
+ auto constructData = getConstructData(vm, m_jsObject.get());
+ if (constructData.type == CallData::Type::None)
+ return false;
+
+ // Convert the passed in arguments.
+ MarkedArgumentBuffer argumentList;
+ for (uint32_t i = 0; i < argumentCount; ++i)
+ argumentList.append(m_objectMap->convertNPVariantToJSValue(m_objectMap->globalObject(), arguments[i]));
+ RELEASE_ASSERT(!argumentList.hasOverflowed());
+
+ JSValue value = JSC::construct(lexicalGlobalObject, m_jsObject.get(), constructData, argumentList);
+
+ // Convert and return the new object.
+ m_objectMap->convertJSValueToNPVariant(lexicalGlobalObject, value, *result);
+ scope.clearException();
+
+ return true;
+}
+
+bool NPJSObject::invoke(JSGlobalObject* lexicalGlobalObject, JSValue function, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
+{
+ VM& vm = lexicalGlobalObject->vm();
+ auto scope = DECLARE_CATCH_SCOPE(vm);
+
+ auto callData = getCallData(vm, function);
+ if (callData.type == CallData::Type::None)
+ return false;
+
+ // Convert the passed in arguments.
+ MarkedArgumentBuffer argumentList;
+ for (uint32_t i = 0; i < argumentCount; ++i)
+ argumentList.append(m_objectMap->convertNPVariantToJSValue(lexicalGlobalObject, arguments[i]));
+ RELEASE_ASSERT(!argumentList.hasOverflowed());
+
+ JSValue value = JSC::call(lexicalGlobalObject, function, callData, m_jsObject.get(), argumentList);
+
+ if (UNLIKELY(scope.exception())) {
+ scope.clearException();
+ return false;
+ }
+
+ // Convert and return the result of the function call.
+ m_objectMap->convertJSValueToNPVariant(lexicalGlobalObject, value, *result);
+
+ if (UNLIKELY(scope.exception())) {
+ scope.clearException();
+ return false;
+ }
+
+ return true;
+}
+
+NPClass* NPJSObject::npClass()
+{
+ static NPClass npClass = {
+ NP_CLASS_STRUCT_VERSION,
+ NP_Allocate,
+ NP_Deallocate,
+ 0,
+ NP_HasMethod,
+ NP_Invoke,
+ NP_InvokeDefault,
+ NP_HasProperty,
+ NP_GetProperty,
+ NP_SetProperty,
+ NP_RemoveProperty,
+ NP_Enumerate,
+ NP_Construct
+ };
+
+ return &npClass;
+}
+
+NPObject* NPJSObject::NP_Allocate(NPP npp, NPClass*)
+{
+ ASSERT_UNUSED(npp, !npp);
+
+ return new NPJSObject;
+}
+
+void NPJSObject::NP_Deallocate(NPObject* npObject)
+{
+ NPJSObject* npJSObject = toNPJSObject(npObject);
+ delete npJSObject;
+}
+
+bool NPJSObject::NP_HasMethod(NPObject* npObject, NPIdentifier methodName)
+{
+ return toNPJSObject(npObject)->hasMethod(methodName);
+}
+
+bool NPJSObject::NP_Invoke(NPObject* npObject, NPIdentifier methodName, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
+{
+ return toNPJSObject(npObject)->invoke(methodName, arguments, argumentCount, result);
+}
+
+bool NPJSObject::NP_InvokeDefault(NPObject* npObject, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
+{
+ return toNPJSObject(npObject)->invokeDefault(arguments, argumentCount, result);
+}
+
+bool NPJSObject::NP_HasProperty(NPObject* npObject, NPIdentifier propertyName)
+{
+ return toNPJSObject(npObject)->hasProperty(propertyName);
+}
+
+bool NPJSObject::NP_GetProperty(NPObject* npObject, NPIdentifier propertyName, NPVariant* result)
+{
+ return toNPJSObject(npObject)->getProperty(propertyName, result);
+}
+
+bool NPJSObject::NP_SetProperty(NPObject* npObject, NPIdentifier propertyName, const NPVariant* value)
+{
+ return toNPJSObject(npObject)->setProperty(propertyName, value);
+}
+
+bool NPJSObject::NP_RemoveProperty(NPObject* npObject, NPIdentifier propertyName)
+{
+ return toNPJSObject(npObject)->removeProperty(propertyName);
+}
+
+bool NPJSObject::NP_Enumerate(NPObject* npObject, NPIdentifier** identifiers, uint32_t* identifierCount)
+{
+ return toNPJSObject(npObject)->enumerate(identifiers, identifierCount);
+}
+
+bool NPJSObject::NP_Construct(NPObject* npObject, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
+{
+ return toNPJSObject(npObject)->construct(arguments, argumentCount, result);
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NPJSObject.h webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NPJSObject.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NPJSObject.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NPJSObject.h 2022-08-26 14:18:15.009022482 -0500
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+ */
+
+#ifndef NPJSObject_h
+#define NPJSObject_h
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include <JavaScriptCore/Strong.h>
+#include <WebCore/npruntime_internal.h>
+#include <wtf/Noncopyable.h>
+
+namespace JSC {
+
+class VM;
+class JSGlobalObject;
+class JSObject;
+
+}
+
+namespace WebKit {
+
+class NPRuntimeObjectMap;
+
+// NPJSObject is an NPObject that wraps a JSObject.
+class NPJSObject : public NPObject {
+ WTF_MAKE_NONCOPYABLE(NPJSObject);
+public:
+ static NPJSObject* create(JSC::VM&, NPRuntimeObjectMap*, JSC::JSObject*);
+
+ JSC::JSObject* jsObject() const { return m_jsObject.get(); }
+
+ static bool isNPJSObject(NPObject*);
+
+ static NPJSObject* toNPJSObject(NPObject* npObject)
+ {
+ RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(isNPJSObject(npObject));
+ return static_cast<NPJSObject*>(npObject);
+ }
+
+private:
+ NPJSObject();
+ ~NPJSObject();
+
+ void initialize(JSC::VM&, NPRuntimeObjectMap*, JSC::JSObject*);
+
+ bool hasMethod(NPIdentifier methodName);
+ bool invoke(NPIdentifier methodName, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result);
+ bool invokeDefault(const NPVariant* arguments, uint32_t argumentCount, NPVariant* result);
+ bool hasProperty(NPIdentifier propertyName);
+ bool getProperty(NPIdentifier propertyName, NPVariant* result);
+ bool setProperty(NPIdentifier propertyName, const NPVariant* value);
+ bool removeProperty(NPIdentifier propertyName);
+ bool enumerate(NPIdentifier** identifiers, uint32_t* identifierCount);
+ bool construct(const NPVariant* arguments, uint32_t argumentCount, NPVariant* result);
+
+ bool invoke(JSC::JSGlobalObject*, JSC::JSValue function, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result);
+
+ static NPClass* npClass();
+ static NPObject* NP_Allocate(NPP, NPClass*);
+ static void NP_Deallocate(NPObject*);
+ static bool NP_HasMethod(NPObject*, NPIdentifier methodName);
+ static bool NP_Invoke(NPObject*, NPIdentifier methodName, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result);
+ static bool NP_InvokeDefault(NPObject*, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result);
+ static bool NP_HasProperty(NPObject*, NPIdentifier propertyName);
+ static bool NP_GetProperty(NPObject*, NPIdentifier propertyName, NPVariant* result);
+ static bool NP_SetProperty(NPObject*, NPIdentifier propertyName, const NPVariant* value);
+ static bool NP_RemoveProperty(NPObject*, NPIdentifier propertyName);
+ static bool NP_Enumerate(NPObject*, NPIdentifier** identifiers, uint32_t* identifierCount);
+ static bool NP_Construct(NPObject*, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result);
+
+ NPRuntimeObjectMap* m_objectMap;
+ JSC::Strong<JSC::JSObject> m_jsObject;
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif // NPJSObject_h
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NPRuntimeObjectMap.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NPRuntimeObjectMap.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NPRuntimeObjectMap.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NPRuntimeObjectMap.cpp 2022-08-26 14:18:15.009022482 -0500
@@ -0,0 +1,296 @@
+/*
+ * Copyright (C) 2010-2019 Apple 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 INC. 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 INC. 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 "config.h"
+#include "NPRuntimeObjectMap.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "JSNPObject.h"
+#include "NPJSObject.h"
+#include "NPRuntimeUtilities.h"
+#include "PluginView.h"
+#include "WebProcess.h"
+#include <JavaScriptCore/Completion.h>
+#include <JavaScriptCore/Error.h>
+#include <JavaScriptCore/JSGlobalObjectInlines.h>
+#include <JavaScriptCore/JSLock.h>
+#include <JavaScriptCore/SourceCode.h>
+#include <JavaScriptCore/Strong.h>
+#include <JavaScriptCore/StrongInlines.h>
+#include <WebCore/DOMWrapperWorld.h>
+#include <WebCore/Frame.h>
+#include <WebCore/ScriptController.h>
+#include <wtf/NeverDestroyed.h>
+
+namespace WebKit {
+using namespace JSC;
+using namespace WebCore;
+
+
+NPRuntimeObjectMap::NPRuntimeObjectMap(PluginView* pluginView)
+ : m_pluginView(pluginView)
+ , m_finalizationTimer(RunLoop::main(), this, &NPRuntimeObjectMap::invalidateQueuedObjects)
+{
+}
+
+NPRuntimeObjectMap::PluginProtector::PluginProtector(NPRuntimeObjectMap* npRuntimeObjectMap)
+{
+ // If we're already in the plug-in view destructor, we shouldn't try to keep it alive.
+ if (!npRuntimeObjectMap->m_pluginView->isBeingDestroyed())
+ m_pluginView = npRuntimeObjectMap->m_pluginView;
+}
+
+NPRuntimeObjectMap::PluginProtector::~PluginProtector()
+{
+}
+
+NPObject* NPRuntimeObjectMap::getOrCreateNPObject(VM& vm, JSObject* jsObject)
+{
+ // If this is a JSNPObject, we can just get its underlying NPObject.
+ if (jsObject->classInfo(vm) == JSNPObject::info()) {
+ JSNPObject* jsNPObject = jsCast<JSNPObject*>(jsObject);
+ NPObject* npObject = jsNPObject->npObject();
+
+ retainNPObject(npObject);
+ return npObject;
+ }
+
+ // First, check if we already know about this object.
+ if (NPJSObject* npJSObject = m_npJSObjects.get(jsObject)) {
+ retainNPObject(npJSObject);
+ return npJSObject;
+ }
+
+ NPJSObject* npJSObject = NPJSObject::create(vm, this, jsObject);
+ m_npJSObjects.set(jsObject, npJSObject);
+
+ return npJSObject;
+}
+
+void NPRuntimeObjectMap::npJSObjectDestroyed(NPJSObject* npJSObject)
+{
+ // Remove the object from the map.
+ ASSERT(m_npJSObjects.contains(npJSObject->jsObject()));
+ m_npJSObjects.remove(npJSObject->jsObject());
+}
+
+JSObject* NPRuntimeObjectMap::getOrCreateJSObject(JSGlobalObject* globalObject, NPObject* npObject)
+{
+ // If this is an NPJSObject, we can just get the JSObject that it's wrapping.
+ if (NPJSObject::isNPJSObject(npObject))
+ return NPJSObject::toNPJSObject(npObject)->jsObject();
+
+ if (JSNPObject* jsNPObject = m_jsNPObjects.get(npObject))
+ return jsNPObject;
+
+ JSNPObject* jsNPObject = JSNPObject::create(globalObject, this, npObject);
+ weakAdd(m_jsNPObjects, npObject, JSC::Weak<JSNPObject>(jsNPObject, this, npObject));
+ return jsNPObject;
+}
+
+JSValue NPRuntimeObjectMap::convertNPVariantToJSValue(JSC::JSGlobalObject* globalObject, const NPVariant& variant)
+{
+ switch (variant.type) {
+ case NPVariantType_Void:
+ return jsUndefined();
+
+ case NPVariantType_Null:
+ return jsNull();
+
+ case NPVariantType_Bool:
+ return jsBoolean(variant.value.boolValue);
+
+ case NPVariantType_Int32:
+ return jsNumber(variant.value.intValue);
+
+ case NPVariantType_Double:
+ return jsNumber(variant.value.doubleValue);
+
+ case NPVariantType_String:
+ return jsString(globalObject->vm(), String::fromUTF8WithLatin1Fallback(variant.value.stringValue.UTF8Characters,
+ variant.value.stringValue.UTF8Length));
+ case NPVariantType_Object:
+ return getOrCreateJSObject(globalObject, variant.value.objectValue);
+ }
+
+ ASSERT_NOT_REACHED();
+ return jsUndefined();
+}
+
+void NPRuntimeObjectMap::convertJSValueToNPVariant(JSGlobalObject* lexicalGlobalObject, JSValue value, NPVariant& variant)
+{
+ VM& vm = lexicalGlobalObject->vm();
+ JSLockHolder lock(lexicalGlobalObject);
+
+ VOID_TO_NPVARIANT(variant);
+
+ if (value.isNull()) {
+ NULL_TO_NPVARIANT(variant);
+ return;
+ }
+
+ if (value.isUndefined()) {
+ VOID_TO_NPVARIANT(variant);
+ return;
+ }
+
+ if (value.isBoolean()) {
+ BOOLEAN_TO_NPVARIANT(value.toBoolean(lexicalGlobalObject), variant);
+ return;
+ }
+
+ if (value.isNumber()) {
+ DOUBLE_TO_NPVARIANT(value.toNumber(lexicalGlobalObject), variant);
+ return;
+ }
+
+ if (value.isString()) {
+ NPString npString = createNPString(value.toString(lexicalGlobalObject)->value(lexicalGlobalObject).utf8());
+ STRINGN_TO_NPVARIANT(npString.UTF8Characters, npString.UTF8Length, variant);
+ return;
+ }
+
+ if (value.isObject()) {
+ NPObject* npObject = getOrCreateNPObject(vm, asObject(value));
+ OBJECT_TO_NPVARIANT(npObject, variant);
+ return;
+ }
+
+ ASSERT_NOT_REACHED();
+}
+
+bool NPRuntimeObjectMap::evaluate(NPObject* npObject, const String& scriptString, NPVariant* result)
+{
+ Strong<JSGlobalObject> globalObject(this->globalObject()->vm(), this->globalObject());
+ if (!globalObject)
+ return false;
+
+ JSLockHolder lock(globalObject.get());
+ JSValue thisValue = getOrCreateJSObject(globalObject.get(), npObject);
+
+ JSValue resultValue = JSC::evaluate(globalObject.get(), makeSource(scriptString, { }), thisValue);
+
+ convertJSValueToNPVariant(globalObject.get(), resultValue, *result);
+ return true;
+}
+
+void NPRuntimeObjectMap::invalidate()
+{
+ // Deallocate all the object wrappers so we won't leak any JavaScript objects.
+ for (auto& npJSObject : copyToVector(m_npJSObjects.values()))
+ deallocateNPObject(npJSObject);
+
+ // We shouldn't have any NPJSObjects left now.
+ ASSERT(m_npJSObjects.isEmpty());
+
+ Vector<NPObject*> objects;
+
+ for (HashMap<NPObject*, JSC::Weak<JSNPObject>>::iterator ptr = m_jsNPObjects.begin(), end = m_jsNPObjects.end(); ptr != end; ++ptr) {
+ JSNPObject* jsNPObject = ptr->value.get();
+ if (!jsNPObject) // Skip zombies.
+ continue;
+ objects.append(jsNPObject->leakNPObject());
+ }
+
+ m_jsNPObjects.clear();
+
+ for (size_t i = 0; i < objects.size(); ++i)
+ releaseNPObject(objects[i]);
+
+ // Deal with any objects that were scheduled for delayed destruction
+ if (m_npObjectsToFinalize.isEmpty())
+ return;
+ ASSERT(m_finalizationTimer.isActive());
+ m_finalizationTimer.stop();
+ invalidateQueuedObjects();
+}
+
+JSGlobalObject* NPRuntimeObjectMap::globalObject() const
+{
+ Frame* frame = m_pluginView->frame();
+ if (!frame)
+ return 0;
+
+ return frame->script().globalObject(pluginWorld());
+}
+
+static String& globalExceptionString()
+{
+ static NeverDestroyed<String> exceptionString;
+ return exceptionString;
+}
+
+void NPRuntimeObjectMap::setGlobalException(const String& exceptionString)
+{
+ globalExceptionString() = exceptionString;
+}
+
+void NPRuntimeObjectMap::moveGlobalExceptionToExecState(JSGlobalObject* lexicalGlobalObject)
+{
+ VM& vm = lexicalGlobalObject->vm();
+ auto scope = DECLARE_THROW_SCOPE(vm);
+
+ if (globalExceptionString().isNull())
+ return;
+
+ {
+ JSLockHolder lock(vm);
+ throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, globalExceptionString()));
+ }
+
+ globalExceptionString() = String();
+}
+
+void NPRuntimeObjectMap::invalidateQueuedObjects()
+{
+ ASSERT(m_npObjectsToFinalize.size());
+ // We deliberately re-request m_npObjectsToFinalize.size() as custom dealloc
+ // functions may execute JS and so get more objects added to the dealloc queue
+ for (size_t i = 0; i < m_npObjectsToFinalize.size(); ++i)
+ deallocateNPObject(m_npObjectsToFinalize[i]);
+ m_npObjectsToFinalize.clear();
+}
+
+void NPRuntimeObjectMap::addToInvalidationQueue(NPObject* npObject)
+{
+ if (trySafeReleaseNPObject(npObject))
+ return;
+ if (m_npObjectsToFinalize.isEmpty())
+ m_finalizationTimer.startOneShot(0_s);
+ ASSERT(m_finalizationTimer.isActive());
+ m_npObjectsToFinalize.append(npObject);
+}
+
+void NPRuntimeObjectMap::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
+{
+ JSNPObject* object = static_cast<JSNPObject*>(handle.get().asCell());
+ weakRemove(m_jsNPObjects, static_cast<NPObject*>(context), object);
+ addToInvalidationQueue(object->leakNPObject());
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NPRuntimeObjectMap.h webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NPRuntimeObjectMap.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NPRuntimeObjectMap.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NPRuntimeObjectMap.h 2022-08-26 14:18:15.009022482 -0500
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+ */
+
+#ifndef NPJSObjectWrapperMap_h
+#define NPJSObjectWrapperMap_h
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include <JavaScriptCore/Weak.h>
+#include <JavaScriptCore/WeakInlines.h>
+#include <wtf/Forward.h>
+#include <wtf/HashMap.h>
+#include <wtf/RunLoop.h>
+
+struct NPObject;
+typedef struct _NPVariant NPVariant;
+
+namespace JSC {
+ class CallFrame;
+ class VM;
+ class JSGlobalObject;
+ class JSObject;
+ class JSValue;
+}
+
+namespace WebKit {
+
+class JSNPObject;
+class NPJSObject;
+class PluginView;
+
+// A per plug-in map of NPObjects that wrap JavaScript objects.
+class NPRuntimeObjectMap : private JSC::WeakHandleOwner {
+public:
+ explicit NPRuntimeObjectMap(PluginView*);
+
+ class PluginProtector {
+ public:
+ explicit PluginProtector(NPRuntimeObjectMap* npRuntimeObjectMap);
+ ~PluginProtector();
+
+ private:
+ RefPtr<PluginView> m_pluginView;
+ };
+
+ // Returns an NPObject that wraps the given JSObject object. If there is already an NPObject that wraps this JSObject, it will
+ // retain it and return it.
+ NPObject* getOrCreateNPObject(JSC::VM&, JSC::JSObject*);
+ void npJSObjectDestroyed(NPJSObject*);
+
+ // Returns a JSObject object that wraps the given NPObject.
+ JSC::JSObject* getOrCreateJSObject(JSC::JSGlobalObject*, NPObject*);
+ void jsNPObjectDestroyed(JSNPObject*);
+
+ void convertJSValueToNPVariant(JSC::JSGlobalObject*, JSC::JSValue, NPVariant&);
+ JSC::JSValue convertNPVariantToJSValue(JSC::JSGlobalObject*, const NPVariant&);
+
+ bool evaluate(NPObject*, const String& scriptString, NPVariant* result);
+
+ // Called when the plug-in is destroyed. Will invalidate all the NPObjects.
+ void invalidate();
+
+ JSC::JSGlobalObject* globalObject() const;
+
+ static void setGlobalException(const String& exceptionString);
+ static void moveGlobalExceptionToExecState(JSC::JSGlobalObject*);
+
+private:
+ // WeakHandleOwner
+ void finalize(JSC::Handle<JSC::Unknown>, void* context) override;
+ void addToInvalidationQueue(NPObject*);
+ void invalidateQueuedObjects();
+
+ PluginView* m_pluginView;
+ HashMap<JSC::JSObject*, NPJSObject*> m_npJSObjects;
+ HashMap<NPObject*, JSC::Weak<JSNPObject>> m_jsNPObjects;
+ Vector<NPObject*> m_npObjectsToFinalize;
+ RunLoop::Timer<NPRuntimeObjectMap> m_finalizationTimer;
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif // NPJSObjectWrapperMap_h
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NPRuntimeUtilities.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NPRuntimeUtilities.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NPRuntimeUtilities.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NPRuntimeUtilities.cpp 2022-08-26 14:18:15.009022482 -0500
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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 "config.h"
+#include "NPRuntimeUtilities.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include <string.h>
+#include <wtf/text/CString.h>
+
+namespace WebKit {
+
+void* npnMemAlloc(uint32_t size)
+{
+ // We could use fastMalloc here, but there might be plug-ins that mix NPN_MemAlloc/NPN_MemFree with malloc and free,
+ // so having them be equivalent seems like a good idea.
+ return malloc(size);
+}
+
+void npnMemFree(void* ptr)
+{
+ // We could use fastFree here, but there might be plug-ins that mix NPN_MemAlloc/NPN_MemFree with malloc and free,
+ // so having them be equivalent seems like a good idea.
+ free(ptr);
+}
+
+NPString createNPString(const CString& string)
+{
+ char* utf8Characters = npnMemNewArray<char>(string.length());
+ memcpy(utf8Characters, string.data(), string.length());
+
+ NPString npString;
+ npString.UTF8Characters = utf8Characters;
+ npString.UTF8Length = string.length();
+
+ return npString;
+}
+
+NPObject* createNPObject(NPP npp, NPClass* npClass)
+{
+ ASSERT(npClass);
+
+ NPObject* npObject;
+ if (npClass->allocate)
+ npObject = npClass->allocate(npp, npClass);
+ else
+ npObject = npnMemNew<NPObject>();
+
+ npObject->_class = npClass;
+ npObject->referenceCount = 1;
+
+ return npObject;
+}
+
+void deallocateNPObject(NPObject* npObject)
+{
+ ASSERT(npObject);
+ if (!npObject)
+ return;
+
+ if (npObject->_class->deallocate)
+ npObject->_class->deallocate(npObject);
+ else
+ npnMemFree(npObject);
+}
+
+void retainNPObject(NPObject* npObject)
+{
+ ASSERT(npObject);
+ if (!npObject)
+ return;
+
+ npObject->referenceCount++;
+}
+
+bool trySafeReleaseNPObject(NPObject* npObject)
+{
+ ASSERT(npObject);
+ if (!npObject)
+ return true;
+
+ ASSERT(npObject->referenceCount >= 1);
+
+ npObject->referenceCount--;
+ if (npObject->referenceCount)
+ return true;
+ if (npObject->_class->deallocate)
+ return false;
+ deallocateNPObject(npObject);
+ return true;
+}
+
+void releaseNPObject(NPObject* npObject)
+{
+ ASSERT(npObject);
+ if (!npObject)
+ return;
+
+ ASSERT(npObject->referenceCount >= 1);
+ npObject->referenceCount--;
+ if (!npObject->referenceCount)
+ deallocateNPObject(npObject);
+}
+
+void releaseNPVariantValue(NPVariant* variant)
+{
+ ASSERT(variant);
+
+ switch (variant->type) {
+ case NPVariantType_Void:
+ case NPVariantType_Null:
+ case NPVariantType_Bool:
+ case NPVariantType_Int32:
+ case NPVariantType_Double:
+ // Nothing to do.
+ break;
+
+ case NPVariantType_String:
+ npnMemFree(const_cast<NPUTF8*>(variant->value.stringValue.UTF8Characters));
+ variant->value.stringValue.UTF8Characters = 0;
+ variant->value.stringValue.UTF8Length = 0;
+ break;
+ case NPVariantType_Object:
+ releaseNPObject(variant->value.objectValue);
+ variant->value.objectValue = 0;
+ break;
+ }
+
+ variant->type = NPVariantType_Void;
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NPRuntimeUtilities.h webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NPRuntimeUtilities.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/NPRuntimeUtilities.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/NPRuntimeUtilities.h 2022-08-26 14:18:15.009022482 -0500
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+ */
+
+#ifndef NPRuntimeUtilities_h
+#define NPRuntimeUtilities_h
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include <WebCore/npruntime_internal.h>
+#include <wtf/Forward.h>
+
+struct NPClass;
+struct NPObject;
+
+namespace WebKit {
+
+void* npnMemAlloc(uint32_t);
+void npnMemFree(void*);
+
+template<typename T> T* npnMemNew()
+{
+ return static_cast<T*>(npnMemAlloc(sizeof(T)));
+}
+
+template<typename T> T* npnMemNewArray(size_t count)
+{
+ return static_cast<T*>(npnMemAlloc(sizeof(T) * count));
+}
+
+NPString createNPString(const CString&);
+
+NPObject* createNPObject(NPP, NPClass*);
+void deallocateNPObject(NPObject*);
+
+void retainNPObject(NPObject*);
+void releaseNPObject(NPObject*);
+
+// This function decrements the refcount of the specified object. If the
+// refcount reaches 0 it will attempt to destroy the object. If the object has
+// a custom deallocate function it will fail and return false, so it will be
+// up to the caller to call deallocateNPObject.
+// This function is used to implement the delayed finalization of NPObjects
+// released during GC.
+bool trySafeReleaseNPObject(NPObject*);
+
+void releaseNPVariantValue(NPVariant*);
+
+}
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif // NPRuntimeUtilities_h
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/unix/NetscapePluginUnix.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/unix/NetscapePluginUnix.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/unix/NetscapePluginUnix.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/unix/NetscapePluginUnix.cpp 2022-08-26 14:18:15.009022482 -0500
@@ -0,0 +1,174 @@
+/*
+ * Copyright (C) 2015 Igalia S.L.
+ *
+ * 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 INC. 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 INC. 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 "config.h"
+#include "NetscapePluginUnix.h"
+
+#if PLUGIN_ARCHITECTURE(UNIX) && ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "NetscapePlugin.h"
+#include "WebEvent.h"
+#include "WebMouseEvent.h"
+#include "WebWheelEvent.h"
+#include <WebCore/NotImplemented.h>
+#include <WebCore/PlatformDisplay.h>
+
+#if PLATFORM(X11)
+#include "NetscapePluginX11.h"
+#endif
+
+namespace WebKit {
+using namespace WebCore;
+
+void NetscapePlugin::platformPreInitialize()
+{
+}
+
+bool NetscapePlugin::platformPostInitialize()
+{
+#if PLATFORM(X11)
+ if (PlatformDisplay::sharedDisplay().type() == PlatformDisplay::Type::X11) {
+ m_impl = NetscapePluginX11::create(*this);
+ if (!m_impl)
+ return false;
+ }
+#endif
+
+ // Windowed plugins need a platform implementation.
+ if (!m_impl)
+ return !m_isWindowed;
+
+ m_npWindow.type = m_impl->windowType();
+ m_npWindow.window = m_impl->window();
+ m_npWindow.ws_info = m_impl->windowSystemInfo();
+ callSetWindow();
+ return true;
+}
+
+void NetscapePlugin::platformDestroy()
+{
+ m_impl = nullptr;
+}
+
+bool NetscapePlugin::platformInvalidate(const IntRect&)
+{
+ notImplemented();
+ return false;
+}
+
+void NetscapePlugin::platformGeometryDidChange()
+{
+ if (!m_impl)
+ return;
+ m_impl->geometryDidChange();
+}
+
+void NetscapePlugin::platformVisibilityDidChange()
+{
+ if (!m_isWindowed || !m_impl)
+ return;
+
+ m_impl->visibilityDidChange();
+}
+
+void NetscapePlugin::platformPaint(GraphicsContext& context, const IntRect& dirtyRect, bool /*isSnapshot*/)
+{
+ if (m_isWindowed || !m_impl)
+ return;
+
+ if (!m_isStarted) {
+ // FIXME: we should paint a missing plugin icon.
+ return;
+ }
+
+ m_impl->paint(context, dirtyRect);
+}
+
+bool NetscapePlugin::platformHandleMouseEvent(const WebMouseEvent& event)
+{
+ if (m_isWindowed || !m_impl)
+ return false;
+
+#if PLATFORM(X11)
+ if ((event.type() == WebEvent::MouseDown || event.type() == WebEvent::MouseUp)
+ && event.button() == WebMouseEvent::RightButton
+ && quirks().contains(PluginQuirks::IgnoreRightClickInWindowlessMode))
+ return false;
+#endif
+
+ return m_impl->handleMouseEvent(event);
+}
+
+bool NetscapePlugin::platformHandleWheelEvent(const WebWheelEvent& event)
+{
+ if (m_isWindowed || !m_impl)
+ return false;
+
+ return m_impl->handleWheelEvent(event);
+}
+
+void NetscapePlugin::platformSetFocus(bool focusIn)
+{
+ if (m_isWindowed || !m_impl)
+ return;
+
+ m_impl->setFocus(focusIn);
+}
+
+bool NetscapePlugin::wantsPluginRelativeNPWindowCoordinates()
+{
+ return true;
+}
+
+bool NetscapePlugin::platformHandleMouseEnterEvent(const WebMouseEvent& event)
+{
+ if (m_isWindowed || !m_impl)
+ return false;
+
+ return m_impl->handleMouseEnterEvent(event);
+}
+
+bool NetscapePlugin::platformHandleMouseLeaveEvent(const WebMouseEvent& event)
+{
+ if (m_isWindowed || !m_impl)
+ return false;
+
+ return m_impl->handleMouseLeaveEvent(event);
+}
+
+bool NetscapePlugin::platformHandleKeyboardEvent(const WebKeyboardEvent& event)
+{
+ // We don't generate other types of keyboard events via WebEventFactory.
+ ASSERT(event.type() == WebEvent::KeyDown || event.type() == WebEvent::KeyUp);
+
+ if (m_isWindowed || !m_impl)
+ return false;
+
+ return m_impl->handleKeyboardEvent(event);
+}
+
+} // namespace WebKit
+
+#endif // PLUGIN_ARCHITECTURE(UNIX) && ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/unix/NetscapePluginUnix.h webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/unix/NetscapePluginUnix.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/unix/NetscapePluginUnix.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/unix/NetscapePluginUnix.h 2022-08-26 14:18:15.009022482 -0500
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2015 Igalia S.L.
+ *
+ * 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 INC. 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 INC. 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.
+ */
+
+#ifndef NetscapePluginUnix_h
+#define NetscapePluginUnix_h
+
+#if PLUGIN_ARCHITECTURE(UNIX) && ENABLE(NETSCAPE_PLUGIN_API)
+
+#include <WebCore/npruntime_internal.h>
+
+namespace WebCore {
+class GraphicsContext;
+class IntRect;
+}
+
+namespace WebKit {
+
+class WebKeyboardEvent;
+class WebMouseEvent;
+class WebWheelEvent;
+
+class NetscapePluginUnix {
+public:
+ virtual ~NetscapePluginUnix() { }
+ virtual NPWindowType windowType() const = 0;
+ virtual void* window() const = 0;
+ virtual NPSetWindowCallbackStruct* windowSystemInfo() = 0;
+ virtual void geometryDidChange() = 0;
+ virtual void visibilityDidChange() = 0;
+ virtual void paint(WebCore::GraphicsContext&, const WebCore::IntRect&) = 0;
+ virtual bool handleMouseEvent(const WebMouseEvent&) = 0;
+ virtual bool handleWheelEvent(const WebWheelEvent&) = 0;
+ virtual bool handleMouseEnterEvent(const WebMouseEvent&) = 0;
+ virtual bool handleMouseLeaveEvent(const WebMouseEvent&) = 0;
+ virtual bool handleKeyboardEvent(const WebKeyboardEvent&) = 0;
+ virtual void setFocus(bool) = 0;
+};
+
+} // namespace WebKit
+
+#endif // PLUGIN_ARCHITECTURE(UNIX) && ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif // NetscapePluginUnix_h
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/unix/PluginProxyUnix.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/unix/PluginProxyUnix.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/unix/PluginProxyUnix.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/unix/PluginProxyUnix.cpp 2022-08-26 14:18:15.009022482 -0500
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2011 Igalia S.L.
+ *
+ * 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 INC. 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 INC. 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 "config.h"
+#include "PluginProxy.h"
+
+#if ENABLE(PLUGIN_PROCESS)
+
+#include <WebCore/NotImplemented.h>
+
+namespace WebKit {
+
+bool PluginProxy::needsBackingStore() const
+{
+ notImplemented();
+ return true;
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(PLUGIN_PROCESS)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp 2022-08-26 14:18:15.013022503 -0500
@@ -0,0 +1,542 @@
+/*
+ * Copyright (C) 2010 Apple Inc. All rights reserved.
+ * Copyright (C) 2010 University of Szeged
+ *
+ * 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 INC. 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 INC. 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 "config.h"
+#include "NetscapePluginX11.h"
+
+#if PLATFORM(X11) && ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "NetscapePlugin.h"
+#include "PluginController.h"
+#include "WebEvent.h"
+#include "WebMouseEvent.h"
+#include "WebWheelEvent.h"
+#include "WebKeyboardEvent.h"
+#include <WebCore/GraphicsContext.h>
+#include <WebCore/NotImplemented.h>
+#include <WebCore/PlatformDisplayX11.h>
+#include <WebCore/XUniquePtr.h>
+
+#if PLATFORM(GTK)
+#include <gdk/gdkx.h>
+#include <gtk/gtk.h>
+#include <gtk/gtkx.h>
+#endif
+
+#if USE(CAIRO)
+#include <WebCore/GraphicsContextCairo.h>
+#include <WebCore/RefPtrCairo.h>
+#include <cairo/cairo-xlib.h>
+#endif
+
+namespace WebKit {
+using namespace WebCore;
+
+static inline Display* x11HostDisplay()
+{
+ return downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native();
+}
+
+static Display* getPluginDisplay()
+{
+#if PLATFORM(GTK)
+ // Since we're a gdk/gtk app, we'll (probably?) have the same X connection as any gdk-based
+ // plugins, so we can return that. We might want to add other implementations here later.
+ return gdk_x11_get_default_xdisplay();
+#else
+ return nullptr;
+#endif
+}
+
+static inline int x11Screen()
+{
+#if PLATFORM(GTK)
+ return gdk_x11_screen_get_screen_number(gdk_screen_get_default());
+#else
+ return 0;
+#endif
+}
+
+static inline int displayDepth()
+{
+#if PLATFORM(GTK)
+ return gdk_visual_get_depth(gdk_screen_get_system_visual(gdk_screen_get_default()));
+#else
+ return 0;
+#endif
+}
+
+static inline unsigned long rootWindowID()
+{
+#if PLATFORM(GTK)
+ return GDK_ROOT_WINDOW();
+#else
+ return 0;
+#endif
+}
+
+#if PLATFORM(GTK)
+static gboolean socketPlugRemovedCallback(GtkSocket*)
+{
+ // Default action is to destroy the GtkSocket, so we just return TRUE here
+ // to be able to reuse the socket. For some obscure reason, newer versions
+ // of flash plugin remove the plug from the socket, probably because the plug
+ // created by the plugin is re-parented.
+ return TRUE;
+}
+#endif
+
+std::unique_ptr<NetscapePluginX11> NetscapePluginX11::create(NetscapePlugin& plugin)
+{
+#if PLATFORM(GTK)
+ uint64_t windowID = 0;
+#endif
+ if (plugin.isWindowed()) {
+#if PLATFORM(GTK)
+ // NPPVplugiNeedsXEmbed is a boolean value, but at least the
+ // Flash player plugin is using an 'int' instead.
+ int needsXEmbed = 0;
+ plugin.NPP_GetValue(NPPVpluginNeedsXEmbed, &needsXEmbed);
+ if (needsXEmbed) {
+ windowID = plugin.controller()->createPluginContainer();
+ if (!windowID)
+ return nullptr;
+ } else {
+ notImplemented();
+ return nullptr;
+ }
+#else
+ notImplemented();
+ return nullptr;
+#endif
+ }
+
+ Display* display = getPluginDisplay();
+ if (!display)
+ return nullptr;
+
+#if PLATFORM(GTK)
+ if (plugin.isWindowed())
+ return makeUnique<NetscapePluginX11>(plugin, display, windowID);
+#endif
+
+ return makeUnique<NetscapePluginX11>(plugin, display);
+}
+
+NetscapePluginX11::NetscapePluginX11(NetscapePlugin& plugin, Display* display)
+ : m_plugin(plugin)
+ , m_pluginDisplay(display)
+{
+ Display* hostDisplay = x11HostDisplay();
+ int depth = displayDepth();
+ m_setWindowCallbackStruct.display = hostDisplay;
+ m_setWindowCallbackStruct.depth = depth;
+
+ XVisualInfo visualTemplate;
+ visualTemplate.screen = x11Screen();
+ visualTemplate.depth = depth;
+ visualTemplate.c_class = TrueColor;
+ int numMatching;
+ XUniquePtr<XVisualInfo> visualInfo(XGetVisualInfo(hostDisplay, VisualScreenMask | VisualDepthMask | VisualClassMask, &visualTemplate, &numMatching));
+ ASSERT(visualInfo);
+ Visual* visual = visualInfo.get()[0].visual;
+ ASSERT(visual);
+
+ m_setWindowCallbackStruct.type = NP_SETWINDOW;
+ m_setWindowCallbackStruct.visual = visual;
+ m_setWindowCallbackStruct.colormap = XCreateColormap(hostDisplay, rootWindowID(), visual, AllocNone);
+}
+
+#if PLATFORM(GTK)
+NetscapePluginX11::NetscapePluginX11(NetscapePlugin& plugin, Display* display, uint64_t windowID)
+ : m_plugin(plugin)
+ , m_pluginDisplay(display)
+{
+ // It seems flash needs the socket to be in the same process,
+ // I guess it uses gdk_window_lookup(), so we create a new socket here
+ // containing a plug with the UI process socket embedded.
+ m_platformPluginWidget = gtk_plug_new(static_cast<Window>(windowID));
+
+ // Hide the GtkPlug on delete-event since we assume the widget is valid while the plugin is active.
+ // platformDestroy() will be called anyway right after the delete-event.
+ g_signal_connect(m_platformPluginWidget, "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), nullptr);
+
+ GtkWidget* socket = gtk_socket_new();
+ // Do not show the plug widget until the socket is connected.
+ g_signal_connect_swapped(socket, "plug-added", G_CALLBACK(gtk_widget_show), m_platformPluginWidget);
+ g_signal_connect(socket, "plug-removed", G_CALLBACK(socketPlugRemovedCallback), nullptr);
+ gtk_container_add(GTK_CONTAINER(m_platformPluginWidget), socket);
+ gtk_widget_show(socket);
+
+ Display* hostDisplay = x11HostDisplay();
+ m_npWindowID = gtk_socket_get_id(GTK_SOCKET(socket));
+ GdkWindow* window = gtk_widget_get_window(socket);
+ m_setWindowCallbackStruct.type = NP_SETWINDOW;
+ m_setWindowCallbackStruct.display = GDK_WINDOW_XDISPLAY(window);
+ m_setWindowCallbackStruct.visual = GDK_VISUAL_XVISUAL(gdk_window_get_visual(window));
+ m_setWindowCallbackStruct.depth = gdk_visual_get_depth(gdk_window_get_visual(window));
+ m_setWindowCallbackStruct.colormap = XCreateColormap(hostDisplay, GDK_ROOT_WINDOW(), m_setWindowCallbackStruct.visual, AllocNone);
+
+ XFlush(hostDisplay);
+}
+#endif
+
+NetscapePluginX11::~NetscapePluginX11()
+{
+ XFreeColormap(x11HostDisplay(), m_setWindowCallbackStruct.colormap);
+
+ m_drawable.reset();
+
+#if PLATFORM(GTK)
+ if (m_platformPluginWidget)
+ gtk_widget_destroy(m_platformPluginWidget);
+#endif
+}
+
+NPWindowType NetscapePluginX11::windowType() const
+{
+ return m_plugin.isWindowed() ? NPWindowTypeWindow : NPWindowTypeDrawable;
+}
+
+void* NetscapePluginX11::window() const
+{
+#if PLATFORM(GTK)
+ return m_plugin.isWindowed() ? GINT_TO_POINTER(m_npWindowID) : nullptr;
+#else
+ return nullptr;
+#endif
+}
+
+void NetscapePluginX11::geometryDidChange()
+{
+ if (m_plugin.isWindowed()) {
+ uint64_t windowID = 0;
+#if PLATFORM(GTK)
+ if (!gtk_plug_get_embedded(GTK_PLUG(m_platformPluginWidget)))
+ return;
+ windowID = static_cast<uint64_t>(GDK_WINDOW_XID(gtk_plug_get_socket_window(GTK_PLUG(m_platformPluginWidget))));
+#endif
+ m_plugin.controller()->windowedPluginGeometryDidChange(m_plugin.frameRectInWindowCoordinates(), m_plugin.clipRect(), windowID);
+ return;
+ }
+
+ m_drawable.reset();
+ if (m_plugin.size().isEmpty())
+ return;
+
+ m_drawable = XCreatePixmap(x11HostDisplay(), rootWindowID(), m_plugin.size().width(), m_plugin.size().height(), displayDepth());
+ XSync(x11HostDisplay(), false); // Make sure that the server knows about the Drawable.
+}
+
+void NetscapePluginX11::visibilityDidChange()
+{
+ ASSERT(m_plugin.isWindowed());
+ uint64_t windowID = 0;
+#if PLATFORM(GTK)
+ if (!gtk_plug_get_embedded(GTK_PLUG(m_platformPluginWidget)))
+ return;
+ windowID = static_cast<uint64_t>(GDK_WINDOW_XID(gtk_plug_get_socket_window(GTK_PLUG(m_platformPluginWidget))));
+#endif
+ m_plugin.controller()->windowedPluginVisibilityDidChange(m_plugin.isVisible(), windowID);
+ m_plugin.controller()->windowedPluginGeometryDidChange(m_plugin.frameRectInWindowCoordinates(), m_plugin.clipRect(), windowID);
+}
+
+void NetscapePluginX11::paint(GraphicsContext& context, const IntRect& dirtyRect)
+{
+ ASSERT(!m_plugin.isWindowed());
+
+ if (context.paintingDisabled() || !m_drawable)
+ return;
+
+ XEvent xevent;
+ memset(&xevent, 0, sizeof(XEvent));
+ XGraphicsExposeEvent& exposeEvent = xevent.xgraphicsexpose;
+ exposeEvent.type = GraphicsExpose;
+ exposeEvent.display = x11HostDisplay();
+ exposeEvent.drawable = m_drawable.get();
+
+ IntRect exposedRect(dirtyRect);
+ exposeEvent.x = exposedRect.x();
+ exposeEvent.y = exposedRect.y();
+
+ // Note: in transparent mode Flash thinks width is the right and height is the bottom.
+ // We should take it into account if we want to support transparency.
+ exposeEvent.width = exposedRect.width();
+ exposeEvent.height = exposedRect.height();
+
+ m_plugin.NPP_HandleEvent(&xevent);
+
+ if (m_pluginDisplay != x11HostDisplay())
+ XSync(m_pluginDisplay, false);
+
+#if PLATFORM(GTK)
+ RefPtr<cairo_surface_t> drawableSurface = adoptRef(cairo_xlib_surface_create(m_pluginDisplay, m_drawable.get(),
+ m_setWindowCallbackStruct.visual, m_plugin.size().width(), m_plugin.size().height()));
+ cairo_t* cr = context.platformContext()->cr();
+ cairo_save(cr);
+
+ cairo_set_source_surface(cr, drawableSurface.get(), 0, 0);
+
+ cairo_rectangle(cr, exposedRect.x(), exposedRect.y(), exposedRect.width(), exposedRect.height());
+ cairo_clip(cr);
+ cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
+ cairo_paint(cr);
+
+ cairo_restore(cr);
+#else
+ notImplemented();
+#endif
+}
+
+static inline void initializeXEvent(XEvent& event)
+{
+ memset(&event, 0, sizeof(XEvent));
+ event.xany.serial = 0;
+ event.xany.send_event = false;
+ event.xany.display = x11HostDisplay();
+ event.xany.window = 0;
+}
+
+static inline uint64_t xTimeStamp(WallTime timestamp)
+{
+ return timestamp.secondsSinceEpoch().milliseconds();
+}
+
+static inline unsigned xKeyModifiers(const WebEvent& event)
+{
+ unsigned xModifiers = 0;
+ if (event.controlKey())
+ xModifiers |= ControlMask;
+ if (event.shiftKey())
+ xModifiers |= ShiftMask;
+ if (event.altKey())
+ xModifiers |= Mod1Mask;
+ if (event.metaKey())
+ xModifiers |= Mod4Mask;
+
+ return xModifiers;
+}
+
+template <typename XEventType, typename WebEventType>
+static inline void setCommonMouseEventFields(XEventType& xEvent, const WebEventType& webEvent, const WebCore::IntPoint& pluginLocation)
+{
+ xEvent.root = rootWindowID();
+ xEvent.subwindow = 0;
+ xEvent.time = xTimeStamp(webEvent.timestamp());
+ xEvent.x = webEvent.position().x() - pluginLocation.x();
+ xEvent.y = webEvent.position().y() - pluginLocation.y();
+ xEvent.x_root = webEvent.globalPosition().x();
+ xEvent.y_root = webEvent.globalPosition().y();
+ xEvent.state = xKeyModifiers(webEvent);
+ xEvent.same_screen = true;
+}
+
+static inline void setXMotionEventFields(XEvent& xEvent, const WebMouseEvent& webEvent, const WebCore::IntPoint& pluginLocation)
+{
+ XMotionEvent& xMotion = xEvent.xmotion;
+ setCommonMouseEventFields(xMotion, webEvent, pluginLocation);
+ xMotion.type = MotionNotify;
+}
+
+static inline void setXButtonEventFields(XEvent& xEvent, const WebMouseEvent& webEvent, const WebCore::IntPoint& pluginLocation)
+{
+ XButtonEvent& xButton = xEvent.xbutton;
+ setCommonMouseEventFields(xButton, webEvent, pluginLocation);
+
+ xButton.type = (webEvent.type() == WebEvent::MouseDown) ? ButtonPress : ButtonRelease;
+ switch (webEvent.button()) {
+ case WebMouseEvent::LeftButton:
+ xButton.button = Button1;
+ break;
+ case WebMouseEvent::MiddleButton:
+ xButton.button = Button2;
+ break;
+ case WebMouseEvent::RightButton:
+ xButton.button = Button3;
+ break;
+ default:
+ ASSERT_NOT_REACHED();
+ break;
+ }
+}
+
+static inline void setXButtonEventFieldsByWebWheelEvent(XEvent& xEvent, const WebWheelEvent& webEvent, const WebCore::IntPoint& pluginLocation)
+{
+ XButtonEvent& xButton = xEvent.xbutton;
+ setCommonMouseEventFields(xButton, webEvent, pluginLocation);
+
+ xButton.type = ButtonPress;
+ FloatSize ticks = webEvent.wheelTicks();
+ if (ticks.height()) {
+ if (ticks.height() > 0)
+ xButton.button = 4; // up
+ else
+ xButton.button = 5; // down
+ } else {
+ if (ticks.width() > 0)
+ xButton.button = 6; // left
+ else
+ xButton.button = 7; // right
+ }
+}
+
+static inline void setXCrossingEventFields(XEvent& xEvent, const WebMouseEvent& webEvent, const WebCore::IntPoint& pluginLocation, int type)
+{
+ XCrossingEvent& xCrossing = xEvent.xcrossing;
+ setCommonMouseEventFields(xCrossing, webEvent, pluginLocation);
+
+ xCrossing.type = type;
+ xCrossing.mode = NotifyNormal;
+ xCrossing.detail = NotifyDetailNone;
+ xCrossing.focus = false;
+}
+
+bool NetscapePluginX11::handleMouseEvent(const WebMouseEvent& event)
+{
+ ASSERT(!m_plugin.isWindowed());
+
+ XEvent xEvent;
+ initializeXEvent(xEvent);
+
+ switch (event.type()) {
+ case WebEvent::MouseDown:
+ case WebEvent::MouseUp:
+ setXButtonEventFields(xEvent, event, m_plugin.convertToRootView(IntPoint()));
+ break;
+ case WebEvent::MouseMove:
+ setXMotionEventFields(xEvent, event, m_plugin.convertToRootView(IntPoint()));
+ break;
+ case WebEvent::MouseForceChanged:
+ case WebEvent::MouseForceDown:
+ case WebEvent::MouseForceUp:
+ case WebEvent::NoType:
+ case WebEvent::Wheel:
+ case WebEvent::KeyDown:
+ case WebEvent::KeyUp:
+ case WebEvent::RawKeyDown:
+ case WebEvent::Char:
+#if ENABLE(TOUCH_EVENTS)
+ case WebEvent::TouchStart:
+ case WebEvent::TouchMove:
+ case WebEvent::TouchEnd:
+ case WebEvent::TouchCancel:
+#endif
+ return false;
+ }
+
+ return !m_plugin.NPP_HandleEvent(&xEvent);
+}
+
+// We undefine these constants in npruntime_internal.h to avoid collision
+// with WebKit and platform headers. Values are defined in X.h.
+const int kKeyPressType = 2;
+const int kKeyReleaseType = 3;
+const int kFocusInType = 9;
+const int kFocusOutType = 10;
+
+bool NetscapePluginX11::handleWheelEvent(const WebWheelEvent& event)
+{
+ ASSERT(!m_plugin.isWindowed());
+
+ XEvent xEvent;
+ initializeXEvent(xEvent);
+ setXButtonEventFieldsByWebWheelEvent(xEvent, event, m_plugin.convertToRootView(IntPoint()));
+
+ return !m_plugin.NPP_HandleEvent(&xEvent);
+}
+
+void NetscapePluginX11::setFocus(bool focusIn)
+{
+ ASSERT(!m_plugin.isWindowed());
+
+ XEvent xEvent;
+ initializeXEvent(xEvent);
+ XFocusChangeEvent& focusEvent = xEvent.xfocus;
+ focusEvent.type = focusIn ? kFocusInType : kFocusOutType;
+ focusEvent.mode = NotifyNormal;
+ focusEvent.detail = NotifyDetailNone;
+
+ m_plugin.NPP_HandleEvent(&xEvent);
+}
+
+bool NetscapePluginX11::handleMouseEnterEvent(const WebMouseEvent& event)
+{
+ ASSERT(!m_plugin.isWindowed());
+
+ XEvent xEvent;
+ initializeXEvent(xEvent);
+ setXCrossingEventFields(xEvent, event, m_plugin.convertToRootView(IntPoint()), EnterNotify);
+
+ return !m_plugin.NPP_HandleEvent(&xEvent);
+}
+
+bool NetscapePluginX11::handleMouseLeaveEvent(const WebMouseEvent& event)
+{
+ ASSERT(!m_plugin.isWindowed());
+
+ XEvent xEvent;
+ initializeXEvent(xEvent);
+ setXCrossingEventFields(xEvent, event, m_plugin.convertToRootView(IntPoint()), LeaveNotify);
+
+ return !m_plugin.NPP_HandleEvent(&xEvent);
+}
+
+static inline void setXKeyEventFields(XEvent& xEvent, const WebKeyboardEvent& webEvent)
+{
+ xEvent.xany.type = (webEvent.type() == WebEvent::KeyDown) ? kKeyPressType : kKeyReleaseType;
+ XKeyEvent& xKey = xEvent.xkey;
+ xKey.root = rootWindowID();
+ xKey.subwindow = 0;
+ xKey.time = xTimeStamp(webEvent.timestamp());
+ xKey.state = xKeyModifiers(webEvent);
+ xKey.keycode = webEvent.nativeVirtualKeyCode();
+
+ xKey.same_screen = true;
+
+ // Key events propagated to the plugin does not need to have position.
+ // source: https://developer.mozilla.org/en/NPEvent
+ xKey.x = 0;
+ xKey.y = 0;
+ xKey.x_root = 0;
+ xKey.y_root = 0;
+}
+
+bool NetscapePluginX11::handleKeyboardEvent(const WebKeyboardEvent& event)
+{
+ ASSERT(!m_plugin.isWindowed());
+ // We don't generate other types of keyboard events via WebEventFactory.
+ ASSERT(event.type() == WebEvent::KeyDown || event.type() == WebEvent::KeyUp);
+
+ XEvent xEvent;
+ initializeXEvent(xEvent);
+ setXKeyEventFields(xEvent, event);
+
+ return !m_plugin.NPP_HandleEvent(&xEvent);
+}
+
+} // namespace WebKit
+
+#endif // PLATFORM(X11) && ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.h webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.h 2022-08-26 14:18:15.013022503 -0500
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2010 Apple Inc. All rights reserved.
+ * Copyright (C) 2010 University of Szeged
+ *
+ * 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 INC. 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 INC. 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.
+ */
+
+#ifndef NetscapePluginX11_h
+#define NetscapePluginX11_h
+
+#if PLATFORM(X11) && ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "NetscapePluginUnix.h"
+#include <WebCore/XUniqueResource.h>
+
+namespace WebKit {
+
+class NetscapePlugin;
+
+class NetscapePluginX11 final : public NetscapePluginUnix {
+ WTF_MAKE_FAST_ALLOCATED;
+public:
+ static std::unique_ptr<NetscapePluginX11> create(NetscapePlugin&);
+ NetscapePluginX11(NetscapePlugin&, Display*);
+#if PLATFORM(GTK)
+ NetscapePluginX11(NetscapePlugin&, Display*, uint64_t windowID);
+#endif
+ virtual ~NetscapePluginX11();
+
+private:
+ NPWindowType windowType() const override;
+ void* window() const override;
+ NPSetWindowCallbackStruct* windowSystemInfo() override { return &m_setWindowCallbackStruct; }
+ void geometryDidChange() override;
+ void visibilityDidChange() override;
+ void paint(WebCore::GraphicsContext&, const WebCore::IntRect&) override;
+ bool handleMouseEvent(const WebMouseEvent&) override;
+ bool handleWheelEvent(const WebWheelEvent&) override;
+ bool handleMouseEnterEvent(const WebMouseEvent&) override;
+ bool handleMouseLeaveEvent(const WebMouseEvent&) override;
+ bool handleKeyboardEvent(const WebKeyboardEvent&) override;
+ void setFocus(bool) override;
+
+ NetscapePlugin& m_plugin;
+ Display* m_pluginDisplay { nullptr };
+ WebCore::XUniquePixmap m_drawable;
+ NPSetWindowCallbackStruct m_setWindowCallbackStruct;
+#if PLATFORM(GTK)
+ unsigned long m_npWindowID { 0 };
+ GtkWidget* m_platformPluginWidget { nullptr };
+#endif
+};
+} // namespace WebKit
+
+#endif // PLATFORM(X11) && ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif // NetscapePluginX11_h
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.h webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.h 2022-06-30 04:49:38.066179000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.h 2022-08-26 14:18:15.013022503 -0500
@@ -195,14 +195,18 @@ private:
bool handlesPageScaleFactor() const final;
bool requiresUnifiedScaleFactor() const final { return true; }
void setFocus(bool) final { }
+ NPObject* pluginScriptableNPObject() final { return nullptr; }
void windowFocusChanged(bool) final { }
void windowAndViewFramesChanged(const WebCore::IntRect& windowFrameInScreenCoordinates, const WebCore::IntRect& viewFrameInWindowCoordinates) final { }
void windowVisibilityChanged(bool) final { }
+ uint64_t pluginComplexTextInputIdentifier() const final { return 0; }
void sendComplexTextInput(const String& textInput) final { }
void setLayerHostingMode(LayerHostingMode) final { }
WebCore::Scrollbar* horizontalScrollbar() final { return m_horizontalScrollbar.get(); }
WebCore::Scrollbar* verticalScrollbar() final { return m_verticalScrollbar.get(); }
void storageBlockingStateChanged(bool) final { }
+ void privateBrowsingStateChanged(bool) final { }
+ bool getFormValue(String& formValue) final { return false; }
bool handleScroll(WebCore::ScrollDirection, WebCore::ScrollGranularity) final;
RefPtr<WebCore::FragmentedSharedBuffer> liveResourceData() const final;
void willDetachRenderer() final;
@@ -221,6 +225,7 @@ private:
bool performDictionaryLookupAtLocation(const WebCore::FloatPoint&) final;
String getSelectionString() const final;
+ String getSelectionForWordAtPoint(const WebCore::FloatPoint&) const final;
bool existingSelectionContainsPoint(const WebCore::FloatPoint&) const final;
bool shouldAllowScripting() final { return false; }
@@ -429,7 +434,7 @@ private:
} // namespace WebKit
SPECIALIZE_TYPE_TRAITS_BEGIN(WebKit::PDFPlugin)
- static bool isType(const WebKit::Plugin&) { return true; } // FIXME: Consolidate PDFPlugin and Plugin into one class.
+ static bool isType(const WebKit::Plugin& plugin) { return plugin.isPDFPlugin(); }
static bool isType(const WebCore::ScrollableArea& area) { return area.isPDFPlugin(); }
SPECIALIZE_TYPE_TRAITS_END()
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginController.h webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginController.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginController.h 2022-06-30 04:49:38.069512400 -0500
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginController.h 2022-08-26 14:18:15.013022503 -0500
@@ -28,6 +28,18 @@
#include <wtf/Forward.h>
#include <wtf/WeakPtr.h>
+#if PLATFORM(COCOA)
+#include "PluginComplexTextInputState.h"
+#endif
+
+struct NPObject;
+typedef struct _NPVariant NPVariant;
+typedef void* NPIdentifier;
+
+namespace WTF {
+class MachSendRight;
+}
+
namespace WebCore {
class HTTPHeaderMap;
class IntRect;
@@ -38,6 +50,12 @@ namespace WebKit {
class PluginController : public CanMakeWeakPtr<PluginController> {
public:
+ // Tells the controller that the plug-in wants the given rect to be repainted. The rect is in the plug-in's coordinate system.
+ virtual void invalidate(const WebCore::IntRect&) = 0;
+
+ // Returns the user agent string.
+ virtual String userAgent() = 0;
+
// Loads the given URL and associates it with the request ID.
//
// If a target is specified, then the URL will be loaded in the window or frame that the target refers to.
@@ -48,12 +66,117 @@ public:
virtual void loadURL(uint64_t requestID, const String& method, const String& urlString, const String& target,
const WebCore::HTTPHeaderMap& headerFields, const Vector<uint8_t>& httpBody, bool allowPopups) = 0;
+ // Continues the load of a stream that was requested by loadURL.
+ virtual void continueStreamLoad(uint64_t streamID) = 0;
+
+ // Cancels the load of a stream that was requested by loadURL.
+ virtual void cancelStreamLoad(uint64_t streamID) = 0;
+
+ // Cancels the load of the manual stream.
+ virtual void cancelManualStreamLoad() = 0;
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ // Get the NPObject that corresponds to the window JavaScript object. Returns a retained object.
+ virtual NPObject* windowScriptNPObject() = 0;
+
+ // Get the NPObject that corresponds to the plug-in's element. Returns a retained object.
+ virtual NPObject* pluginElementNPObject() = 0;
+
+ // Evaluates the given script string in the context of the given NPObject.
+ virtual bool evaluate(NPObject*, const String& scriptString, NPVariant* result, bool allowPopups) = 0;
+
+ // Called by the Netscape plug-in when it starts or stops playing audio.
+ virtual void setPluginIsPlayingAudio(bool) = 0;
+
+ // Returns whether the plugin should be muted.
+ virtual bool isMuted() const = 0;
+#endif
+
+ // Set the statusbar text.
+ virtual void setStatusbarText(const String&) = 0;
+
+ // Return whether accelerated compositing is enabled.
+ virtual bool isAcceleratedCompositingEnabled() = 0;
+
+ // Tells the controller that the plug-in process has crashed.
+ virtual void pluginProcessCrashed() = 0;
+
+#if PLATFORM(COCOA)
+ // Tells the controller that the plug-in focus or window focus did change.
+ virtual void pluginFocusOrWindowFocusChanged(bool) = 0;
+
+ // Tells the controller that complex text input be enabled or disabled for the plug-in.
+ virtual void setComplexTextInputState(PluginComplexTextInputState) = 0;
+
+ // Returns the mach port of the compositing render server.
+ virtual const WTF::MachSendRight& compositingRenderServerPort() = 0;
+#endif
+
// Returns the contents scale factor.
virtual float contentsScaleFactor() = 0;
+ // Returns the proxies for the given URL or null on failure.
+ virtual String proxiesForURL(const String&) = 0;
+
+ // Returns the cookies for the given URL or null on failure.
+ virtual String cookiesForURL(const String&) = 0;
+
+ // Sets the cookies for the given URL.
+ virtual void setCookiesForURL(const String& urlString, const String& cookieString) = 0;
+
+ // Get authentication credentials for the given protection space.
+ virtual bool getAuthenticationInfo(const WebCore::ProtectionSpace&, String& username, String& password) = 0;
+
+ // Returns whether private browsing is enabled.
+ virtual bool isPrivateBrowsingEnabled() = 0;
+
+ // Returns whether or not asynchronous plugin initialization is enabled.
+ virtual bool asynchronousPluginInitializationEnabled() const { return false; }
+
+ // Returns whether or not asynchronous plugin initialization should be attempted for all plugins.
+ virtual bool asynchronousPluginInitializationEnabledForAllPlugins() const { return false; }
+
+ // Returns the articifical plugin delay to use for testing of asynchronous plugin initialization.
+ virtual bool artificialPluginInitializationDelayEnabled() const { return false; }
+
+ // Increments a counter that prevents the plug-in from being destroyed.
+ virtual void protectPluginFromDestruction() = 0;
+
+ // Decrements a counter that, when it reaches 0, stops preventing the plug-in from being destroyed.
+ virtual void unprotectPluginFromDestruction() = 0;
+
+#if PLATFORM(X11) && ENABLE(NETSCAPE_PLUGIN_API)
+ // Create a plugin container for windowed plugins
+ virtual uint64_t createPluginContainer() = 0;
+ virtual void windowedPluginGeometryDidChange(const WebCore::IntRect& frameRect, const WebCore::IntRect& clipRect, uint64_t windowID) = 0;
+ virtual void windowedPluginVisibilityDidChange(bool isVisible, uint64_t windowID) = 0;
+#endif
+
// Called when the a plug-in instance is successfully initialized, either synchronously or asynchronously.
virtual void didInitializePlugin() = 0;
+ // Called when the a plug-in instance fails to initialized, either synchronously or asynchronously.
+ virtual void didFailToInitializePlugin() = 0;
+
+ // Helper class for delaying destruction of a plug-in.
+ class PluginDestructionProtector {
+ WTF_MAKE_FAST_ALLOCATED;
+ public:
+ explicit PluginDestructionProtector(PluginController* pluginController)
+ : m_pluginController(pluginController)
+ {
+ m_pluginController->protectPluginFromDestruction();
+ }
+
+ ~PluginDestructionProtector()
+ {
+ m_pluginController->unprotectPluginFromDestruction();
+ }
+
+ private:
+ PluginController* m_pluginController;
+ };
+
protected:
virtual ~PluginController() { }
};
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Plugin.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Plugin.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Plugin.cpp 2022-06-30 04:49:38.069512400 -0500
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Plugin.cpp 2022-08-26 14:18:15.013022503 -0500
@@ -79,7 +79,11 @@ bool Plugin::Parameters::decode(IPC::Dec
return true;
}
-Plugin::Plugin() = default;
+Plugin::Plugin(PluginType type)
+ : m_type(type)
+{
+}
+
Plugin::~Plugin() = default;
bool Plugin::initialize(PluginController& pluginController, const Parameters& parameters)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Plugin.h webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Plugin.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/Plugin.h 2022-06-30 04:49:38.069512400 -0500
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/Plugin.h 2022-08-26 14:18:15.013022503 -0500
@@ -44,6 +44,8 @@ OBJC_CLASS PDFDocument;
OBJC_CLASS PDFSelection;
#endif
+struct NPObject;
+
namespace IPC {
class Encoder;
class Decoder;
@@ -72,6 +74,12 @@ class WebWheelEvent;
class PluginController;
+enum PluginType {
+ PluginProxyType,
+ NetscapePluginType,
+ PDFPluginType,
+};
+
enum class LayerHostingMode : uint8_t;
class Plugin : public ThreadSafeRefCounted<Plugin> {
@@ -102,6 +110,12 @@ public:
virtual ~Plugin();
+ PluginType type() const { return m_type; }
+
+ bool isPluginProxy() const { return m_type == PluginProxyType; }
+ bool isNetscapePlugin() const { return m_type == NetscapePluginType; }
+ bool isPDFPlugin() const { return m_type == PDFPluginType; }
+
private:
// Initializes the plug-in. If the plug-in fails to initialize this should return false.
// This is only called by the other initialize overload so it can be made private.
@@ -218,6 +232,9 @@ public:
// Tells the plug-in about focus changes.
virtual void setFocus(bool) = 0;
+ // Get the NPObject that corresponds to the plug-in's scriptable object. Returns a retained object.
+ virtual NPObject* pluginScriptableNPObject() = 0;
+
// Tells the plug-in about window focus changes.
virtual void windowFocusChanged(bool) = 0;
@@ -228,6 +245,9 @@ public:
// Tells the plug-in about window and plug-in frame changes.
virtual void windowAndViewFramesChanged(const WebCore::IntRect& windowFrameInScreenCoordinates, const WebCore::IntRect& viewFrameInWindowCoordinates) = 0;
+ // Get the per complex text input identifier.
+ virtual uint64_t pluginComplexTextInputIdentifier() const = 0;
+
// Send the complex text input to the plug-in.
virtual void sendComplexTextInput(const String& textInput) = 0;
@@ -241,6 +261,12 @@ public:
// Called when the storage blocking policy for this plug-in changes.
virtual void storageBlockingStateChanged(bool) = 0;
+ // Called when the private browsing state for this plug-in changes.
+ virtual void privateBrowsingStateChanged(bool) = 0;
+
+ // Gets the form value representation for the plug-in, letting plug-ins participate in form submission.
+ virtual bool getFormValue(String& formValue) = 0;
+
// Tells the plug-in that it should scroll. The plug-in should return true if it did scroll.
virtual bool handleScroll(WebCore::ScrollDirection, WebCore::ScrollGranularity) = 0;
@@ -268,10 +294,13 @@ public:
virtual bool performDictionaryLookupAtLocation(const WebCore::FloatPoint&) = 0;
virtual String getSelectionString() const = 0;
+ virtual String getSelectionForWordAtPoint(const WebCore::FloatPoint&) const = 0;
virtual bool existingSelectionContainsPoint(const WebCore::FloatPoint&) const = 0;
virtual void mutedStateChanged(bool) { }
+ virtual bool canCreateTransientPaintingSnapshot() const { return true; }
+
virtual bool requiresUnifiedScaleFactor() const { return false; }
virtual void willDetachRenderer() { }
@@ -279,7 +308,9 @@ public:
virtual bool pluginHandlesContentOffsetForAccessibilityHitTest() const { return false; }
protected:
- Plugin();
+ Plugin(PluginType);
+
+ PluginType m_type;
bool m_isBeingDestroyed { false };
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginProcessConnection.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginProcessConnection.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginProcessConnection.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginProcessConnection.cpp 2022-08-26 14:18:15.013022503 -0500
@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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 "config.h"
+#include "PluginProcessConnection.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "NPObjectMessageReceiverMessages.h"
+#include "NPRemoteObjectMap.h"
+#include "NPRuntimeObjectMap.h"
+#include "PluginProcessConnectionManager.h"
+#include "PluginProxy.h"
+#include "WebProcess.h"
+#include "WebProcessProxyMessages.h"
+#include <JavaScriptCore/JSObject.h>
+#include <wtf/FileSystem.h>
+
+namespace WebKit {
+
+PluginProcessConnection::PluginProcessConnection(PluginProcessConnectionManager* pluginProcessConnectionManager, uint64_t pluginProcessToken, IPC::Connection::Identifier connectionIdentifier, bool supportsAsynchronousPluginInitialization)
+ : m_pluginProcessConnectionManager(pluginProcessConnectionManager)
+ , m_pluginProcessToken(pluginProcessToken)
+ , m_supportsAsynchronousPluginInitialization(supportsAsynchronousPluginInitialization)
+{
+ m_connection = IPC::Connection::createClientConnection(connectionIdentifier, *this);
+
+ m_npRemoteObjectMap = NPRemoteObjectMap::create(m_connection.get());
+
+ m_connection->open();
+}
+
+PluginProcessConnection::~PluginProcessConnection()
+{
+ ASSERT(!m_connection);
+ ASSERT(!m_npRemoteObjectMap);
+}
+
+void PluginProcessConnection::addPluginProxy(PluginProxy* plugin)
+{
+ ASSERT(!m_plugins.contains(plugin->pluginInstanceID()));
+ m_plugins.set(plugin->pluginInstanceID(), plugin);
+}
+
+void PluginProcessConnection::removePluginProxy(PluginProxy* plugin)
+{
+ ASSERT(m_plugins.contains(plugin->pluginInstanceID()));
+ m_plugins.remove(plugin->pluginInstanceID());
+
+ // Invalidate all objects related to this plug-in.
+ m_npRemoteObjectMap->pluginDestroyed(plugin);
+
+ if (!m_plugins.isEmpty())
+ return;
+
+ m_npRemoteObjectMap = nullptr;
+
+ // We have no more plug-ins, invalidate the connection to the plug-in process.
+ ASSERT(m_connection);
+ m_connection->invalidate();
+ m_connection = nullptr;
+
+ // This will cause us to be deleted.
+ m_pluginProcessConnectionManager->removePluginProcessConnection(this);
+}
+
+void PluginProcessConnection::didReceiveMessage(IPC::Connection& connection, IPC::Decoder& decoder)
+{
+ ASSERT(decoder.destinationID());
+
+ PluginProxy* pluginProxy = m_plugins.get(decoder.destinationID());
+ if (!pluginProxy)
+ return;
+
+ pluginProxy->didReceivePluginProxyMessage(connection, decoder);
+}
+
+bool PluginProcessConnection::didReceiveSyncMessage(IPC::Connection& connection, IPC::Decoder& decoder, UniqueRef<IPC::Encoder>& replyEncoder)
+{
+ if (decoder.messageReceiverName() == Messages::NPObjectMessageReceiver::messageReceiverName())
+ return m_npRemoteObjectMap->didReceiveSyncMessage(connection, decoder, replyEncoder);
+
+ uint64_t destinationID = decoder.destinationID();
+
+ if (!destinationID)
+ return didReceiveSyncPluginProcessConnectionMessage(connection, decoder, replyEncoder);
+
+ PluginProxy* pluginProxy = m_plugins.get(destinationID);
+ if (!pluginProxy)
+ return false;
+
+ return pluginProxy->didReceiveSyncPluginProxyMessage(connection, decoder, replyEncoder);
+}
+
+void PluginProcessConnection::didClose(IPC::Connection&)
+{
+ // The plug-in process must have crashed.
+ for (HashMap<uint64_t, PluginProxy*>::const_iterator::Values it = m_plugins.begin().values(), end = m_plugins.end().values(); it != end; ++it) {
+ PluginProxy* pluginProxy = (*it);
+
+ pluginProxy->pluginProcessCrashed();
+ }
+}
+
+void PluginProcessConnection::didReceiveInvalidMessage(IPC::Connection&, IPC::MessageName)
+{
+}
+
+void PluginProcessConnection::setException(const String& exceptionString, CompletionHandler<void()>&& completionHandler)
+{
+ NPRuntimeObjectMap::setGlobalException(exceptionString);
+ completionHandler();
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginProcessConnection.h webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginProcessConnection.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginProcessConnection.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginProcessConnection.h 2022-08-26 14:18:15.013022503 -0500
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+ */
+
+#ifndef PluginProcessConnection_h
+#define PluginProcessConnection_h
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "Connection.h"
+#include "Plugin.h"
+#include "PluginProcess.h"
+#include "PluginProcessAttributes.h"
+#include <wtf/RefCounted.h>
+
+namespace WebKit {
+
+class NPRemoteObjectMap;
+class PluginProcessConnectionManager;
+class PluginProxy;
+
+class PluginProcessConnection : public RefCounted<PluginProcessConnection>, IPC::Connection::Client {
+public:
+ static Ref<PluginProcessConnection> create(PluginProcessConnectionManager* pluginProcessConnectionManager, uint64_t pluginProcessToken, IPC::Connection::Identifier connectionIdentifier, bool supportsAsynchronousPluginInitialization)
+ {
+ return adoptRef(*new PluginProcessConnection(pluginProcessConnectionManager, pluginProcessToken, connectionIdentifier, supportsAsynchronousPluginInitialization));
+ }
+ ~PluginProcessConnection();
+
+ uint64_t pluginProcessToken() const { return m_pluginProcessToken; }
+
+ IPC::Connection* connection() const { return m_connection.get(); }
+
+ void addPluginProxy(PluginProxy*);
+ void removePluginProxy(PluginProxy*);
+
+ NPRemoteObjectMap* npRemoteObjectMap() const { return m_npRemoteObjectMap.get(); }
+
+ bool supportsAsynchronousPluginInitialization() const { return m_supportsAsynchronousPluginInitialization; }
+
+private:
+ PluginProcessConnection(PluginProcessConnectionManager*, uint64_t pluginProcessToken, IPC::Connection::Identifier connectionIdentifier, bool supportsAsynchronousInitialization);
+
+ // IPC::Connection::Client
+ void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
+ bool didReceiveSyncMessage(IPC::Connection&, IPC::Decoder&, UniqueRef<IPC::Encoder>&) override;
+ void didClose(IPC::Connection&) override;
+ void didReceiveInvalidMessage(IPC::Connection&, IPC::MessageName) override;
+
+ // Message handlers.
+ bool didReceiveSyncPluginProcessConnectionMessage(IPC::Connection&, IPC::Decoder&, UniqueRef<IPC::Encoder>&);
+ void setException(const String&, CompletionHandler<void()>&&);
+
+ PluginProcessConnectionManager* m_pluginProcessConnectionManager;
+ uint64_t m_pluginProcessToken;
+
+ // The connection from the web process to the plug-in process.
+ RefPtr<IPC::Connection> m_connection;
+
+ // The plug-ins. We use a weak reference to the plug-in proxies because the plug-in view holds the strong reference.
+ HashMap<uint64_t, PluginProxy*> m_plugins;
+
+ RefPtr<NPRemoteObjectMap> m_npRemoteObjectMap;
+
+ bool m_supportsAsynchronousPluginInitialization;
+};
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif // PluginProcessConnection_h
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginProcessConnectionManager.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginProcessConnectionManager.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginProcessConnectionManager.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginProcessConnectionManager.cpp 2022-08-26 14:18:15.013022503 -0500
@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2010-2018 Apple 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 INC. 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 INC. 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 "config.h"
+#include "PluginProcessConnectionManager.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "Decoder.h"
+#include "Encoder.h"
+#include "PluginProcessConnection.h"
+#include "PluginProcessConnectionManagerMessages.h"
+#include "WebCoreArgumentCoders.h"
+#include "WebProcess.h"
+#include "WebProcessProxyMessages.h"
+
+#if OS(DARWIN) && !USE(UNIX_DOMAIN_SOCKETS)
+#include "MachPort.h"
+#endif
+
+namespace WebKit {
+
+Ref<PluginProcessConnectionManager> PluginProcessConnectionManager::create()
+{
+ return adoptRef(*new PluginProcessConnectionManager);
+}
+
+PluginProcessConnectionManager::PluginProcessConnectionManager()
+ : m_queue(WorkQueue::create("com.apple.WebKit.PluginProcessConnectionManager"))
+{
+}
+
+PluginProcessConnectionManager::~PluginProcessConnectionManager()
+{
+ ASSERT_NOT_REACHED();
+}
+
+void PluginProcessConnectionManager::initializeConnection(IPC::Connection* connection)
+{
+ connection->addWorkQueueMessageReceiver(Messages::PluginProcessConnectionManager::messageReceiverName(), m_queue.get(), this);
+}
+
+PluginProcessConnection* PluginProcessConnectionManager::getPluginProcessConnection(uint64_t pluginProcessToken)
+{
+ for (size_t i = 0; i < m_pluginProcessConnections.size(); ++i) {
+ if (m_pluginProcessConnections[i]->pluginProcessToken() == pluginProcessToken)
+ return m_pluginProcessConnections[i].get();
+ }
+
+ IPC::Attachment encodedConnectionIdentifier;
+ bool supportsAsynchronousInitialization;
+ if (!WebProcess::singleton().parentProcessConnection()->sendSync(Messages::WebProcessProxy::GetPluginProcessConnection(pluginProcessToken),
+ Messages::WebProcessProxy::GetPluginProcessConnection::Reply(encodedConnectionIdentifier, supportsAsynchronousInitialization), 0))
+ return nullptr;
+
+#if USE(UNIX_DOMAIN_SOCKETS)
+ IPC::Connection::Identifier connectionIdentifier = encodedConnectionIdentifier.releaseFileDescriptor();
+#elif OS(DARWIN)
+ IPC::Connection::Identifier connectionIdentifier(encodedConnectionIdentifier.port());
+#elif OS(WINDOWS)
+ IPC::Connection::Identifier connectionIdentifier = encodedConnectionIdentifier.handle();
+#endif
+ if (!IPC::Connection::identifierIsValid(connectionIdentifier))
+ return nullptr;
+
+ auto pluginProcessConnection = PluginProcessConnection::create(this, pluginProcessToken, connectionIdentifier, supportsAsynchronousInitialization);
+ m_pluginProcessConnections.append(pluginProcessConnection.copyRef());
+
+ {
+ Locker locker { m_tokensAndConnectionsLock };
+ ASSERT(!m_tokensAndConnections.contains(pluginProcessToken));
+
+ m_tokensAndConnections.set(pluginProcessToken, pluginProcessConnection->connection());
+ }
+
+ return pluginProcessConnection.ptr();
+}
+
+void PluginProcessConnectionManager::removePluginProcessConnection(PluginProcessConnection* pluginProcessConnection)
+{
+ size_t vectorIndex = m_pluginProcessConnections.find(pluginProcessConnection);
+ ASSERT(vectorIndex != notFound);
+
+ {
+ Locker locker { m_tokensAndConnectionsLock };
+ ASSERT(m_tokensAndConnections.contains(pluginProcessConnection->pluginProcessToken()));
+
+ m_tokensAndConnections.remove(pluginProcessConnection->pluginProcessToken());
+ }
+
+ m_pluginProcessConnections.remove(vectorIndex);
+}
+
+void PluginProcessConnectionManager::pluginProcessCrashed(uint64_t pluginProcessToken)
+{
+ Locker locker { m_tokensAndConnectionsLock };
+ IPC::Connection* connection = m_tokensAndConnections.get(pluginProcessToken);
+
+ // It's OK for connection to be null here; it will happen if this web process doesn't know
+ // anything about the plug-in process.
+ if (!connection)
+ return;
+
+ connection->postConnectionDidCloseOnConnectionWorkQueue();
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginProcessConnectionManager.h webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginProcessConnectionManager.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginProcessConnectionManager.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginProcessConnectionManager.h 2022-08-26 14:18:15.013022503 -0500
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+ */
+
+#ifndef PluginProcessConnectionManager_h
+#define PluginProcessConnectionManager_h
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "PluginProcess.h"
+#include <wtf/Forward.h>
+#include <wtf/HashMap.h>
+#include <wtf/Lock.h>
+#include <wtf/Noncopyable.h>
+#include <wtf/Threading.h>
+#include <wtf/Vector.h>
+#include <wtf/text/StringHash.h>
+
+// Manages plug-in process connections for the given web process.
+
+namespace WebKit {
+
+class PluginProcessConnection;
+
+class PluginProcessConnectionManager : public IPC::Connection::WorkQueueMessageReceiver {
+public:
+ static Ref<PluginProcessConnectionManager> create();
+ ~PluginProcessConnectionManager();
+
+ void initializeConnection(IPC::Connection*);
+
+ PluginProcessConnection* getPluginProcessConnection(uint64_t pluginProcessToken);
+ void removePluginProcessConnection(PluginProcessConnection*);
+
+private:
+ PluginProcessConnectionManager();
+
+ // IPC::Connection::WorkQueueMessageReceiver.
+ void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
+
+ void pluginProcessCrashed(uint64_t pluginProcessToken);
+
+ Ref<WorkQueue> m_queue;
+
+ Vector<RefPtr<PluginProcessConnection>> m_pluginProcessConnections;
+
+ Lock m_tokensAndConnectionsLock;
+ HashMap<uint64_t, RefPtr<IPC::Connection>> m_tokensAndConnections WTF_GUARDED_BY_LOCK(m_tokensAndConnectionsLock);
+};
+
+}
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
+#endif // PluginProcessConnectionManager_h
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginProcessConnectionManager.messages.in webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginProcessConnectionManager.messages.in
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginProcessConnectionManager.messages.in 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginProcessConnectionManager.messages.in 2022-08-26 14:18:15.013022503 -0500
@@ -0,0 +1,29 @@
+# Copyright (C) 2013 Apple 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 INC. 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 INC. 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.
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+messages -> PluginProcessConnectionManager {
+ PluginProcessCrashed(uint64_t pluginProcessToken)
+}
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginProcessConnection.messages.in webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginProcessConnection.messages.in
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginProcessConnection.messages.in 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginProcessConnection.messages.in 2022-08-26 14:18:15.013022503 -0500
@@ -0,0 +1,30 @@
+# Copyright (C) 2011 Apple 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 INC. 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 INC. 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.
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+messages -> PluginProcessConnection LegacyReceiver {
+ # Set a global JavaScript exception.
+ SetException(String exceptionString) -> () Synchronous
+}
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginProxy.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginProxy.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginProxy.cpp 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginProxy.cpp 2022-08-26 14:18:15.013022503 -0500
@@ -0,0 +1,747 @@
+/*
+ * Copyright (C) 2010 Apple 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 INC. 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 INC. 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 "config.h"
+#include "PluginProxy.h"
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "DataReference.h"
+#include "NPRemoteObjectMap.h"
+#include "NPRuntimeUtilities.h"
+#include "NPVariantData.h"
+#include "PluginController.h"
+#include "PluginControllerProxyMessages.h"
+#include "PluginCreationParameters.h"
+#include "PluginProcessConnection.h"
+#include "PluginProcessConnectionManager.h"
+#include "ShareableBitmap.h"
+#include "WebCoreArgumentCoders.h"
+#include "WebKeyboardEvent.h"
+#include "WebMouseEvent.h"
+#include "WebProcess.h"
+#include "WebProcessConnectionMessages.h"
+#include "WebWheelEvent.h"
+#include <WebCore/GraphicsContext.h>
+#include <WebCore/SharedBuffer.h>
+
+namespace WebKit {
+using namespace WebCore;
+
+static uint64_t generatePluginInstanceID()
+{
+ static uint64_t uniquePluginInstanceID;
+ return ++uniquePluginInstanceID;
+}
+
+Ref<PluginProxy> PluginProxy::create(uint64_t pluginProcessToken)
+{
+ return adoptRef(*new PluginProxy(pluginProcessToken));
+}
+
+PluginProxy::PluginProxy(uint64_t pluginProcessToken)
+ : Plugin(PluginProxyType)
+ , m_pluginProcessToken(pluginProcessToken)
+ , m_pluginInstanceID(generatePluginInstanceID())
+{
+}
+
+PluginProxy::~PluginProxy()
+{
+}
+
+void PluginProxy::pluginProcessCrashed()
+{
+ controller()->pluginProcessCrashed();
+}
+
+bool PluginProxy::initialize(const Parameters& parameters)
+{
+ ASSERT(!m_connection);
+ m_connection = WebProcess::singleton().pluginProcessConnectionManager().getPluginProcessConnection(m_pluginProcessToken);
+
+ if (!m_connection)
+ return false;
+
+ // Add the plug-in proxy before creating the plug-in; it needs to be in the map because CreatePlugin
+ // can call back out to the plug-in proxy.
+ m_connection->addPluginProxy(this);
+
+ // Ask the plug-in process to create a plug-in.
+ m_pendingPluginCreationParameters = makeUnique<PluginCreationParameters>();
+
+ m_pendingPluginCreationParameters->pluginInstanceID = m_pluginInstanceID;
+ m_pendingPluginCreationParameters->windowNPObjectID = windowNPObjectID();
+ m_pendingPluginCreationParameters->parameters = parameters;
+ m_pendingPluginCreationParameters->userAgent = controller()->userAgent();
+ m_pendingPluginCreationParameters->contentsScaleFactor = contentsScaleFactor();
+ m_pendingPluginCreationParameters->isPrivateBrowsingEnabled = controller()->isPrivateBrowsingEnabled();
+ m_pendingPluginCreationParameters->isMuted = controller()->isMuted();
+ m_pendingPluginCreationParameters->artificialPluginInitializationDelayEnabled = controller()->artificialPluginInitializationDelayEnabled();
+ m_pendingPluginCreationParameters->isAcceleratedCompositingEnabled = controller()->isAcceleratedCompositingEnabled();
+
+ if (!canInitializeAsynchronously())
+ return initializeSynchronously();
+
+ // Remember that we tried to create this plug-in asynchronously in case we need to create it synchronously later.
+ m_waitingOnAsynchronousInitialization = true;
+ PluginCreationParameters creationParameters(*m_pendingPluginCreationParameters.get());
+ m_connection->connection()->send(Messages::WebProcessConnection::CreatePluginAsynchronously(creationParameters), m_pluginInstanceID);
+ return true;
+}
+
+bool PluginProxy::canInitializeAsynchronously() const
+{
+ return controller()->asynchronousPluginInitializationEnabled() && (m_connection->supportsAsynchronousPluginInitialization() || controller()->asynchronousPluginInitializationEnabledForAllPlugins());
+}
+
+bool PluginProxy::initializeSynchronously()
+{
+ ASSERT(m_pendingPluginCreationParameters);
+
+ m_pendingPluginCreationParameters->asynchronousCreationIncomplete = m_waitingOnAsynchronousInitialization;
+ bool result = false;
+ bool wantsWheelEvents = false;
+ uint32_t remoteLayerClientID = 0;
+
+ PluginCreationParameters parameters(*m_pendingPluginCreationParameters.get());
+
+ if (!m_connection->connection()->sendSync(Messages::WebProcessConnection::CreatePlugin(parameters), Messages::WebProcessConnection::CreatePlugin::Reply(result, wantsWheelEvents, remoteLayerClientID), 0) || !result)
+ didFailToCreatePluginInternal();
+ else
+ didCreatePluginInternal(wantsWheelEvents, remoteLayerClientID);
+
+ return result;
+}
+
+void PluginProxy::didCreatePlugin(bool wantsWheelEvents, uint32_t remoteLayerClientID, CompletionHandler<void()>&& completionHandler)
+{
+ // We might have tried to create the plug-in sychronously while waiting on the asynchronous reply,
+ // in which case we should ignore this message.
+ if (!m_waitingOnAsynchronousInitialization)
+ return completionHandler();
+
+ didCreatePluginInternal(wantsWheelEvents, remoteLayerClientID);
+ completionHandler();
+}
+
+void PluginProxy::didFailToCreatePlugin(CompletionHandler<void()>&& completionHandler)
+{
+ // We might have tried to create the plug-in sychronously while waiting on the asynchronous reply,
+ // in which case we should ignore this message.
+ if (!m_waitingOnAsynchronousInitialization)
+ return completionHandler();
+
+ didFailToCreatePluginInternal();
+ completionHandler();
+}
+
+void PluginProxy::didCreatePluginInternal(bool wantsWheelEvents, uint32_t remoteLayerClientID)
+{
+ m_wantsWheelEvents = wantsWheelEvents;
+ m_remoteLayerClientID = remoteLayerClientID;
+ m_isStarted = true;
+ controller()->didInitializePlugin();
+
+ // Whether synchronously or asynchronously, this plug-in was created and we shouldn't need to remember
+ // anything about how.
+ m_pendingPluginCreationParameters = nullptr;
+ m_waitingOnAsynchronousInitialization = false;
+}
+
+void PluginProxy::didFailToCreatePluginInternal()
+{
+ // Calling out to the connection and the controller could potentially cause the plug-in proxy to go away, so protect it here.
+ Ref<PluginProxy> protect(*this);
+
+ m_connection->removePluginProxy(this);
+ controller()->didFailToInitializePlugin();
+
+ // Whether synchronously or asynchronously, this plug-in failed to create and we shouldn't need to remember
+ // anything about how.
+ m_pendingPluginCreationParameters = nullptr;
+ m_waitingOnAsynchronousInitialization = false;
+}
+
+void PluginProxy::destroy()
+{
+ m_isStarted = false;
+
+ if (!m_connection)
+ return;
+
+ // Although this message is sent synchronously, the Plugin process replies immediately (before performing any tasks) so this is only waiting for
+ // confirmation that the Plugin process received the DestroyPlugin message.
+ m_connection->connection()->sendSync(Messages::WebProcessConnection::DestroyPlugin(m_pluginInstanceID, m_waitingOnAsynchronousInitialization), Messages::WebProcessConnection::DestroyPlugin::Reply(), 0, 1_s);
+ m_connection->removePluginProxy(this);
+}
+
+void PluginProxy::paint(GraphicsContext& graphicsContext, const IntRect& dirtyRect)
+{
+ if (!needsBackingStore() || !m_backingStore)
+ return;
+
+ if (!m_pluginBackingStoreContainsValidData) {
+ m_connection->connection()->sendSync(Messages::PluginControllerProxy::PaintEntirePlugin(), Messages::PluginControllerProxy::PaintEntirePlugin::Reply(), m_pluginInstanceID);
+
+ // Blit the plug-in backing store into our own backing store.
+ auto graphicsContext = m_backingStore->createGraphicsContext();
+ if (graphicsContext) {
+ graphicsContext->applyDeviceScaleFactor(contentsScaleFactor());
+ graphicsContext->setCompositeOperation(CompositeOperator::Copy);
+
+ m_pluginBackingStore->paint(*graphicsContext, contentsScaleFactor(), IntPoint(), pluginBounds());
+
+ m_pluginBackingStoreContainsValidData = true;
+ }
+ }
+
+ m_backingStore->paint(graphicsContext, contentsScaleFactor(), dirtyRect.location(), dirtyRect);
+
+ if (m_waitingForPaintInResponseToUpdate) {
+ m_waitingForPaintInResponseToUpdate = false;
+ m_connection->connection()->send(Messages::PluginControllerProxy::DidUpdate(), m_pluginInstanceID);
+ }
+}
+
+bool PluginProxy::supportsSnapshotting() const
+{
+ if (m_waitingOnAsynchronousInitialization)
+ return false;
+
+ bool isSupported = false;
+ if (m_connection && !m_connection->connection()->sendSync(Messages::PluginControllerProxy::SupportsSnapshotting(), Messages::PluginControllerProxy::SupportsSnapshotting::Reply(isSupported), m_pluginInstanceID))
+ return false;
+
+ return isSupported;
+}
+
+RefPtr<ShareableBitmap> PluginProxy::snapshot()
+{
+ ShareableBitmap::Handle snapshotStoreHandle;
+ m_connection->connection()->sendSync(Messages::PluginControllerProxy::Snapshot(), Messages::PluginControllerProxy::Snapshot::Reply(snapshotStoreHandle), m_pluginInstanceID);
+
+ if (snapshotStoreHandle.isNull())
+ return nullptr;
+
+ return ShareableBitmap::create(snapshotStoreHandle);
+}
+
+bool PluginProxy::isTransparent()
+{
+ // This should never be called from the web process.
+ ASSERT_NOT_REACHED();
+ return false;
+}
+
+bool PluginProxy::wantsWheelEvents()
+{
+ return m_wantsWheelEvents;
+}
+
+void PluginProxy::geometryDidChange()
+{
+ ASSERT(m_isStarted);
+
+ ShareableBitmap::Handle pluginBackingStoreHandle;
+
+ if (updateBackingStore()) {
+ // Create a new plug-in backing store.
+ m_pluginBackingStore = ShareableBitmap::createShareable(m_backingStore->size(), { });
+ if (!m_pluginBackingStore)
+ return;
+
+ // Create a handle to the plug-in backing store so we can send it over.
+ if (!m_pluginBackingStore->createHandle(pluginBackingStoreHandle)) {
+ m_pluginBackingStore = nullptr;
+ return;
+ }
+
+ m_pluginBackingStoreContainsValidData = false;
+ }
+
+ m_connection->connection()->send(Messages::PluginControllerProxy::GeometryDidChange(m_pluginSize, m_clipRect, m_pluginToRootViewTransform, contentsScaleFactor(), pluginBackingStoreHandle), m_pluginInstanceID, IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
+}
+
+void PluginProxy::geometryDidChange(const IntSize& pluginSize, const IntRect& clipRect, const AffineTransform& pluginToRootViewTransform)
+{
+ if (pluginSize == m_pluginSize && m_clipRect == clipRect && m_pluginToRootViewTransform == pluginToRootViewTransform) {
+ // Nothing to do.
+ return;
+ }
+
+ m_pluginSize = pluginSize;
+ m_clipRect = clipRect;
+ m_pluginToRootViewTransform = pluginToRootViewTransform;
+
+ geometryDidChange();
+}
+
+void PluginProxy::visibilityDidChange(bool isVisible)
+{
+ ASSERT(m_isStarted);
+ m_connection->connection()->send(Messages::PluginControllerProxy::VisibilityDidChange(isVisible), m_pluginInstanceID);
+}
+
+void PluginProxy::frameDidFinishLoading(uint64_t requestID)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::FrameDidFinishLoading(requestID), m_pluginInstanceID);
+}
+
+void PluginProxy::frameDidFail(uint64_t requestID, bool wasCancelled)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::FrameDidFail(requestID, wasCancelled), m_pluginInstanceID);
+}
+
+void PluginProxy::didEvaluateJavaScript(uint64_t requestID, const WTF::String& result)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::DidEvaluateJavaScript(requestID, result), m_pluginInstanceID);
+}
+
+void PluginProxy::streamWillSendRequest(uint64_t streamID, const URL& requestURL, const URL& responseURL, int responseStatus)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::StreamWillSendRequest(streamID, requestURL.string(), responseURL.string(), responseStatus), m_pluginInstanceID);
+}
+
+void PluginProxy::streamDidReceiveResponse(uint64_t streamID, const URL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime, const WTF::String& mimeType, const WTF::String& headers, const String& /* suggestedFileName */)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::StreamDidReceiveResponse(streamID, responseURL.string(), streamLength, lastModifiedTime, mimeType, headers), m_pluginInstanceID);
+}
+
+void PluginProxy::streamDidReceiveData(uint64_t streamID, const WebCore::SharedBuffer& buffer)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::StreamDidReceiveData(streamID, IPC::DataReference(buffer.data(), buffer.size())), m_pluginInstanceID);
+}
+
+void PluginProxy::streamDidFinishLoading(uint64_t streamID)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::StreamDidFinishLoading(streamID), m_pluginInstanceID);
+}
+
+void PluginProxy::streamDidFail(uint64_t streamID, bool wasCancelled)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::StreamDidFail(streamID, wasCancelled), m_pluginInstanceID);
+}
+
+void PluginProxy::manualStreamDidReceiveResponse(const URL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime, const WTF::String& mimeType, const WTF::String& headers, const String& /* suggestedFileName */)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::ManualStreamDidReceiveResponse(responseURL.string(), streamLength, lastModifiedTime, mimeType, headers), m_pluginInstanceID);
+}
+
+void PluginProxy::manualStreamDidReceiveData(const SharedBuffer& buffer)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::ManualStreamDidReceiveData(IPC::DataReference(buffer.data(), buffer.size())), m_pluginInstanceID);
+}
+
+void PluginProxy::manualStreamDidFinishLoading()
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::ManualStreamDidFinishLoading(), m_pluginInstanceID);
+}
+
+void PluginProxy::manualStreamDidFail(bool wasCancelled)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::ManualStreamDidFail(wasCancelled), m_pluginInstanceID);
+}
+
+bool PluginProxy::handleMouseEvent(const WebMouseEvent& mouseEvent)
+{
+ if (m_waitingOnAsynchronousInitialization)
+ return false;
+
+ m_connection->connection()->send(Messages::PluginControllerProxy::HandleMouseEvent(mouseEvent), m_pluginInstanceID);
+ return true;
+}
+
+bool PluginProxy::handleWheelEvent(const WebWheelEvent& wheelEvent)
+{
+ if (m_waitingOnAsynchronousInitialization)
+ return false;
+
+ bool handled = false;
+ if (!m_connection->connection()->sendSync(Messages::PluginControllerProxy::HandleWheelEvent(wheelEvent), Messages::PluginControllerProxy::HandleWheelEvent::Reply(handled), m_pluginInstanceID))
+ return false;
+
+ return handled;
+}
+
+bool PluginProxy::handleMouseEnterEvent(const WebMouseEvent& mouseEnterEvent)
+{
+ if (m_waitingOnAsynchronousInitialization)
+ return false;
+
+ bool handled = false;
+ if (!m_connection->connection()->sendSync(Messages::PluginControllerProxy::HandleMouseEnterEvent(mouseEnterEvent), Messages::PluginControllerProxy::HandleMouseEnterEvent::Reply(handled), m_pluginInstanceID))
+ return false;
+
+ return handled;
+}
+
+bool PluginProxy::handleMouseLeaveEvent(const WebMouseEvent& mouseLeaveEvent)
+{
+ if (m_waitingOnAsynchronousInitialization)
+ return false;
+
+ bool handled = false;
+ if (!m_connection->connection()->sendSync(Messages::PluginControllerProxy::HandleMouseLeaveEvent(mouseLeaveEvent), Messages::PluginControllerProxy::HandleMouseLeaveEvent::Reply(handled), m_pluginInstanceID))
+ return false;
+
+ return handled;
+}
+
+bool PluginProxy::handleContextMenuEvent(const WebMouseEvent&)
+{
+ // We don't know if the plug-in has handled mousedown event by displaying a context menu, so we never want WebKit to show a default one.
+ return true;
+}
+
+bool PluginProxy::handleKeyboardEvent(const WebKeyboardEvent& keyboardEvent)
+{
+ if (m_waitingOnAsynchronousInitialization)
+ return false;
+
+ bool handled = false;
+ if (!m_connection->connection()->sendSync(Messages::PluginControllerProxy::HandleKeyboardEvent(keyboardEvent), Messages::PluginControllerProxy::HandleKeyboardEvent::Reply(handled), m_pluginInstanceID))
+ return false;
+
+ return handled;
+}
+
+void PluginProxy::setFocus(bool hasFocus)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::SetFocus(hasFocus), m_pluginInstanceID);
+}
+
+bool PluginProxy::handleEditingCommand(const String& commandName, const String& argument)
+{
+ if (m_waitingOnAsynchronousInitialization)
+ return false;
+
+ bool handled = false;
+ if (!m_connection->connection()->sendSync(Messages::PluginControllerProxy::HandleEditingCommand(commandName, argument), Messages::PluginControllerProxy::HandleEditingCommand::Reply(handled), m_pluginInstanceID))
+ return false;
+
+ return handled;
+}
+
+bool PluginProxy::isEditingCommandEnabled(const String& commandName)
+{
+ if (m_waitingOnAsynchronousInitialization)
+ return false;
+
+ bool enabled = false;
+ if (!m_connection->connection()->sendSync(Messages::PluginControllerProxy::IsEditingCommandEnabled(commandName), Messages::PluginControllerProxy::IsEditingCommandEnabled::Reply(enabled), m_pluginInstanceID))
+ return false;
+
+ return enabled;
+}
+
+bool PluginProxy::handlesPageScaleFactor() const
+{
+ if (m_waitingOnAsynchronousInitialization)
+ return false;
+
+ bool handled = false;
+ if (!m_connection->connection()->sendSync(Messages::PluginControllerProxy::HandlesPageScaleFactor(), Messages::PluginControllerProxy::HandlesPageScaleFactor::Reply(handled), m_pluginInstanceID))
+ return false;
+
+ return handled;
+}
+
+bool PluginProxy::requiresUnifiedScaleFactor() const
+{
+ if (m_waitingOnAsynchronousInitialization)
+ return false;
+
+ bool required = false;
+ if (!m_connection->connection()->sendSync(Messages::PluginControllerProxy::RequiresUnifiedScaleFactor(), Messages::PluginControllerProxy::RequiresUnifiedScaleFactor::Reply(required), m_pluginInstanceID))
+ return false;
+
+ return required;
+}
+
+NPObject* PluginProxy::pluginScriptableNPObject()
+{
+ // Sending the synchronous Messages::PluginControllerProxy::GetPluginScriptableNPObject message can cause us to dispatch an
+ // incoming synchronous message that ends up destroying the PluginProxy object.
+ PluginController::PluginDestructionProtector protector(controller());
+
+ uint64_t pluginScriptableNPObjectID = 0;
+
+ if (!m_connection->connection()->sendSync(Messages::PluginControllerProxy::GetPluginScriptableNPObject(), Messages::PluginControllerProxy::GetPluginScriptableNPObject::Reply(pluginScriptableNPObjectID), m_pluginInstanceID))
+ return 0;
+
+ if (!pluginScriptableNPObjectID)
+ return 0;
+
+ return m_connection->npRemoteObjectMap()->createNPObjectProxy(pluginScriptableNPObjectID, this);
+}
+
+void PluginProxy::windowFocusChanged(bool hasFocus)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::WindowFocusChanged(hasFocus), m_pluginInstanceID);
+}
+
+void PluginProxy::windowVisibilityChanged(bool isVisible)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::WindowVisibilityChanged(isVisible), m_pluginInstanceID);
+}
+
+#if PLATFORM(COCOA)
+void PluginProxy::windowAndViewFramesChanged(const WebCore::IntRect& windowFrameInScreenCoordinates, const WebCore::IntRect& viewFrameInWindowCoordinates)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::WindowAndViewFramesChanged(windowFrameInScreenCoordinates, viewFrameInWindowCoordinates), m_pluginInstanceID);
+}
+uint64_t PluginProxy::pluginComplexTextInputIdentifier() const
+{
+ return m_pluginInstanceID;
+}
+
+void PluginProxy::sendComplexTextInput(const String& textInput)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::SendComplexTextInput(textInput), m_pluginInstanceID);
+}
+#endif
+
+void PluginProxy::contentsScaleFactorChanged(float)
+{
+ geometryDidChange();
+}
+
+void PluginProxy::storageBlockingStateChanged(bool isStorageBlockingEnabled)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::StorageBlockingStateChanged(isStorageBlockingEnabled), m_pluginInstanceID);
+}
+
+void PluginProxy::privateBrowsingStateChanged(bool isPrivateBrowsingEnabled)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::PrivateBrowsingStateChanged(isPrivateBrowsingEnabled), m_pluginInstanceID);
+}
+
+void PluginProxy::mutedStateChanged(bool isMuted)
+{
+ m_connection->connection()->send(Messages::PluginControllerProxy::MutedStateChanged(isMuted), m_pluginInstanceID);
+}
+
+bool PluginProxy::getFormValue(String& formValue)
+{
+ bool returnValue;
+ if (!m_connection->connection()->sendSync(Messages::PluginControllerProxy::GetFormValue(), Messages::PluginControllerProxy::GetFormValue::Reply(returnValue, formValue), m_pluginInstanceID))
+ return false;
+
+ return returnValue;
+}
+
+bool PluginProxy::handleScroll(ScrollDirection, ScrollGranularity)
+{
+ return false;
+}
+
+Scrollbar* PluginProxy::horizontalScrollbar()
+{
+ return 0;
+}
+
+Scrollbar* PluginProxy::verticalScrollbar()
+{
+ return 0;
+}
+
+void PluginProxy::loadURL(uint64_t requestID, const String& method, const String& urlString, const String& target, const HTTPHeaderMap& headerFields, const Vector<uint8_t>& httpBody, bool allowPopups)
+{
+ controller()->loadURL(requestID, method, urlString, target, headerFields, httpBody, allowPopups);
+}
+
+void PluginProxy::proxiesForURL(const String& urlString, CompletionHandler<void(String)>&& completionHandler)
+{
+ completionHandler(controller()->proxiesForURL(urlString));
+}
+
+void PluginProxy::cookiesForURL(const String& urlString, CompletionHandler<void(String)>&& completionHandler)
+{
+ completionHandler(controller()->cookiesForURL(urlString));
+}
+
+void PluginProxy::setCookiesForURL(const String& urlString, const String& cookieString)
+{
+ controller()->setCookiesForURL(urlString, cookieString);
+}
+
+void PluginProxy::getAuthenticationInfo(const ProtectionSpace& protectionSpace, CompletionHandler<void(bool returnValue, String username, String password)>&& completionHandler)
+{
+ String username;
+ String password;
+ bool returnValue = controller()->getAuthenticationInfo(protectionSpace, username, password);
+ completionHandler(returnValue, username, password);
+}
+
+float PluginProxy::contentsScaleFactor()
+{
+ return controller()->contentsScaleFactor();
+}
+
+bool PluginProxy::updateBackingStore()
+{
+ if (m_pluginSize.isEmpty() || !needsBackingStore())
+ return false;
+
+ IntSize backingStoreSize = m_pluginSize;
+ backingStoreSize.scale(contentsScaleFactor());
+
+ if (m_backingStore) {
+ if (m_backingStore->size() == backingStoreSize)
+ return false;
+ m_backingStore = nullptr; // Give malloc a chance to recycle our backing store.
+ }
+
+ m_backingStore = ShareableBitmap::create(backingStoreSize, { });
+ return !!m_backingStore;
+}
+
+uint64_t PluginProxy::windowNPObjectID()
+{
+ NPObject* windowScriptNPObject = controller()->windowScriptNPObject();
+ if (!windowScriptNPObject)
+ return 0;
+
+ uint64_t windowNPObjectID = m_connection->npRemoteObjectMap()->registerNPObject(windowScriptNPObject, this);
+ releaseNPObject(windowScriptNPObject);
+
+ return windowNPObjectID;
+}
+
+IntRect PluginProxy::pluginBounds()
+{
+ return IntRect(IntPoint(), m_pluginSize);
+}
+
+void PluginProxy::getPluginElementNPObject(CompletionHandler<void(uint64_t)>&& completionHandler)
+{
+ NPObject* pluginElementNPObject = controller()->pluginElementNPObject();
+ if (!pluginElementNPObject)
+ return completionHandler(0);
+
+ uint64_t pluginElementNPObjectID = m_connection->npRemoteObjectMap()->registerNPObject(pluginElementNPObject, this);
+ releaseNPObject(pluginElementNPObject);
+ completionHandler(pluginElementNPObjectID);
+}
+
+void PluginProxy::evaluate(const NPVariantData& npObjectAsVariantData, const String& scriptString, bool allowPopups, CompletionHandler<void(bool returnValue, NPVariantData&& resultData)>&& completionHandler)
+{
+ PluginController::PluginDestructionProtector protector(controller());
+
+ NPVariant npObjectAsVariant = m_connection->npRemoteObjectMap()->npVariantDataToNPVariant(npObjectAsVariantData, this);
+ if (!NPVARIANT_IS_OBJECT(npObjectAsVariant) || !(NPVARIANT_TO_OBJECT(npObjectAsVariant)))
+ return completionHandler(false, { });
+
+ NPVariant result;
+ bool returnValue = controller()->evaluate(NPVARIANT_TO_OBJECT(npObjectAsVariant), scriptString, &result, allowPopups);
+ if (!returnValue)
+ return completionHandler(false, { });
+
+ // Convert the NPVariant to an NPVariantData.
+ NPVariantData resultData = m_connection->npRemoteObjectMap()->npVariantToNPVariantData(result, this);
+
+ // And release the result.
+ releaseNPVariantValue(&result);
+ releaseNPVariantValue(&npObjectAsVariant);
+
+ completionHandler(returnValue, WTFMove(resultData));
+}
+
+void PluginProxy::setPluginIsPlayingAudio(bool pluginIsPlayingAudio)
+{
+ controller()->setPluginIsPlayingAudio(pluginIsPlayingAudio);
+}
+
+void PluginProxy::continueStreamLoad(uint64_t streamID)
+{
+ controller()->continueStreamLoad(streamID);
+}
+
+void PluginProxy::cancelStreamLoad(uint64_t streamID)
+{
+ controller()->cancelStreamLoad(streamID);
+}
+
+void PluginProxy::cancelManualStreamLoad()
+{
+ controller()->cancelManualStreamLoad();
+}
+
+void PluginProxy::setStatusbarText(const String& statusbarText)
+{
+ controller()->setStatusbarText(statusbarText);
+}
+
+#if PLATFORM(X11)
+void PluginProxy::createPluginContainer(CompletionHandler<void(uint64_t windowID)>&& completionHandler)
+{
+ completionHandler(controller()->createPluginContainer());
+}
+
+void PluginProxy::windowedPluginGeometryDidChange(const WebCore::IntRect& frameRect, const WebCore::IntRect& clipRect, uint64_t windowID)
+{
+ controller()->windowedPluginGeometryDidChange(frameRect, clipRect, windowID);
+}
+
+void PluginProxy::windowedPluginVisibilityDidChange(bool isVisible, uint64_t windowID)
+{
+ controller()->windowedPluginVisibilityDidChange(isVisible, windowID);
+}
+#endif
+
+void PluginProxy::update(const IntRect& paintedRect)
+{
+ if (paintedRect == pluginBounds())
+ m_pluginBackingStoreContainsValidData = true;
+
+ if (m_backingStore) {
+ // Blit the plug-in backing store into our own backing store.
+ auto graphicsContext = m_backingStore->createGraphicsContext();
+ if (graphicsContext) {
+ graphicsContext->applyDeviceScaleFactor(contentsScaleFactor());
+ graphicsContext->setCompositeOperation(CompositeOperator::Copy);
+ m_pluginBackingStore->paint(*graphicsContext, contentsScaleFactor(), paintedRect.location(), paintedRect);
+ }
+ }
+
+ // Ask the controller to invalidate the rect for us.
+ m_waitingForPaintInResponseToUpdate = true;
+ controller()->invalidate(paintedRect);
+}
+
+IntPoint PluginProxy::convertToRootView(const IntPoint& point) const
+{
+ return m_pluginToRootViewTransform.mapPoint(point);
+}
+
+RefPtr<WebCore::FragmentedSharedBuffer> PluginProxy::liveResourceData() const
+{
+ return nullptr;
+}
+
+} // namespace WebKit
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginProxy.h webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginProxy.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginProxy.h 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginProxy.h 2022-08-26 14:18:15.013022503 -0500
@@ -0,0 +1,234 @@
+/*
+ * Copyright (C) 2010, 2015 Apple 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 INC. 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 INC. 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.
+ */
+
+#pragma once
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+#include "Connection.h"
+#include "Plugin.h"
+#include "PluginProcess.h"
+#include <WebCore/AffineTransform.h>
+#include <WebCore/IntRect.h>
+#include <WebCore/SecurityOrigin.h>
+#include <memory>
+
+#if PLATFORM(COCOA)
+#include <wtf/RetainPtr.h>
+OBJC_CLASS CALayer;
+#endif
+
+namespace WebCore {
+ class HTTPHeaderMap;
+ class ProtectionSpace;
+}
+
+namespace WebKit {
+
+class ShareableBitmap;
+class NPVariantData;
+class PluginProcessConnection;
+
+struct PluginCreationParameters;
+
+class PluginProxy : public Plugin {
+public:
+ static Ref<PluginProxy> create(uint64_t pluginProcessToken);
+ ~PluginProxy();
+
+ uint64_t pluginInstanceID() const { return m_pluginInstanceID; }
+ void pluginProcessCrashed();
+
+ void didReceivePluginProxyMessage(IPC::Connection&, IPC::Decoder&);
+ bool didReceiveSyncPluginProxyMessage(IPC::Connection&, IPC::Decoder&, UniqueRef<IPC::Encoder>&);
+
+private:
+ explicit PluginProxy(uint64_t pluginProcessToken);
+
+ // Plugin
+ bool initialize(const Parameters&) override;
+ bool initializeSynchronously();
+
+ void destroy() override;
+ void paint(WebCore::GraphicsContext&, const WebCore::IntRect& dirtyRect) override;
+ bool supportsSnapshotting() const override;
+ RefPtr<ShareableBitmap> snapshot() override;
+#if PLATFORM(COCOA)
+ PlatformLayer* pluginLayer() override;
+#endif
+ bool isTransparent() override;
+ bool wantsWheelEvents() override;
+ void geometryDidChange(const WebCore::IntSize& pluginSize, const WebCore::IntRect& clipRect, const WebCore::AffineTransform& pluginToRootViewTransform) override;
+ void visibilityDidChange(bool isVisible) override;
+ void frameDidFinishLoading(uint64_t requestID) override;
+ void frameDidFail(uint64_t requestID, bool wasCancelled) override;
+ void didEvaluateJavaScript(uint64_t requestID, const String& result) override;
+ void streamWillSendRequest(uint64_t streamID, const URL& requestURL, const URL& responseURL, int responseStatus) override;
+ void streamDidReceiveResponse(uint64_t streamID, const URL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime, const String& mimeType, const String& headers, const String& suggestedFileName) override;
+ void streamDidReceiveData(uint64_t streamID, const WebCore::SharedBuffer& buffer) override;
+ void streamDidFinishLoading(uint64_t streamID) override;
+ void streamDidFail(uint64_t streamID, bool wasCancelled) override;
+ void manualStreamDidReceiveResponse(const URL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime, const WTF::String& mimeType, const WTF::String& headers, const String& suggestedFileName) override;
+ void manualStreamDidReceiveData(const WebCore::SharedBuffer& buffer) override;
+ void manualStreamDidFinishLoading() override;
+ void manualStreamDidFail(bool wasCancelled) override;
+
+ bool handleMouseEvent(const WebMouseEvent&) override;
+ bool handleWheelEvent(const WebWheelEvent&) override;
+ bool handleMouseEnterEvent(const WebMouseEvent&) override;
+ bool handleMouseLeaveEvent(const WebMouseEvent&) override;
+ bool handleContextMenuEvent(const WebMouseEvent&) override;
+ bool handleKeyboardEvent(const WebKeyboardEvent&) override;
+ void setFocus(bool) override;
+ bool handleEditingCommand(const String& commandName, const String& argument) override;
+ bool isEditingCommandEnabled(const String& commandName) override;
+ bool shouldAllowScripting() override { return true; }
+ bool shouldAllowNavigationFromDrags() override { return false; }
+
+ bool handlesPageScaleFactor() const override;
+ bool requiresUnifiedScaleFactor() const override;
+
+ NPObject* pluginScriptableNPObject() override;
+
+ void windowFocusChanged(bool) override;
+ void windowVisibilityChanged(bool) override;
+
+#if PLATFORM(COCOA)
+ void windowAndViewFramesChanged(const WebCore::IntRect& windowFrameInScreenCoordinates, const WebCore::IntRect& viewFrameInWindowCoordinates) override;
+ uint64_t pluginComplexTextInputIdentifier() const override;
+ void sendComplexTextInput(const String& textInput) override;
+ void setLayerHostingMode(LayerHostingMode) override;
+#endif
+
+ void contentsScaleFactorChanged(float) override;
+ void storageBlockingStateChanged(bool) override;
+ void privateBrowsingStateChanged(bool) override;
+ void mutedStateChanged(bool) override;
+ bool getFormValue(String& formValue) override;
+ bool handleScroll(WebCore::ScrollDirection, WebCore::ScrollGranularity) override;
+ WebCore::Scrollbar* horizontalScrollbar() override;
+ WebCore::Scrollbar* verticalScrollbar() override;
+
+ unsigned countFindMatches(const String&, WebCore::FindOptions, unsigned) override { return 0; }
+ bool findString(const String&, WebCore::FindOptions, unsigned) override { return false; }
+
+ WebCore::IntPoint convertToRootView(const WebCore::IntPoint&) const override;
+
+ RefPtr<WebCore::FragmentedSharedBuffer> liveResourceData() const override;
+ bool performDictionaryLookupAtLocation(const WebCore::FloatPoint&) override { return false; }
+
+ String getSelectionString() const override { return String(); }
+ String getSelectionForWordAtPoint(const WebCore::FloatPoint&) const override { return String(); }
+ bool existingSelectionContainsPoint(const WebCore::FloatPoint&) const override { return false; }
+
+ float contentsScaleFactor();
+ bool needsBackingStore() const;
+ bool updateBackingStore();
+ uint64_t windowNPObjectID();
+ WebCore::IntRect pluginBounds();
+
+ void geometryDidChange();
+
+ // Message handlers.
+ void loadURL(uint64_t requestID, const String& method, const String& urlString, const String& target, const WebCore::HTTPHeaderMap& headerFields, const Vector<uint8_t>& httpBody, bool allowPopups);
+ void update(const WebCore::IntRect& paintedRect);
+ void proxiesForURL(const String& urlString, CompletionHandler<void(String)>&&);
+ void cookiesForURL(const String& urlString, CompletionHandler<void(String)>&&);
+ void setCookiesForURL(const String& urlString, const String& cookieString);
+ void getAuthenticationInfo(const WebCore::ProtectionSpace&, CompletionHandler<void(bool returnValue, String username, String password)>&&);
+ void getPluginElementNPObject(CompletionHandler<void(uint64_t)>&&);
+ void evaluate(const NPVariantData& npObjectAsVariantData, const String& scriptString, bool allowPopups, CompletionHandler<void(bool returnValue, NPVariantData&& resultData)>&&);
+ void setPluginIsPlayingAudio(bool);
+ void continueStreamLoad(uint64_t streamID);
+ void cancelStreamLoad(uint64_t streamID);
+ void cancelManualStreamLoad();
+ void setStatusbarText(const String& statusbarText);
+#if PLATFORM(COCOA)
+ void pluginFocusOrWindowFocusChanged(bool);
+ void setComplexTextInputState(uint64_t);
+ void setLayerHostingContextID(uint32_t);
+#endif
+#if PLATFORM(X11)
+ void createPluginContainer(CompletionHandler<void(uint64_t windowID)>&&);
+ void windowedPluginGeometryDidChange(const WebCore::IntRect& frameRect, const WebCore::IntRect& clipRect, uint64_t windowID);
+ void windowedPluginVisibilityDidChange(bool isVisible, uint64_t windowID);
+#endif
+
+ bool canInitializeAsynchronously() const;
+
+ void didCreatePlugin(bool wantsWheelEvents, uint32_t remoteLayerClientID, CompletionHandler<void()>&&);
+ void didFailToCreatePlugin(CompletionHandler<void()>&&);
+
+ void didCreatePluginInternal(bool wantsWheelEvents, uint32_t remoteLayerClientID);
+ void didFailToCreatePluginInternal();
+
+ uint64_t m_pluginProcessToken { 0 };
+
+ RefPtr<PluginProcessConnection> m_connection;
+ uint64_t m_pluginInstanceID { 0 };
+
+ WebCore::IntSize m_pluginSize;
+
+ // The clip rect in plug-in coordinates.
+ WebCore::IntRect m_clipRect;
+
+ // A transform that can be used to convert from root view coordinates to plug-in coordinates.
+ WebCore::AffineTransform m_pluginToRootViewTransform;
+
+ // This is the backing store that we paint when we're told to paint.
+ RefPtr<ShareableBitmap> m_backingStore;
+
+ // This is the shared memory backing store that the plug-in paints into. When the plug-in tells us
+ // that it's painted something in it, we'll blit from it to our own backing store.
+ RefPtr<ShareableBitmap> m_pluginBackingStore;
+
+ // Whether all of the plug-in backing store contains valid data.
+ bool m_pluginBackingStoreContainsValidData { false };
+
+ bool m_isStarted { false };
+
+ // Whether we're called invalidate in response to an update call, and are now waiting for a paint call.
+ bool m_waitingForPaintInResponseToUpdate { false };
+
+ // Whether we should send wheel events to this plug-in or not.
+ bool m_wantsWheelEvents { false };
+
+ // The client ID for the CA layer in the plug-in process. Will be 0 if the plug-in is not a CA plug-in.
+ uint32_t m_remoteLayerClientID { 0 };
+
+ std::unique_ptr<PluginCreationParameters> m_pendingPluginCreationParameters;
+ bool m_waitingOnAsynchronousInitialization { false };
+
+#if PLATFORM(COCOA)
+ RetainPtr<CALayer> m_pluginLayer;
+#endif
+};
+
+} // namespace WebKit
+
+SPECIALIZE_TYPE_TRAITS_PLUGIN(PluginProxy, isPluginProxy())
+
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginProxy.messages.in webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginProxy.messages.in
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginProxy.messages.in 1969-12-31 18:00:00.000000000 -0600
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginProxy.messages.in 2022-08-26 14:18:15.013022503 -0500
@@ -0,0 +1,94 @@
+# Copyright (C) 2010 Apple 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 INC. 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 INC. 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.
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+
+messages -> PluginProxy LegacyReceiver {
+ # Asks the web process to load a URL.
+ LoadURL(uint64_t requestID, String method, String urlString, String target, WebCore::HTTPHeaderMap headerFields, Vector<uint8_t> httpBody, bool allowPopups);
+
+ # Called when the plug-in has painted into its backing store. The painted rect is in plug-in coordinates.
+ Update(WebCore::IntRect paintedRect)
+
+ # Returns a PAC style string with proxies for the given URL.
+ ProxiesForURL(String urlString) -> (String proxiesString) Synchronous
+
+ # Returns the cookies for the given URL.
+ CookiesForURL(String urlString) -> (String cookieString) Synchronous
+
+ # Sets the cookies for the given URL.
+ SetCookiesForURL(String urlString, String cookieString)
+
+ # Gets the authentication info for the given protection space.
+ GetAuthenticationInfo(WebCore::ProtectionSpace protectionSpace) -> (bool returnValue, String username, String password) Synchronous
+
+ # Gets a reference to the plug-in element NPObject.
+ GetPluginElementNPObject() -> (uint64_t pluginElementNPObjectID) Synchronous
+
+ # Evaluates the given JavaScript string.
+ Evaluate(WebKit::NPVariantData npObjectAsVariantData, String scriptString, bool allowPopups) -> (bool returnValue, WebKit::NPVariantData resultData) Synchronous
+
+ # Cancels the given stream load.
+ CancelStreamLoad(uint64_t streamID)
+
+ # Continues the given stream load.
+ ContinueStreamLoad(uint64_t streamID)
+
+ # Cancel the manual stream load.
+ CancelManualStreamLoad()
+
+ # Set the status bar text.
+ SetStatusbarText(String statusbarText)
+
+#if PLATFORM(COCOA)
+ # Called when the plug-in's focus or its containing window focus changes.
+ PluginFocusOrWindowFocusChanged(bool pluginHasFocusAndWindowHasFocus)
+
+ # Change whether complex text input is enabled for this plug-in.
+ SetComplexTextInputState(uint64_t complexTextInputState)
+
+ # Update the layer hosting context ID. Called whenever the layer hosting state changes.
+ SetLayerHostingContextID(uint32_t layerHostingContextID)
+#endif
+
+#if PLATFORM(X11)
+ # Create the plugin container for windowed plugins
+ CreatePluginContainer() -> (uint64_t windowID) Synchronous
+
+ # Update geometry of windowed plugin widget
+ WindowedPluginGeometryDidChange(WebCore::IntRect frameRect, WebCore::IntRect clipRect, uint64_t windowID)
+
+ # Update visibility of windowed plugin widget
+ WindowedPluginVisibilityDidChange(bool isVisible, uint64_t windowID)
+#endif
+
+ # Tells the WebProcess that the plug-in was successfully initialized asynchronously
+ DidCreatePlugin(bool wantsWheelEvents, uint32_t remoteLayerClientID) -> () Synchronous
+
+ # Tells the WebProcess that the plug-in failed to initialize.
+ DidFailToCreatePlugin() -> () Synchronous
+
+ # Tells the WebProcess that the plug-in has started or stopped playing audio.
+ SetPluginIsPlayingAudio(bool pluginIsPlayingAudio)
+}
+
+#endif
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginView.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginView.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginView.cpp 2022-06-30 04:49:38.069512400 -0500
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginView.cpp 2022-08-26 14:18:15.013022503 -0500
@@ -26,6 +26,7 @@
#include "config.h"
#include "PluginView.h"
+#include "NPRuntimeUtilities.h"
#include "Plugin.h"
#include "ShareableBitmap.h"
#include "WebCoreArgumentCoders.h"
@@ -61,6 +62,7 @@
#include <WebCore/PageInlines.h>
#include <WebCore/PlatformMouseEvent.h>
#include <WebCore/ProtectionSpace.h>
+#include <WebCore/ProxyServer.h>
#include <WebCore/RenderEmbeddedObject.h>
#include <WebCore/ScriptController.h>
#include <WebCore/ScrollView.h>
@@ -72,6 +74,10 @@
#include <wtf/CompletionHandler.h>
#include <wtf/text/StringBuilder.h>
+#if PLATFORM(X11) && ENABLE(NETSCAPE_PLUGIN_API)
+#include <WebCore/PlatformDisplay.h>
+#endif
+
namespace WebKit {
using namespace JSC;
using namespace WebCore;
@@ -258,6 +264,10 @@ void PluginView::Stream::didFinishLoadin
// Calling streamDidFinishLoading could cause us to be deleted, so we hold on to a reference here.
Ref<Stream> protect(*this);
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ // Protect the plug-in while we're calling into it.
+ NPRuntimeObjectMap::PluginProtector pluginProtector(&m_pluginView->m_npRuntimeObjectMap);
+#endif
m_pluginView->m_plugin->streamDidFinishLoading(m_streamID);
m_pluginView->removeStream(this);
@@ -322,11 +332,36 @@ void PluginView::destroyPluginAndReset()
m_pendingURLRequests.clear();
m_pendingURLRequestsTimer.stop();
+
+#if PLATFORM(COCOA)
+ if (m_webPage)
+ pluginFocusOrWindowFocusChanged(false);
+#endif
}
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ // Invalidate the object map.
+ m_npRuntimeObjectMap.invalidate();
+#endif
+
cancelAllStreams();
}
+void PluginView::recreateAndInitialize(Ref<Plugin>&& plugin)
+{
+ if (m_plugin)
+ destroyPluginAndReset();
+
+ m_plugin = WTFMove(plugin);
+ m_isInitialized = false;
+ m_isWaitingForSynchronousInitialization = false;
+ m_isWaitingUntilMediaCanStart = false;
+ m_manualStreamState = ManualStreamState::Initial;
+ m_transientPaintingSnapshot = nullptr;
+
+ initializePlugin();
+}
+
void PluginView::setLayerHostingMode(LayerHostingMode layerHostingMode)
{
#if HAVE(OUT_OF_PROCESS_LAYER_HOSTING)
@@ -492,6 +527,18 @@ void PluginView::windowAndViewFramesChan
m_plugin->windowAndViewFramesChanged(enclosingIntRect(windowFrameInScreenCoordinates), enclosingIntRect(viewFrameInWindowCoordinates));
}
+bool PluginView::sendComplexTextInput(uint64_t pluginComplexTextInputIdentifier, const String& textInput)
+{
+ if (!m_plugin)
+ return false;
+
+ if (m_plugin->pluginComplexTextInputIdentifier() != pluginComplexTextInputIdentifier)
+ return false;
+
+ m_plugin->sendComplexTextInput(textInput);
+ return true;
+}
+
id PluginView::accessibilityAssociatedPluginParentForElement(Element* element) const
{
if (!m_plugin)
@@ -537,7 +584,18 @@ void PluginView::initializePlugin()
m_plugin->initialize(*this, m_parameters);
- // Plug-in initialization continued in didInitializePlugin().
+ // Plug-in initialization continued in didFailToInitializePlugin() or didInitializePlugin().
+}
+
+void PluginView::didFailToInitializePlugin()
+{
+ m_plugin = nullptr;
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ String frameURLString = frame()->loader().documentLoader()->responseURL().string();
+ String pageURLString = m_webPage->corePage()->mainFrame().loader().documentLoader()->responseURL().string();
+ m_webPage->send(Messages::WebPageProxy::DidFailToInitializePlugin(m_parameters.mimeType, frameURLString, pageURLString));
+#endif
}
void PluginView::didInitializePlugin()
@@ -584,9 +642,9 @@ void PluginView::didInitializePlugin()
PlatformLayer* PluginView::platformLayer() const
{
// The plug-in can be null here if it failed to initialize.
- if (!m_isInitialized || !m_plugin)
+ if (!m_isInitialized || !m_plugin || m_pluginProcessHasCrashed)
return 0;
-
+
return m_plugin->pluginLayer();
}
#endif
@@ -603,8 +661,19 @@ JSObject* PluginView::scriptObject(JSGlo
if (!m_isInitialized || !m_plugin)
return 0;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ NPObject* scriptableNPObject = m_plugin->pluginScriptableNPObject();
+ if (!scriptableNPObject)
+ return 0;
+
+ JSObject* jsObject = m_npRuntimeObjectMap.getOrCreateJSObject(globalObject, scriptableNPObject);
+ releaseNPObject(scriptableNPObject);
+
+ return jsObject;
+#else
UNUSED_PARAM(globalObject);
return 0;
+#endif
}
void PluginView::storageBlockingStateChanged()
@@ -618,6 +687,24 @@ void PluginView::storageBlockingStateCha
m_plugin->storageBlockingStateChanged(storageBlockingPolicy);
}
+void PluginView::privateBrowsingStateChanged(bool privateBrowsingEnabled)
+{
+ // The plug-in can be null here if it failed to initialize.
+ if (!m_isInitialized || !m_plugin)
+ return;
+
+ m_plugin->privateBrowsingStateChanged(privateBrowsingEnabled);
+}
+
+bool PluginView::getFormValue(String& formValue)
+{
+ // The plug-in can be null here if it failed to initialize.
+ if (!m_isInitialized || !m_plugin)
+ return false;
+
+ return m_plugin->getFormValue(formValue);
+}
+
bool PluginView::scroll(ScrollDirection direction, ScrollGranularity granularity)
{
// The plug-in can be null here if it failed to initialize.
@@ -854,6 +941,11 @@ bool PluginView::shouldAllowNavigationFr
return m_plugin->shouldAllowNavigationFromDrags();
}
+bool PluginView::shouldNotAddLayer() const
+{
+ return false;
+}
+
void PluginView::willDetachRenderer()
{
if (!m_isInitialized || !m_plugin)
@@ -882,6 +974,14 @@ bool PluginView::performDictionaryLookup
return m_plugin->performDictionaryLookupAtLocation(point);
}
+String PluginView::getSelectionForWordAtPoint(const WebCore::FloatPoint& point) const
+{
+ if (!m_isInitialized || !m_plugin)
+ return String();
+
+ return m_plugin->getSelectionForWordAtPoint(point);
+}
+
bool PluginView::existingSelectionContainsPoint(const WebCore::FloatPoint& point) const
{
if (!m_isInitialized || !m_plugin)
@@ -1220,6 +1320,27 @@ void PluginView::mediaCanStart(WebCore::
void PluginView::pageMutedStateDidChange()
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ // The plug-in can be null here if it failed to initialize.
+ if (!m_isInitialized || !m_plugin)
+ return;
+
+ m_plugin->mutedStateChanged(isMuted());
+#endif
+}
+
+void PluginView::invalidate(const IntRect& dirtyRect)
+{
+ invalidateRect(dirtyRect);
+}
+
+String PluginView::userAgent()
+{
+ Frame* frame = m_pluginElement->document().frame();
+ if (!frame)
+ return String();
+
+ return frame->loader().client().userAgent(URL());
}
void PluginView::loadURL(uint64_t requestID, const String& method, const String& urlString, const String& target, const HTTPHeaderMap& headerFields, const Vector<uint8_t>& httpBody, bool allowPopups)
@@ -1242,6 +1363,176 @@ void PluginView::loadURL(uint64_t reques
m_pendingURLRequestsTimer.startOneShot(0_s);
}
+void PluginView::cancelStreamLoad(uint64_t streamID)
+{
+ // Keep a reference to the stream. Stream::cancel might remove the stream from the map, and thus
+ // releasing its last reference.
+ RefPtr<Stream> stream = m_streams.get(streamID);
+ if (!stream)
+ return;
+
+ // Cancelling the stream here will remove it from the map.
+ stream->cancel();
+ ASSERT(!m_streams.contains(streamID));
+}
+
+void PluginView::continueStreamLoad(uint64_t streamID)
+{
+ RefPtr<Stream> stream = m_streams.get(streamID);
+ if (!stream)
+ return;
+
+ stream->continueLoad();
+}
+
+void PluginView::cancelManualStreamLoad()
+{
+ if (!frame())
+ return;
+
+ DocumentLoader* documentLoader = frame()->loader().activeDocumentLoader();
+ ASSERT(documentLoader);
+ if (documentLoader && documentLoader->isLoadingMainResource())
+ documentLoader->cancelMainResourceLoad(frame()->loader().cancelledError(m_parameters.url));
+}
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+NPObject* PluginView::windowScriptNPObject()
+{
+ if (!frame())
+ return nullptr;
+
+ if (!frame()->script().canExecuteScripts(NotAboutToExecuteScript)) {
+ // FIXME: Investigate if other browsers allow plug-ins to access JavaScript objects even if JavaScript is disabled.
+ return nullptr;
+ }
+
+ return m_npRuntimeObjectMap.getOrCreateNPObject(pluginWorld().vm(), frame()->windowProxy().jsWindowProxy(pluginWorld())->window());
+}
+
+NPObject* PluginView::pluginElementNPObject()
+{
+ if (!frame())
+ return 0;
+
+ if (!frame()->script().canExecuteScripts(NotAboutToExecuteScript)) {
+ // FIXME: Investigate if other browsers allow plug-ins to access JavaScript objects even if JavaScript is disabled.
+ return 0;
+ }
+
+ JSObject* object = frame()->script().jsObjectForPluginElement(m_pluginElement.get());
+ ASSERT(object);
+
+ return m_npRuntimeObjectMap.getOrCreateNPObject(pluginWorld().vm(), object);
+}
+
+bool PluginView::evaluate(NPObject* npObject, const String& scriptString, NPVariant* result, bool allowPopups)
+{
+ // FIXME: Is this check necessary?
+ if (!m_pluginElement->document().frame())
+ return false;
+
+ // Calling evaluate will run JavaScript that can potentially remove the plug-in element, so we need to
+ // protect the plug-in view from destruction.
+ NPRuntimeObjectMap::PluginProtector pluginProtector(&m_npRuntimeObjectMap);
+
+ UserGestureIndicator gestureIndicator(allowPopups ? std::optional<ProcessingUserGestureState>(ProcessingUserGesture) : std::nullopt);
+ return m_npRuntimeObjectMap.evaluate(npObject, scriptString, result);
+}
+
+void PluginView::setPluginIsPlayingAudio(bool pluginIsPlayingAudio)
+{
+ if (m_pluginIsPlayingAudio == pluginIsPlayingAudio)
+ return;
+
+ m_pluginIsPlayingAudio = pluginIsPlayingAudio;
+ m_pluginElement->document().updateIsPlayingMedia();
+}
+
+bool PluginView::isMuted() const
+{
+ if (!frame() || !frame()->page())
+ return false;
+
+ return frame()->page()->isAudioMuted();
+}
+#endif
+
+void PluginView::setStatusbarText(const String& statusbarText)
+{
+ if (!frame())
+ return;
+
+ Page* page = frame()->page();
+ if (!page)
+ return;
+
+ page->chrome().setStatusbarText(*frame(), statusbarText);
+}
+
+bool PluginView::isAcceleratedCompositingEnabled()
+{
+ if (!frame())
+ return false;
+
+ return frame()->settings().acceleratedCompositingEnabled();
+}
+
+#if PLATFORM(X11) && ENABLE(NETSCAPE_PLUGIN_API)
+uint64_t PluginView::createPluginContainer()
+{
+ uint64_t windowID = 0;
+ if (PlatformDisplay::sharedDisplay().type() == PlatformDisplay::Type::X11)
+ m_webPage->sendSync(Messages::WebPageProxy::CreatePluginContainer(), Messages::WebPageProxy::CreatePluginContainer::Reply(windowID));
+ return windowID;
+}
+
+void PluginView::windowedPluginGeometryDidChange(const WebCore::IntRect& frameRect, const WebCore::IntRect& clipRect, uint64_t windowID)
+{
+ m_webPage->send(Messages::WebPageProxy::WindowedPluginGeometryDidChange(frameRect, clipRect, windowID));
+}
+
+void PluginView::windowedPluginVisibilityDidChange(bool isVisible, uint64_t windowID)
+{
+ m_webPage->send(Messages::WebPageProxy::WindowedPluginVisibilityDidChange(isVisible, windowID));
+}
+#endif
+
+void PluginView::pluginProcessCrashed()
+{
+ m_pluginProcessHasCrashed = true;
+
+ auto* renderer = m_pluginElement->renderer();
+ if (!is<RenderEmbeddedObject>(renderer))
+ return;
+
+ m_pluginElement->invalidateStyleAndLayerComposition();
+
+ downcast<RenderEmbeddedObject>(*renderer).setPluginUnavailabilityReason(RenderEmbeddedObject::PluginCrashed);
+
+ Widget::invalidate();
+}
+
+#if PLATFORM(COCOA)
+void PluginView::pluginFocusOrWindowFocusChanged(bool pluginHasFocusAndWindowHasFocus)
+{
+ if (m_webPage)
+ m_webPage->send(Messages::WebPageProxy::PluginFocusOrWindowFocusChanged(m_plugin->pluginComplexTextInputIdentifier(), pluginHasFocusAndWindowHasFocus));
+}
+
+void PluginView::setComplexTextInputState(PluginComplexTextInputState pluginComplexTextInputState)
+{
+ if (m_webPage)
+ m_webPage->send(Messages::WebPageProxy::SetPluginComplexTextInputState(m_plugin->pluginComplexTextInputIdentifier(), pluginComplexTextInputState));
+}
+
+const MachSendRight& PluginView::compositingRenderServerPort()
+{
+ return WebProcess::singleton().compositingRenderServerPort();
+}
+
+#endif
+
float PluginView::contentsScaleFactor()
{
if (Page* page = frame() ? frame()->page() : 0)
@@ -1249,6 +1540,96 @@ float PluginView::contentsScaleFactor()
return 1;
}
+
+String PluginView::proxiesForURL(const String& urlString)
+{
+ Vector<ProxyServer> proxyServers = proxyServersForURL(URL(URL(), urlString));
+ return toString(proxyServers);
+}
+
+String PluginView::cookiesForURL(const String& urlString)
+{
+ if (auto* page = m_pluginElement->document().page())
+ return page->cookieJar().cookies(m_pluginElement->document(), URL(URL(), urlString));
+ ASSERT_NOT_REACHED();
+ return { };
+}
+
+void PluginView::setCookiesForURL(const String& urlString, const String& cookieString)
+{
+ if (auto* page = m_pluginElement->document().page())
+ page->cookieJar().setCookies(m_pluginElement->document(), URL(URL(), urlString), cookieString);
+ else
+ ASSERT_NOT_REACHED();
+}
+
+bool PluginView::getAuthenticationInfo(const ProtectionSpace& protectionSpace, String& username, String& password)
+{
+ auto* contentDocument = m_pluginElement->contentDocument();
+ if (!contentDocument)
+ return false;
+
+ auto credential = CredentialStorage::getFromPersistentStorage(protectionSpace);
+ if (!credential.hasPassword())
+ return false;
+
+ username = credential.user();
+ password = credential.password();
+
+ return true;
+}
+
+bool PluginView::isPrivateBrowsingEnabled()
+{
+ // If we can't get the real setting, we'll assume that private browsing is enabled.
+ if (!frame())
+ return true;
+
+ if (!frame()->document()->securityOrigin().canAccessPluginStorage(frame()->document()->topOrigin()))
+ return true;
+
+ return frame()->page()->usesEphemeralSession();
+}
+
+bool PluginView::asynchronousPluginInitializationEnabled() const
+{
+ return m_webPage->asynchronousPluginInitializationEnabled();
+}
+
+bool PluginView::asynchronousPluginInitializationEnabledForAllPlugins() const
+{
+ return m_webPage->asynchronousPluginInitializationEnabledForAllPlugins();
+}
+
+bool PluginView::artificialPluginInitializationDelayEnabled() const
+{
+ return m_webPage->artificialPluginInitializationDelayEnabled();
+}
+
+void PluginView::protectPluginFromDestruction()
+{
+ if (m_plugin && !m_plugin->isBeingDestroyed())
+ ref();
+}
+
+void PluginView::unprotectPluginFromDestruction()
+{
+ if (!m_plugin || m_plugin->isBeingDestroyed())
+ return;
+
+ // A plug-in may ask us to evaluate JavaScript that removes the plug-in from the
+ // page, but expect the object to still be alive when the call completes. Flash,
+ // for example, may crash if the plug-in is destroyed and we return to code for
+ // the destroyed object higher on the stack. To prevent this, if the plug-in has
+ // only one remaining reference, call deref() asynchronously.
+ if (hasOneRef()) {
+ RunLoop::main().dispatch([lastRef = adoptRef(*this)] {
+ });
+ return;
+ }
+
+ deref();
+}
void PluginView::didFinishLoad(WebFrame* webFrame)
{
@@ -1284,6 +1665,9 @@ bool PluginView::shouldCreateTransientPa
}
}
+ if (!m_plugin->canCreateTransientPaintingSnapshot())
+ return false;
+
return true;
}
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginView.h webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginView.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/PluginView.h 2022-06-30 04:49:38.069512400 -0500
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/PluginView.h 2022-08-26 14:18:15.013022503 -0500
@@ -26,6 +26,7 @@
#pragma once
#include "LayerTreeContext.h"
+#include "NPRuntimeObjectMap.h"
#include "Plugin.h"
#include "PluginController.h"
#include "WebFrame.h"
@@ -68,6 +69,8 @@ class PluginView : public WebCore::Plugi
public:
static Ref<PluginView> create(WebCore::HTMLPlugInElement&, Ref<Plugin>&&, const Plugin::Parameters&);
+ void recreateAndInitialize(Ref<Plugin>&&);
+
WebCore::Frame* frame() const;
bool isBeingDestroyed() const { return !m_plugin || m_plugin->isBeingDestroyed(); }
@@ -83,6 +86,7 @@ public:
#if PLATFORM(COCOA)
void setDeviceScaleFactor(float);
void windowAndViewFramesChanged(const WebCore::FloatRect& windowFrameInScreenCoordinates, const WebCore::FloatRect& viewFrameInWindowCoordinates);
+ bool sendComplexTextInput(uint64_t pluginComplexTextInputIdentifier, const String& textInput);
RetainPtr<PDFDocument> pdfDocumentForPrinting() const { return m_plugin->pdfDocumentForPrinting(); }
id accessibilityHitTest(const WebCore::IntPoint& point) const override { return m_plugin->accessibilityHitTest(point); }
id accessibilityObject() const override;
@@ -115,6 +119,7 @@ public:
RefPtr<WebCore::FragmentedSharedBuffer> liveResourceData() const;
bool performDictionaryLookupAtLocation(const WebCore::FloatPoint&);
+ String getSelectionForWordAtPoint(const WebCore::FloatPoint&) const;
bool existingSelectionContainsPoint(const WebCore::FloatPoint&) const;
private:
@@ -153,11 +158,14 @@ private:
#endif
JSC::JSObject* scriptObject(JSC::JSGlobalObject*) override;
void storageBlockingStateChanged() override;
+ void privateBrowsingStateChanged(bool) override;
+ bool getFormValue(String&) override;
bool scroll(WebCore::ScrollDirection, WebCore::ScrollGranularity) override;
WebCore::Scrollbar* horizontalScrollbar() override;
WebCore::Scrollbar* verticalScrollbar() override;
bool wantsWheelEvents() override;
bool shouldAllowNavigationFromDrags() const override;
+ bool shouldNotAddLayer() const override;
void willDetachRenderer() override;
// WebCore::Widget
@@ -183,10 +191,45 @@ private:
void pageMutedStateDidChange() override;
// PluginController
+ void invalidate(const WebCore::IntRect&) override;
+ String userAgent() override;
void loadURL(uint64_t requestID, const String& method, const String& urlString, const String& target, const WebCore::HTTPHeaderMap& headerFields, const Vector<uint8_t>& httpBody, bool allowPopups) override;
+ void cancelStreamLoad(uint64_t streamID) override;
+ void continueStreamLoad(uint64_t streamID) override;
+ void cancelManualStreamLoad() override;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ NPObject* windowScriptNPObject() override;
+ NPObject* pluginElementNPObject() override;
+ bool evaluate(NPObject*, const String& scriptString, NPVariant* result, bool allowPopups) override;
+ void setPluginIsPlayingAudio(bool) override;
+ bool isMuted() const override;
+#endif
+ void setStatusbarText(const String&) override;
+ bool isAcceleratedCompositingEnabled() override;
+ void pluginProcessCrashed() override;
+#if PLATFORM(COCOA)
+ void pluginFocusOrWindowFocusChanged(bool pluginHasFocusAndWindowHasFocus) override;
+ const WTF::MachSendRight& compositingRenderServerPort() override;
+#endif
float contentsScaleFactor() override;
+ String proxiesForURL(const String&) override;
+ String cookiesForURL(const String&) override;
+ void setCookiesForURL(const String& urlString, const String& cookieString) override;
+ bool getAuthenticationInfo(const WebCore::ProtectionSpace&, String& username, String& password) override;
+ bool isPrivateBrowsingEnabled() override;
+ bool asynchronousPluginInitializationEnabled() const override;
+ bool asynchronousPluginInitializationEnabledForAllPlugins() const override;
+ bool artificialPluginInitializationDelayEnabled() const override;
+ void protectPluginFromDestruction() override;
+ void unprotectPluginFromDestruction() override;
+#if PLATFORM(X11) && ENABLE(NETSCAPE_PLUGIN_API)
+ uint64_t createPluginContainer() override;
+ void windowedPluginGeometryDidChange(const WebCore::IntRect& frameRect, const WebCore::IntRect& clipRect, uint64_t windowID) override;
+ void windowedPluginVisibilityDidChange(bool isVisible, uint64_t windowID) override;
+#endif
void didInitializePlugin() override;
+ void didFailToInitializePlugin() override;
void destroyPluginAndReset();
// WebFrame::LoadListener
@@ -197,12 +240,13 @@ private:
RefPtr<WebCore::HTMLPlugInElement> m_pluginElement;
RefPtr<Plugin> m_plugin;
- WeakPtr<WebPage> m_webPage;
+ WebPage* m_webPage;
Plugin::Parameters m_parameters;
bool m_isInitialized { false };
bool m_isWaitingForSynchronousInitialization { false };
bool m_isWaitingUntilMediaCanStart { false };
+ bool m_pluginProcessHasCrashed { false };
// Pending URLRequests that the plug-in has made.
Deque<RefPtr<URLRequest>> m_pendingURLRequests;
@@ -215,6 +259,11 @@ private:
// Streams that the plug-in has requested to load.
HashMap<uint64_t, RefPtr<Stream>> m_streams;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ // A map of all related NPObjects for this plug-in view.
+ NPRuntimeObjectMap m_npRuntimeObjectMap { this };
+#endif
+
// The manual stream state. This is used so we can deliver a manual stream to a plug-in
// when it is initialized.
enum class ManualStreamState { Initial, HasReceivedResponse, Finished, Failed };
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/WebPluginInfoProvider.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/WebPluginInfoProvider.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/WebPluginInfoProvider.cpp 2022-06-30 04:49:38.069512400 -0500
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/WebPluginInfoProvider.cpp 2022-08-26 14:18:15.013022503 -0500
@@ -67,11 +67,23 @@ WebPluginInfoProvider::~WebPluginInfoPro
void WebPluginInfoProvider::refreshPlugins()
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ m_cachedPlugins.clear();
+ m_pluginCacheIsPopulated = false;
+ m_shouldRefreshPlugins = true;
+#endif
}
Vector<PluginInfo> WebPluginInfoProvider::pluginInfo(Page& page, std::optional<Vector<SupportedPluginIdentifier>>& supportedPluginIdentifiers)
{
-#if ENABLE(PDFKIT_PLUGIN)
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ populatePluginCache(page);
+
+ if (m_cachedSupportedPluginIdentifiers)
+ supportedPluginIdentifiers = *m_cachedSupportedPluginIdentifiers;
+
+ return page.mainFrame().arePluginsEnabled() ? m_cachedPlugins : m_cachedApplicationPlugins;
+#elif ENABLE(PDFKIT_PLUGIN)
UNUSED_PARAM(page);
UNUSED_PARAM(supportedPluginIdentifiers);
return { PDFPlugin::pluginInfo() };
@@ -79,7 +91,7 @@ Vector<PluginInfo> WebPluginInfoProvider
UNUSED_PARAM(page);
UNUSED_PARAM(supportedPluginIdentifiers);
return { };
-#endif // ENABLE(PDFKIT_PLUGIN)
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
}
Vector<WebCore::PluginInfo> WebPluginInfoProvider::webVisiblePluginInfo(Page& page, const URL& url)
@@ -109,4 +121,27 @@ Vector<WebCore::PluginInfo> WebPluginInf
return plugins;
}
+#if ENABLE(NETSCAPE_PLUGIN_API)
+void WebPluginInfoProvider::populatePluginCache(const WebCore::Page& page)
+{
+ if (!m_pluginCacheIsPopulated) {
+#if PLATFORM(COCOA)
+ // Application plugins are not affected by enablePlugins setting, so we always need to scan plugins to get them.
+ bool shouldScanPlugins = true;
+#else
+ bool shouldScanPlugins = page.mainFrame().arePluginsEnabled();
+#endif
+ if (shouldScanPlugins) {
+ HangDetectionDisabler hangDetectionDisabler;
+ if (!WebProcess::singleton().parentProcessConnection()->sendSync(Messages::WebProcessProxy::GetPlugins(m_shouldRefreshPlugins),
+ Messages::WebProcessProxy::GetPlugins::Reply(m_cachedPlugins, m_cachedApplicationPlugins, m_cachedSupportedPluginIdentifiers), 0))
+ return;
+ }
+
+ m_shouldRefreshPlugins = false;
+ m_pluginCacheIsPopulated = true;
+ }
+}
+#endif
+
}
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/WebPluginInfoProvider.h webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/WebPluginInfoProvider.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/Plugins/WebPluginInfoProvider.h 2022-06-30 04:49:38.072845700 -0500
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/Plugins/WebPluginInfoProvider.h 2022-08-26 14:18:15.013022503 -0500
@@ -43,6 +43,18 @@ private:
Vector<WebCore::PluginInfo> pluginInfo(WebCore::Page&, std::optional<Vector<WebCore::SupportedPluginIdentifier>>&) final;
Vector<WebCore::PluginInfo> webVisiblePluginInfo(WebCore::Page&, const URL&) final;
void refreshPlugins() override;
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ void populatePluginCache(const WebCore::Page&);
+#endif
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ bool m_pluginCacheIsPopulated { false };
+ bool m_shouldRefreshPlugins { false };
+ Vector<WebCore::PluginInfo> m_cachedPlugins;
+ Vector<WebCore::PluginInfo> m_cachedApplicationPlugins;
+ std::optional<Vector<WebCore::SupportedPluginIdentifier>> m_cachedSupportedPluginIdentifiers;
+#endif
};
}
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.cpp 2022-08-08 16:28:31.871981100 -0500
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.cpp 2022-08-26 14:18:15.017022524 -0500
@@ -707,8 +707,23 @@ bool WebChromeClient::shouldUnavailableP
void WebChromeClient::unavailablePluginButtonClicked(Element& element, RenderEmbeddedObject::PluginUnavailabilityReason pluginUnavailabilityReason) const
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ ASSERT(element.hasTagName(objectTag) || element.hasTagName(embedTag) || element.hasTagName(appletTag));
+ ASSERT(pluginUnavailabilityReason == RenderEmbeddedObject::PluginMissing || pluginUnavailabilityReason == RenderEmbeddedObject::InsecurePluginVersion || pluginUnavailabilityReason);
+
+ auto& pluginElement = downcast<HTMLPlugInImageElement>(element);
+
+ String frameURLString = pluginElement.document().frame()->loader().documentLoader()->responseURL().string();
+ String pageURLString = m_page.mainFrame()->loader().documentLoader()->responseURL().string();
+ String pluginURLString = pluginElement.document().completeURL(pluginElement.url()).string();
+ URL pluginspageAttributeURL = pluginElement.document().completeURL(stripLeadingAndTrailingHTMLSpaces(pluginElement.attributeWithoutSynchronization(pluginspageAttr)));
+ if (!pluginspageAttributeURL.protocolIsInHTTPFamily())
+ pluginspageAttributeURL = URL();
+ m_page.send(Messages::WebPageProxy::UnavailablePluginButtonClicked(pluginUnavailabilityReason, pluginElement.serviceType(), pluginURLString, pluginspageAttributeURL.string(), frameURLString, pageURLString));
+#else
UNUSED_PARAM(element);
UNUSED_PARAM(pluginUnavailabilityReason);
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
}
void WebChromeClient::mouseDidMoveOverElement(const HitTestResult& hitTestResult, unsigned modifierFlags, const String& toolTip, TextDirection)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp 2022-06-30 04:49:38.082845700 -0500
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp 2022-08-26 14:18:15.017022524 -0500
@@ -33,6 +33,7 @@
#include "NetworkConnectionToWebProcessMessages.h"
#include "NetworkProcessConnection.h"
#include "NetworkResourceLoadParameters.h"
+#include "PluginInfoStore.h"
#include "SharedBufferCopy.h"
#include "WebCoreArgumentCoders.h"
#include "WebErrors.h"
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/WebPage/WebPage.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/WebPage/WebPage.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/WebPage/WebPage.cpp 2022-08-23 05:34:51.190085400 -0500
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/WebPage/WebPage.cpp 2022-08-26 14:18:15.017022524 -0500
@@ -49,10 +49,13 @@
#include "MediaKeySystemPermissionRequestManager.h"
#include "MediaPlaybackState.h"
#include "MediaRecorderProvider.h"
+#include "NetscapePlugin.h"
#include "NetworkConnectionToWebProcessMessages.h"
#include "NetworkProcessConnection.h"
#include "NotificationPermissionRequestManager.h"
#include "PageBanner.h"
+#include "PluginProcessAttributes.h"
+#include "PluginProxy.h"
#include "PluginView.h"
#include "PrintInfo.h"
#include "RemoteRenderingBackendProxy.h"
@@ -1163,11 +1166,53 @@ void WebPage::initializeInjectedBundleFu
#if ENABLE(PDFKIT_PLUGIN)
RefPtr<Plugin> WebPage::createPlugin(WebFrame* frame, HTMLPlugInElement* pluginElement, const Plugin::Parameters& parameters, String& newMIMEType)
{
- if (shouldUsePDFPlugin(parameters.mimeType, parameters.url.path()))
- return PDFPlugin::create(*frame, pluginElement);
+ String frameURLString = frame->coreFrame()->loader().documentLoader()->responseURL().string();
+ String pageURLString = m_page->mainFrame().loader().documentLoader()->responseURL().string();
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ bool allowOnlyApplicationPlugins = !frame->coreFrame()->arePluginsEnabled();
+#endif
+
+ uint64_t pluginProcessToken { 0 };
+ uint32_t pluginLoadPolicy { 0 };
+ String unavailabilityDescription;
+ bool isUnsupported { false };
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ if (!sendSync(Messages::WebPageProxy::FindPlugin(parameters.mimeType, parameters.url.string(), frameURLString, pageURLString, allowOnlyApplicationPlugins), Messages::WebPageProxy::FindPlugin::Reply(pluginProcessToken, newMIMEType, pluginLoadPolicy, unavailabilityDescription, isUnsupported)))
+ return nullptr;
+#endif
+
+ PluginModuleLoadPolicy loadPolicy = static_cast<PluginModuleLoadPolicy>(pluginLoadPolicy);
+ bool isBlockedPlugin = (loadPolicy == PluginModuleBlockedForSecurity) || (loadPolicy == PluginModuleBlockedForCompatibility);
+
+ if (isUnsupported || isBlockedPlugin || !pluginProcessToken) {
+#if ENABLE(PDFKIT_PLUGIN)
+ if (shouldUsePDFPlugin(parameters.mimeType, parameters.url.path()))
+ return PDFPlugin::create(*frame, pluginElement);
+#endif
+ }
+
+ if (isUnsupported) {
+ pluginElement->setReplacement(RenderEmbeddedObject::UnsupportedPlugin, unavailabilityDescription);
+ return nullptr;
+ }
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ if (isBlockedPlugin) {
+ bool isReplacementObscured = pluginElement->setReplacement(RenderEmbeddedObject::InsecurePluginVersion, unavailabilityDescription);
+ send(Messages::WebPageProxy::DidBlockInsecurePluginVersion(parameters.mimeType, parameters.url.string(), frameURLString, pageURLString, isReplacementObscured));
+ return nullptr;
+ }
+
+ if (!pluginProcessToken)
+ return nullptr;
+
+ return PluginProxy::create(pluginProcessToken);
+#else
return nullptr;
+#endif
}
-#endif // ENABLE(PDFKIT_PLUGIN)
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
#if ENABLE(WEBGL) && !PLATFORM(MAC)
WebCore::WebGLLoadPolicy WebPage::webGLPolicyForURL(WebFrame*, const URL&)
@@ -3982,6 +4027,9 @@ void WebPage::updatePreferences(const We
DatabaseManager::singleton().setIsAvailable(store.getBoolValueForKey(WebPreferencesKey::databasesEnabledKey()));
m_tabToLinks = store.getBoolValueForKey(WebPreferencesKey::tabsToLinksKey());
+ m_asynchronousPluginInitializationEnabled = store.getBoolValueForKey(WebPreferencesKey::asynchronousPluginInitializationEnabledKey());
+ m_asynchronousPluginInitializationEnabledForAllPlugins = store.getBoolValueForKey(WebPreferencesKey::asynchronousPluginInitializationEnabledForAllPluginsKey());
+ m_artificialPluginInitializationDelayEnabled = store.getBoolValueForKey(WebPreferencesKey::artificialPluginInitializationDelayEnabledKey());
bool isAppNapEnabled = store.getBoolValueForKey(WebPreferencesKey::pageVisibilityBasedProcessSuppressionEnabledKey());
if (m_isAppNapEnabled != isAppNapEnabled) {
@@ -5863,8 +5911,24 @@ FrameView* WebPage::mainFrameView() cons
bool WebPage::canPluginHandleResponse(const ResourceResponse& response)
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ uint32_t pluginLoadPolicy;
+ bool allowOnlyApplicationPlugins = !m_mainFrame->coreFrame()->arePluginsEnabled();
+
+ uint64_t pluginProcessToken;
+ String newMIMEType;
+ String unavailabilityDescription;
+ bool isUnsupported = false;
+ if (!sendSync(Messages::WebPageProxy::FindPlugin(response.mimeType(), response.url().string(), response.url().string(), response.url().string(), allowOnlyApplicationPlugins), Messages::WebPageProxy::FindPlugin::Reply(pluginProcessToken, newMIMEType, pluginLoadPolicy, unavailabilityDescription, isUnsupported)))
+ return false;
+
+ ASSERT(!isUnsupported);
+ bool isBlockedPlugin = (pluginLoadPolicy == PluginModuleBlockedForSecurity) || (pluginLoadPolicy == PluginModuleBlockedForCompatibility);
+ return !isUnsupported && !isBlockedPlugin && pluginProcessToken;
+#else
UNUSED_PARAM(response);
return false;
+#endif
}
bool WebPage::shouldUseCustomContentProviderForResponse(const ResourceResponse& response)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/WebPage/WebPage.h webkitgtk-2.36.7/Source/WebKit/WebProcess/WebPage/WebPage.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/WebPage/WebPage.h 2022-08-22 03:34:34.661301900 -0500
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/WebPage/WebPage.h 2022-08-26 14:18:15.017022524 -0500
@@ -949,6 +949,8 @@ public:
WKAccessibilityWebPageObject* accessibilityRemoteObject();
NSObject *accessibilityObjectForMainFramePlugin();
const WebCore::FloatPoint& accessibilityPosition() const { return m_accessibilityPosition; }
+
+ void sendComplexTextInputToPlugin(uint64_t pluginComplexTextInputIdentifier, const String& textInput);
void setTextAsync(const String&);
void insertTextAsync(const String& text, const EditingRange& replacementRange, InsertTextOptions&&);
@@ -1146,6 +1148,13 @@ public:
bool shouldUseCustomContentProviderForResponse(const WebCore::ResourceResponse&);
+ bool asynchronousPluginInitializationEnabled() const { return m_asynchronousPluginInitializationEnabled; }
+ void setAsynchronousPluginInitializationEnabled(bool enabled) { m_asynchronousPluginInitializationEnabled = enabled; }
+ bool asynchronousPluginInitializationEnabledForAllPlugins() const { return m_asynchronousPluginInitializationEnabledForAllPlugins; }
+ void setAsynchronousPluginInitializationEnabledForAllPlugins(bool enabled) { m_asynchronousPluginInitializationEnabledForAllPlugins = enabled; }
+ bool artificialPluginInitializationDelayEnabled() const { return m_artificialPluginInitializationDelayEnabled; }
+ void setArtificialPluginInitializationDelayEnabled(bool enabled) { m_artificialPluginInitializationDelayEnabled = enabled; }
+
#if PLATFORM(COCOA)
bool pdfPluginEnabled() const { return m_pdfPluginEnabled; }
void setPDFPluginEnabled(bool enabled) { m_pdfPluginEnabled = enabled; }
@@ -2010,6 +2019,9 @@ private:
bool m_isClosed { false };
bool m_tabToLinks { false };
+ bool m_asynchronousPluginInitializationEnabled { false };
+ bool m_asynchronousPluginInitializationEnabledForAllPlugins { false };
+ bool m_artificialPluginInitializationDelayEnabled { false };
bool m_mainFrameIsScrollable { true };
bool m_alwaysShowsHorizontalScroller { false };
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/WebPage/WebPage.messages.in webkitgtk-2.36.7/Source/WebKit/WebProcess/WebPage/WebPage.messages.in
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/WebPage/WebPage.messages.in 2022-07-01 06:23:00.618417300 -0500
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/WebPage/WebPage.messages.in 2022-08-26 14:18:15.017022524 -0500
@@ -461,6 +461,9 @@ GenerateSyntheticEditingCommand(enum:uin
#endif
#if PLATFORM(COCOA)
+ # Complex text input support for plug-ins.
+ SendComplexTextInputToPlugin(uint64_t pluginComplexTextInputIdentifier, String textInput)
+
WindowAndViewFramesChanged(WebCore::FloatRect windowFrameInScreenCoordinates, WebCore::FloatRect windowFrameInUnflippedScreenCoordinates, WebCore::FloatRect viewFrameInWindowCoordinates, WebCore::FloatPoint accessibilityViewCoordinates)
SetMainFrameIsScrollable(bool isScrollable)
RegisterUIProcessAccessibilityTokens(IPC::DataReference elemenToken, IPC::DataReference windowToken)
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/WebProcess.cpp webkitgtk-2.36.7/Source/WebKit/WebProcess/WebProcess.cpp
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/WebProcess.cpp 2022-08-08 06:13:37.349459400 -0500
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/WebProcess.cpp 2022-08-26 14:18:15.017022524 -0500
@@ -42,6 +42,7 @@
#include "NetworkProcessConnectionInfo.h"
#include "NetworkSession.h"
#include "NetworkSessionCreationParameters.h"
+#include "PluginProcessConnectionManager.h"
#include "ProcessAssertion.h"
#include "RemoteAudioHardwareListener.h"
#include "RemoteAudioSession.h"
@@ -287,6 +288,9 @@ WebProcess::WebProcess()
, m_webLockRegistry(RemoteWebLockRegistry::create(*this))
, m_cookieJar(WebCookieJar::create())
, m_dnsPrefetchHystereris([this](PAL::HysteresisState state) { if (state == PAL::HysteresisState::Stopped) m_dnsPrefetchedHosts.clear(); })
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ , m_pluginProcessConnectionManager(PluginProcessConnectionManager::create())
+#endif
, m_nonVisibleProcessGraphicsCleanupTimer(*this, &WebProcess::nonVisibleProcessGraphicsCleanupTimerFired)
#if ENABLE(NON_VISIBLE_WEBPROCESS_MEMORY_CLEANUP_TIMER)
, m_nonVisibleProcessMemoryCleanupTimer(*this, &WebProcess::nonVisibleProcessMemoryCleanupTimerFired)
@@ -380,6 +384,10 @@ void WebProcess::initializeConnection(IP
m_webInspectorInterruptDispatcher->initializeConnection(connection);
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ m_pluginProcessConnectionManager->initializeConnection(connection);
+#endif
+
for (auto& supplement : m_supplements.values())
supplement->initializeConnection(connection);
@@ -550,6 +558,8 @@ void WebProcess::initializeWebProcess(We
setShouldUseFontSmoothing(parameters.shouldUseFontSmoothing);
+ setTerminationTimeout(parameters.terminationTimeout);
+
setMemoryCacheDisabled(parameters.memoryCacheDisabled);
WebCore::RuntimeEnabledFeatures::sharedFeatures().setAttrStyleEnabled(parameters.attrStyleEnabled);
@@ -778,6 +788,13 @@ void WebProcess::fullKeyboardAccessModeC
m_fullKeyboardAccessEnabled = fullKeyboardAccessEnabled;
}
+#if ENABLE(NETSCAPE_PLUGIN_API)
+PluginProcessConnectionManager& WebProcess::pluginProcessConnectionManager()
+{
+ return *m_pluginProcessConnectionManager;
+}
+#endif
+
void WebProcess::setCacheModel(CacheModel cacheModel)
{
if (m_hasSetCacheModel && (cacheModel == m_cacheModel))
@@ -1017,6 +1034,9 @@ void WebProcess::isJITEnabled(Completion
void WebProcess::refreshPlugins()
{
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ WebPluginInfoProvider::singleton().refresh(false);
+#endif
}
void WebProcess::garbageCollectJavaScriptObjects()
diff -urpN webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/WebProcess.h webkitgtk-2.36.7/Source/WebKit/WebProcess/WebProcess.h
--- webkitgtk-2.36.7.orig/Source/WebKit/WebProcess/WebProcess.h 2022-06-30 04:49:38.116179000 -0500
+++ webkitgtk-2.36.7/Source/WebKit/WebProcess/WebProcess.h 2022-08-26 14:18:15.017022524 -0500
@@ -29,6 +29,7 @@
#include "AuxiliaryProcess.h"
#include "CacheModel.h"
#include "IdentifierTypes.h"
+#include "PluginProcessConnectionManager.h"
#include "SandboxExtension.h"
#include "StorageAreaMapIdentifier.h"
#include "TextCheckerState.h"
@@ -236,6 +237,10 @@ public:
const TextCheckerState& textCheckerState() const { return m_textCheckerState; }
void setTextCheckerState(const TextCheckerState&);
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ PluginProcessConnectionManager& pluginProcessConnectionManager();
+#endif
EventDispatcher& eventDispatcher() { return m_eventDispatcher.get(); }
@@ -683,6 +688,10 @@ private:
std::unique_ptr<WebAutomationSessionProxy> m_automationSessionProxy;
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ RefPtr<PluginProcessConnectionManager> m_pluginProcessConnectionManager;
+#endif
+
#if ENABLE(SERVICE_CONTROLS)
bool m_hasImageServices { false };
bool m_hasSelectionServices { false };
diff -urpN webkitgtk-2.36.7.orig/Source/WTF/Scripts/Preferences/WebPreferencesInternal.yaml webkitgtk-2.36.7/Source/WTF/Scripts/Preferences/WebPreferencesInternal.yaml
--- webkitgtk-2.36.7.orig/Source/WTF/Scripts/Preferences/WebPreferencesInternal.yaml 2022-07-01 06:23:00.601750900 -0500
+++ webkitgtk-2.36.7/Source/WTF/Scripts/Preferences/WebPreferencesInternal.yaml 2022-08-26 14:18:15.017022524 -0500
@@ -281,6 +281,18 @@ EventHandlerDrivenSmoothKeyboardScrollin
WebCore:
default: false
+# FIXME: This is not relevent for WebKitLegacy, so should be excluded from WebKitLegacy entirely.
+ExperimentalPlugInSandboxProfilesEnabled:
+ type: bool
+ humanReadableName: "Sandbox Plug-Ins"
+ humanReadableDescription: "Enable Plug-In sandboxing"
+ webcoreBinding: RuntimeEnabledFeatures
+ defaultValue:
+ WebKitLegacy:
+ default: false
+ WebKit:
+ default: false
+
FasterClicksEnabled:
type: bool
humanReadableName: "Fast clicks"
diff -urpN webkitgtk-2.36.7.orig/Source/WTF/Scripts/Preferences/WebPreferences.yaml webkitgtk-2.36.7/Source/WTF/Scripts/Preferences/WebPreferences.yaml
--- webkitgtk-2.36.7.orig/Source/WTF/Scripts/Preferences/WebPreferences.yaml 2022-06-30 04:49:30.029517700 -0500
+++ webkitgtk-2.36.7/Source/WTF/Scripts/Preferences/WebPreferences.yaml 2022-08-26 14:18:15.017022524 -0500
@@ -312,6 +312,30 @@ ApplePayEnabled:
"ENABLE(APPLE_PAY_REMOTE_UI)": true
default: false
+ArtificialPluginInitializationDelayEnabled:
+ type: bool
+ webcoreBinding: none
+ exposed: [ WebKit ]
+ defaultValue:
+ WebKit:
+ default: false
+
+AsynchronousPluginInitializationEnabled:
+ type: bool
+ webcoreBinding: none
+ exposed: [ WebKit ]
+ defaultValue:
+ WebKit:
+ default: false
+
+AsynchronousPluginInitializationEnabledForAllPlugins:
+ type: bool
+ webcoreBinding: none
+ exposed: [ WebKit ]
+ defaultValue:
+ WebKit:
+ default: false
+
AsynchronousSpellCheckingEnabled:
type: bool
defaultValue:
@@ -345,6 +369,17 @@ AuthorAndUserStylesEnabled:
WebCore:
default: true
+BackForwardCacheSupportsPlugins:
+ type: bool
+ webKitLegacyPreferenceKey: WebKitPageCacheSupportsPluginsPreferenceKey
+ defaultValue:
+ WebKitLegacy:
+ default: true
+ WebKit:
+ default: true
+ WebCore:
+ default: false
+
BackspaceKeyNavigationEnabled:
type: bool
defaultValue:
diff -urpN webkitgtk-2.36.7.orig/Source/WTF/wtf/PlatformEnable.h webkitgtk-2.36.7/Source/WTF/wtf/PlatformEnable.h
--- webkitgtk-2.36.7.orig/Source/WTF/wtf/PlatformEnable.h 2022-06-30 04:49:30.112851000 -0500
+++ webkitgtk-2.36.7/Source/WTF/wtf/PlatformEnable.h 2022-08-26 14:18:15.017022524 -0500
@@ -395,6 +395,10 @@
#define ENABLE_MOUSE_FORCE_EVENTS 1
#endif
+#if !defined(ENABLE_NETSCAPE_PLUGIN_API)
+#define ENABLE_NETSCAPE_PLUGIN_API 0
+#endif
+
#if !defined(ENABLE_NETSCAPE_PLUGIN_METADATA_CACHE)
#define ENABLE_NETSCAPE_PLUGIN_METADATA_CACHE 0
#endif
diff -urpN webkitgtk-2.36.7.orig/Tools/PlatformGTK.cmake webkitgtk-2.36.7/Tools/PlatformGTK.cmake
--- webkitgtk-2.36.7.orig/Tools/PlatformGTK.cmake 2022-06-30 04:49:38.729512000 -0500
+++ webkitgtk-2.36.7/Tools/PlatformGTK.cmake 2022-08-26 14:18:15.021022546 -0500
@@ -7,6 +7,10 @@ if (DEVELOPER_MODE)
if (ENABLE_API_TESTS)
add_subdirectory(TestWebKitAPI/glib)
endif ()
+
+ if (ENABLE_NETSCAPE_PLUGIN_API)
+ add_subdirectory(DumpRenderTree/TestNetscapePlugIn)
+ endif ()
endif ()
if (ENABLE_MINIBROWSER)
diff -urpN webkitgtk-2.36.7.orig/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitSettings.cpp webkitgtk-2.36.7/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitSettings.cpp
--- webkitgtk-2.36.7.orig/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitSettings.cpp 2022-06-30 04:49:39.152845100 -0500
+++ webkitgtk-2.36.7/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitSettings.cpp 2022-08-26 14:18:15.021022546 -0500
@@ -82,6 +82,11 @@ static void testWebKitSettings(Test*, gc
webkit_settings_set_enable_frame_flattening(settings, TRUE);
g_assert_true(webkit_settings_get_enable_frame_flattening(settings));
+ // Plugins are enabled by default.
+ g_assert_true(webkit_settings_get_enable_plugins(settings));
+ webkit_settings_set_enable_plugins(settings, FALSE);
+ g_assert_false(webkit_settings_get_enable_plugins(settings));
+
// Java is enabled by default.
g_assert_true(webkit_settings_get_enable_java(settings));
webkit_settings_set_enable_java(settings, FALSE);
diff -urpN webkitgtk-2.36.7.orig/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp webkitgtk-2.36.7/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp
--- webkitgtk-2.36.7.orig/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp 2022-07-01 10:15:58.943722200 -0500
+++ webkitgtk-2.36.7/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp 2022-08-26 14:18:15.021022546 -0500
@@ -79,6 +79,84 @@ static void testWebContextEphemeral(Test
g_assert_true(webkit_web_context_is_ephemeral(context.get()));
}
+#if ENABLE(NETSCAPE_PLUGIN_API)
+class PluginsTest: public Test {
+public:
+ MAKE_GLIB_TEST_FIXTURE(PluginsTest);
+
+ PluginsTest()
+ : m_mainLoop(g_main_loop_new(nullptr, TRUE))
+ , m_plugins(nullptr)
+ {
+ webkit_web_context_set_additional_plugins_directory(m_webContext.get(), WEBKIT_TEST_PLUGIN_DIR);
+ }
+
+ ~PluginsTest()
+ {
+ g_main_loop_unref(m_mainLoop);
+ g_list_free_full(m_plugins, g_object_unref);
+ }
+
+ static void getPluginsAsyncReadyCallback(GObject*, GAsyncResult* result, PluginsTest* test)
+ {
+ test->m_plugins = webkit_web_context_get_plugins_finish(test->m_webContext.get(), result, nullptr);
+ g_main_loop_quit(test->m_mainLoop);
+ }
+
+ GList* getPlugins()
+ {
+ g_list_free_full(m_plugins, g_object_unref);
+ webkit_web_context_get_plugins(m_webContext.get(), nullptr, reinterpret_cast<GAsyncReadyCallback>(getPluginsAsyncReadyCallback), this);
+ g_main_loop_run(m_mainLoop);
+ return m_plugins;
+ }
+
+ GMainLoop* m_mainLoop;
+ GList* m_plugins;
+};
+
+static void testWebContextGetPlugins(PluginsTest* test, gconstpointer)
+{
+ GList* plugins = test->getPlugins();
+ g_assert_nonnull(plugins);
+
+ GRefPtr<WebKitPlugin> testPlugin;
+ for (GList* item = plugins; item; item = g_list_next(item)) {
+ WebKitPlugin* plugin = WEBKIT_PLUGIN(item->data);
+ test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(plugin));
+ if (!g_strcmp0(webkit_plugin_get_name(plugin), "WebKit Test PlugIn")) {
+ testPlugin = plugin;
+ break;
+ }
+ }
+ g_assert_true(WEBKIT_IS_PLUGIN(testPlugin.get()));
+
+ char normalizedPath[PATH_MAX];
+ g_assert_nonnull(realpath(WEBKIT_TEST_PLUGIN_DIR, normalizedPath));
+ GUniquePtr<char> pluginPath(g_build_filename(normalizedPath, "libTestNetscapePlugIn.so", nullptr));
+ g_assert_cmpstr(webkit_plugin_get_path(testPlugin.get()), ==, pluginPath.get());
+ g_assert_cmpstr(webkit_plugin_get_description(testPlugin.get()), ==, "Simple Netscape® plug-in that handles test content for WebKit");
+ GList* mimeInfoList = webkit_plugin_get_mime_info_list(testPlugin.get());
+ g_assert_nonnull(mimeInfoList);
+ g_assert_cmpuint(g_list_length(mimeInfoList), ==, 2);
+
+ WebKitMimeInfo* mimeInfo = static_cast<WebKitMimeInfo*>(mimeInfoList->data);
+ g_assert_cmpstr(webkit_mime_info_get_mime_type(mimeInfo), ==, "image/png");
+ g_assert_cmpstr(webkit_mime_info_get_description(mimeInfo), ==, "png image");
+ const gchar* const* extensions = webkit_mime_info_get_extensions(mimeInfo);
+ g_assert_nonnull(extensions);
+ g_assert_cmpstr(extensions[0], ==, "png");
+
+ mimeInfoList = g_list_next(mimeInfoList);
+ mimeInfo = static_cast<WebKitMimeInfo*>(mimeInfoList->data);
+ g_assert_cmpstr(webkit_mime_info_get_mime_type(mimeInfo), ==, "application/x-webkit-test-netscape");
+ g_assert_cmpstr(webkit_mime_info_get_description(mimeInfo), ==, "test netscape content");
+ extensions = webkit_mime_info_get_extensions(mimeInfo);
+ g_assert_nonnull(extensions);
+ g_assert_cmpstr(extensions[0], ==, "testnetscape");
+}
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
+
static const char* kBarHTML = "<html><body>Bar</body></html>";
static const char* kEchoHTMLFormat = "<html><body>%s</body></html>";
static const char* errorDomain = "test";
@@ -1025,6 +1103,9 @@ void beforeAll()
Test::add("WebKitWebContext", "default-context", testWebContextDefault);
Test::add("WebKitWebContext", "ephemeral", testWebContextEphemeral);
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ PluginsTest::add("WebKitWebContext", "get-plugins", testWebContextGetPlugins);
+#endif
URISchemeTest::add("WebKitWebContext", "uri-scheme", testWebContextURIScheme);
// FIXME: implement spellchecker in WPE.
#if PLATFORM(GTK)
