blob: e2fcc8c50e64ddb58bbe3fc5a96d4cbda43c812c [file] [log] [blame]
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
/*
* Copyright (C) 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.
*/
#include "content/shell/tools/plugin/test_object.h"
#include "PluginObject.h"
#include <string.h>
#include <stdlib.h>
static bool testEnumerate(NPObject* npobj,
NPIdentifier** value,
uint32_t* count);
static bool testHasMethod(NPObject*, NPIdentifier name);
static bool testInvoke(NPObject*,
NPIdentifier name,
const NPVariant* args,
uint32_t argCount,
NPVariant* result);
static bool testHasProperty(NPObject*, NPIdentifier name);
static bool testGetProperty(NPObject*, NPIdentifier name, NPVariant*);
static NPObject* testAllocate(NPP npp, NPClass* theClass);
static void testDeallocate(NPObject* obj);
static bool testConstruct(NPObject* obj,
const NPVariant* args,
uint32_t argCount,
NPVariant* result);
static NPClass g_test_class = {
NP_CLASS_STRUCT_VERSION, testAllocate, testDeallocate, 0,
testHasMethod, testInvoke, 0, testHasProperty,
testGetProperty, 0, 0, testEnumerate,
testConstruct};
static int g_test_object_count = 0;
typedef struct {
NPObject header;
NPObject* testObject;
} TestObject;
static bool identifiersInitialized = false;
#define NUM_ENUMERATABLE_TEST_IDENTIFIERS 2
enum {
ID_PROPERTY_FOO = 0,
ID_PROPERTY_BAR,
ID_PROPERTY_OBJECT_POINTER,
ID_PROPERTY_TEST_OBJECT,
ID_PROPERTY_REF_COUNT,
NUM_TEST_IDENTIFIERS,
};
static NPIdentifier testIdentifiers[NUM_TEST_IDENTIFIERS];
static const NPUTF8* testIdentifierNames[NUM_TEST_IDENTIFIERS] = {
"foo", "bar", "objectPointer", "testObject", "refCount", };
#define ID_THROW_EXCEPTION_METHOD 0
#define NUM_METHOD_IDENTIFIERS 1
static NPIdentifier testMethodIdentifiers[NUM_METHOD_IDENTIFIERS];
static const NPUTF8* testMethodIdentifierNames[NUM_METHOD_IDENTIFIERS] = {
"throwException", };
static void initializeIdentifiers(void) {
browser->getstringidentifiers(
testIdentifierNames, NUM_TEST_IDENTIFIERS, testIdentifiers);
browser->getstringidentifiers(
testMethodIdentifierNames, NUM_METHOD_IDENTIFIERS, testMethodIdentifiers);
}
static NPObject* testAllocate(NPP npp, NPClass* /*theClass*/) {
TestObject* newInstance =
static_cast<TestObject*>(malloc(sizeof(TestObject)));
newInstance->testObject = 0;
++g_test_object_count;
if (!identifiersInitialized) {
identifiersInitialized = true;
initializeIdentifiers();
}
return reinterpret_cast<NPObject*>(newInstance);
}
static void testDeallocate(NPObject* obj) {
TestObject* testObject = reinterpret_cast<TestObject*>(obj);
if (testObject->testObject)
browser->releaseobject(testObject->testObject);
--g_test_object_count;
free(obj);
}
static bool testHasMethod(NPObject*, NPIdentifier name) {
for (unsigned i = 0; i < NUM_METHOD_IDENTIFIERS; i++) {
if (testMethodIdentifiers[i] == name)
return true;
}
return false;
}
static bool testInvoke(NPObject* header,
NPIdentifier name,
const NPVariant* /*args*/,
uint32_t /*argCount*/,
NPVariant* /*result*/) {
if (name == testMethodIdentifiers[ID_THROW_EXCEPTION_METHOD]) {
browser->setexception(header, "test object throwException SUCCESS");
return true;
}
return false;
}
static bool testHasProperty(NPObject*, NPIdentifier name) {
for (unsigned i = 0; i < NUM_TEST_IDENTIFIERS; i++) {
if (testIdentifiers[i] == name)
return true;
}
return false;
}
static bool testGetProperty(NPObject* npobj,
NPIdentifier name,
NPVariant* result) {
if (name == testIdentifiers[ID_PROPERTY_FOO]) {
char* mem = static_cast<char*>(browser->memalloc(4));
strcpy(mem, "foo");
STRINGZ_TO_NPVARIANT(mem, *result);
return true;
}
if (name == testIdentifiers[ID_PROPERTY_BAR]) {
char* mem = static_cast<char*>(browser->memalloc(4));
strcpy(mem, "bar");
STRINGZ_TO_NPVARIANT(mem, *result);
return true;
}
if (name == testIdentifiers[ID_PROPERTY_OBJECT_POINTER]) {
int32_t objectPointer =
static_cast<int32_t>(reinterpret_cast<long long>(npobj));
INT32_TO_NPVARIANT(objectPointer, *result);
return true;
}
if (name == testIdentifiers[ID_PROPERTY_TEST_OBJECT]) {
TestObject* testObject = reinterpret_cast<TestObject*>(npobj);
if (!testObject->testObject)
testObject->testObject = browser->createobject(0, &g_test_class);
browser->retainobject(testObject->testObject);
OBJECT_TO_NPVARIANT(testObject->testObject, *result);
return true;
}
if (name == testIdentifiers[ID_PROPERTY_REF_COUNT]) {
INT32_TO_NPVARIANT(npobj->referenceCount, *result);
return true;
}
return false;
}
static bool testEnumerate(NPObject* /*npobj*/,
NPIdentifier** value,
uint32_t* count) {
*count = NUM_ENUMERATABLE_TEST_IDENTIFIERS;
*value = (NPIdentifier*)browser->memalloc(NUM_ENUMERATABLE_TEST_IDENTIFIERS *
sizeof(NPIdentifier));
memcpy(*value,
testIdentifiers,
sizeof(NPIdentifier) * NUM_ENUMERATABLE_TEST_IDENTIFIERS);
return true;
}
static bool testConstruct(NPObject* npobj,
const NPVariant* /*args*/,
uint32_t /*argCount*/,
NPVariant* result) {
browser->retainobject(npobj);
// Just return the same object.
OBJECT_TO_NPVARIANT(npobj, *result);
return true;
}
namespace content {
NPClass* GetTestClass() { return &g_test_class; }
int GetTestObjectCount() { return g_test_object_count; }
} // namespace content