Remove NPAPI test plugin

content/shell/tools/plugin/PluginTest.cpp

-// 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) 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 "PluginTest.h"
-
-#include "PluginObject.h"
-#include <string.h>
-
-#if defined(XP_UNIX) || defined(ANDROID)
-#include <unistd.h>
-#endif
-
-using namespace std;
-extern NPNetscapeFuncs *browser;
-
-static void (*shutdownFunction)();
-
-PluginTest* PluginTest::create(NPP npp, const string& identifier) {
-  if (identifier.empty())
-    return new PluginTest(npp, identifier);
-
-  CreateTestFunction createTestFunction = createTestFunctions()[identifier];
-  if (createTestFunction)
-    return createTestFunction(npp, identifier);
-
-  return 0;
-}
-
-PluginTest::PluginTest(NPP npp, const string& identifier)
-    : m_npp(npp), m_identifier(identifier) {
-  // Reset the shutdown function.
-  shutdownFunction = 0;
-}
-
-PluginTest::~PluginTest() {}
-
-void PluginTest::NP_Shutdown() {
-  if (shutdownFunction)
-    shutdownFunction();
-}
-
-void PluginTest::registerNPShutdownFunction(void (*func)()) {
-  assert(!shutdownFunction);
-  shutdownFunction = func;
-}
-
-void PluginTest::indicateTestFailure() {
-// This should really be an assert, but there's no way for the test framework
-// to know that the plugin process crashed, so we'll just sleep for a while
-// to ensure that the test times out.
-#if defined(XP_WIN)
-  ::Sleep(100000);
-#else
-  sleep(1000);
-#endif
-}
-
-NPError PluginTest::NPP_New(NPMIMEType pluginType,
-                            uint16_t mode,
-                            int16_t argc,
-                            char* argn[],
-                            char* argv[],
-                            NPSavedData* saved) {
-  return NPERR_NO_ERROR;
-}
-
-NPError PluginTest::NPP_Destroy(NPSavedData**) { return NPERR_NO_ERROR; }
-
-NPError PluginTest::NPP_SetWindow(NPWindow*) { return NPERR_NO_ERROR; }
-
-NPError PluginTest::NPP_NewStream(NPMIMEType type,
-                                  NPStream* stream,
-                                  NPBool seekable,
-                                  uint16_t* stype) {
-  return NPERR_NO_ERROR;
-}
-
-NPError PluginTest::NPP_DestroyStream(NPStream* stream, NPReason reason) {
-  return NPERR_NO_ERROR;
-}
-
-int32_t PluginTest::NPP_WriteReady(NPStream*) { return 4096; }
-
-int32_t PluginTest::NPP_Write(NPStream*,
-                              int32_t offset,
-                              int32_t len,
-                              void* buffer) {
-  return len;
-}
-
-int16_t PluginTest::NPP_HandleEvent(void*) { return 0; }
-
-bool PluginTest::NPP_URLNotify(const char* url, NPReason, void* notifyData) {
-  // FIXME: Port the code from NPP_URLNotify in main.cpp over to always using
-  // PluginTest, so we don't have to use a return value to indicate whether the
-  // "default" NPP_URLNotify implementation should be invoked.
-  return false;
-}
-
-NPError PluginTest::NPP_GetValue(NPPVariable variable, void* value) {
-  // We don't know anything about plugin values so just return
-  // NPERR_GENERIC_ERROR.
-  return NPERR_GENERIC_ERROR;
-}
-
-NPError PluginTest::NPP_SetValue(NPNVariable, void* value) {
-  return NPERR_GENERIC_ERROR;
-}
-
-// NPN functions.
-
-NPError PluginTest::NPN_GetValue(NPNVariable variable, void* value) {
-  return browser->getvalue(m_npp, variable, value);
-}
-
-void PluginTest::NPN_InvalidateRect(NPRect* invalidRect) {
-  browser->invalidaterect(m_npp, invalidRect);
-}
-
-bool PluginTest::NPN_Invoke(NPObject* npobj,
-                            NPIdentifier methodName,
-                            const NPVariant* args,
-                            uint32_t argCount,
-                            NPVariant* result) {
-  return browser->invoke(m_npp, npobj, methodName, args, argCount, result);
-}
-
-void* PluginTest::NPN_MemAlloc(uint32_t size) {
-  return browser->memalloc(size);
-}
-
-// NPRuntime NPN functions.
-
-NPIdentifier PluginTest::NPN_GetStringIdentifier(const NPUTF8* name) {
-  return browser->getstringidentifier(name);
-}
-
-NPIdentifier PluginTest::NPN_GetIntIdentifier(int32_t intid) {
-  return browser->getintidentifier(intid);
-}
-
-bool PluginTest::NPN_IdentifierIsString(NPIdentifier npIdentifier) {
-  return browser->identifierisstring(npIdentifier);
-}
-
-NPUTF8* PluginTest::NPN_UTF8FromIdentifier(NPIdentifier npIdentifier) {
-  return browser->utf8fromidentifier(npIdentifier);
-}
-
-int32_t PluginTest::NPN_IntFromIdentifier(NPIdentifier npIdentifier) {
-  return browser->intfromidentifier(npIdentifier);
-}
-
-NPObject* PluginTest::NPN_CreateObject(NPClass* npClass) {
-  return browser->createobject(m_npp, npClass);
-}
-
-NPObject* PluginTest::NPN_RetainObject(NPObject* npObject) {
-  return browser->retainobject(npObject);
-}
-
-void PluginTest::NPN_ReleaseObject(NPObject* npObject) {
-  browser->releaseobject(npObject);
-}
-
-bool PluginTest::NPN_GetProperty(NPObject* npObject,
-                                 NPIdentifier propertyName,
-                                 NPVariant* value) {
-  return browser->getproperty(m_npp, npObject, propertyName, value);
-}
-
-bool PluginTest::NPN_RemoveProperty(NPObject* npObject,
-                                    NPIdentifier propertyName) {
-  return browser->removeproperty(m_npp, npObject, propertyName);
-}
-
-void PluginTest::NPN_ReleaseVariantValue(NPVariant* variant) {
-  browser->releasevariantvalue(variant);
-}
-
-#ifdef XP_MACOSX
-bool PluginTest::NPN_ConvertPoint(double sourceX,
-                                  double sourceY,
-                                  NPCoordinateSpace sourceSpace,
-                                  double* destX,
-                                  double* destY,
-                                  NPCoordinateSpace destSpace) {
-  return browser->convertpoint(
-      m_npp, sourceX, sourceY, sourceSpace, destX, destY, destSpace);
-}
-#endif
-
-bool PluginTest::executeScript(const NPString* script, NPVariant* result) {
-  NPObject* windowScriptObject;
-  browser->getvalue(m_npp, NPNVWindowNPObject, &windowScriptObject);
-
-  return browser->evaluate(
-      m_npp, windowScriptObject, const_cast<NPString*>(script), result);
-}
-
-void PluginTest::executeScript(const char* script) {
-  NPString npScript;
-  npScript.UTF8Characters = script;
-  npScript.UTF8Length = strlen(script);
-
-  NPVariant browserResult;
-  executeScript(&npScript, &browserResult);
-  browser->releasevariantvalue(&browserResult);
-}
-
-void PluginTest::log(const char* format, ...) {
-  va_list args;
-  va_start(args, format);
-  pluginLogWithArguments(m_npp, format, args);
-  va_end(args);
-}
-
-NPNetscapeFuncs* PluginTest::netscapeFuncs() { return browser; }
-
-void PluginTest::waitUntilDone() {
-  executeScript("testRunner.waitUntilDone()");
-}
-
-void PluginTest::notifyDone() { executeScript("testRunner.notifyDone()"); }
-
-void PluginTest::registerCreateTestFunction(
-    const string& identifier,
-    CreateTestFunction createTestFunction) {
-  assert(!createTestFunctions().count(identifier));
-
-  createTestFunctions()[identifier] = createTestFunction;
-}
-
-std::map<std::string, PluginTest::CreateTestFunction>&
-PluginTest::createTestFunctions() {
-  static std::map<std::string, CreateTestFunction> testFunctions;
-
-  return testFunctions;
-}