Re-fork ScriptController.h to fix build.

TBR=eseidel
Review URL: http://codereview.chromium.org/6560

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@2972 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 329 insertions, 0 deletions

diff --git a/webkit/pending/ScriptController.h b/webkit/pending/ScriptController.h
new file mode 100644
index 0000000..bdfa696
--- /dev/null
+++ b/webkit/pending/ScriptController.h
@@ -0,0 +1,329 @@
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * 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.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+
+// An interface to abstract implementation differences
+// for various Javascript engines.
+
+#ifndef ScriptController_h
+#define ScriptController_h
+
+#include "HashMap.h"
+
+#include "bindings/npruntime.h"
+#if USE(JSC)
+#include <kjs/ustring.h>
+#endif
+
+#include <wtf/HashMap.h>
+
+#if USE(V8)
+#include "v8.h"
+#include "v8_proxy.h"
+#endif
+
+// JavaScript implementations which expose NPObject will need to implement
+// these methods.
+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 struct _NPRuntimeFunctions {
+    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;
+} NPRuntimeFunctions;
+
+#if USE(JSC)
+namespace KJS {
+    namespace Bindings {
+        class Instance;
+        class RootObject;
+    } 
+}
+#endif
+
+namespace WebCore {
+class Document;
+class EventListener;
+class Event;
+class Frame;
+class HTMLPlugInElement;
+class Node;
+class PausedTimeouts;
+class String;
+class Widget;
+
+// JSString is the string class used for XMLHttpRequest's
+// m_responseText field.
+#if USE(JSC)
+typedef HashMap<void*, RefPtr<KJS::Bindings::RootObject> > RootObjectMap;
+typedef KJS::UString JSString;
+typedef KJS::Bindings::Instance* JSInstance;
+typedef KJS::Bindings::Instance* JSPersistentInstance;
+typedef KJS::JSValue* JSException;
+typedef KJS::JSValue* JSResult;
+#endif
+
+#if USE(V8)
+typedef String JSString;
+typedef v8::Local<v8::Object> JSInstance;
+typedef v8::Persistent<v8::Object> JSPersistentInstance;
+typedef v8::Local<v8::Value> JSException;
+typedef v8::Persistent<v8::Value> JSResult;
+#endif
+
+class ScriptController {
+public:
+    ScriptController(Frame*);
+    ~ScriptController();
+
+#if USE(V8)
+    // TODO(eseidel): V8Proxy should either be folded into ScriptController
+    // or this accessor should be made JSProxy*
+    V8Proxy* proxy() { return m_proxy.get(); }
+#endif
+
+    // Evaluate a script file in the environment of this proxy.
+    // If succeeded, 'succ' is set to true and result is returned
+    // as a string.
+    String evaluate(const String& filename, int baseLine, const String& code, Node* node = NULL, bool* succ = NULL);
+
+    // Second API function for evaluating a JS code.
+    // It returns a JSResult which must be disposed by calling
+    // disposeJSResult. If the result is not disposed, it can cause
+    // serious memory leak. The caller determines whether the evaluation
+    // is successful by checking the value of JSResult.
+    JSResult evaluate(const String& filename, int baseLine, const String& code, Node*);
+    void disposeJSResult(JSResult result);
+    void collectGarbage();
+
+    PassRefPtr<EventListener> createHTMLEventHandler(const String& functionName, const String& code, Node*);
+#if ENABLE(SVG)
+    PassRefPtr<EventListener> createSVGEventHandler(const String& functionName, const String& code, Node*);
+#endif
+
+    // Get the Root object
+    //  JSRootObject* getRootObject();
+    // Creates a property of the global object of a frame.
+    void BindToWindowObject(Frame*, const String& key, NPObject*);
+
+    NPRuntimeFunctions* functions();
+
+    JSInstance createScriptInstanceForWidget(Widget*);
+
+    void clearPluginObjects();
+    void clearDocumentWrapper();
+    void disconnectFrame();
+
+    // Check if the javascript engine has been initialized.
+    bool haveInterpreter() const;
+
+    bool isEnabled() const;
+
+    // TODO(eseide): void* is a compile hack
+    void attachDebugger(void*);
+
+    // Create a NPObject wrapper for a JSObject
+    // NPObject *WrapScriptObject(NPP pluginId, JSObject* objectToWrap,
+    //                           JSRootObject* originRootObject,
+    //                           JSRootObject* rootObject);
+
+    // --- Static methods assume we are running VM in single thread, ---
+    // --- and there is only one VM instance.                        ---
+
+    // Returns the frame of the calling code is in.
+    // Not necessary the frame of this proxy.
+    // For example, JS code in frame A calls windowB.open(...).
+    // Window::open method has the frame pointer of B, but
+    // the execution context is in frame A, so it needs
+    // frame A's loader to complete URL.
+    static Frame* retrieveActiveFrame();
+
+    // Check whether it is safe to access a frame in another domain.
+    static bool isSafeScript(Frame* target);
+
+    // Tell the proxy that document.domain is set.
+    static void setDomain(Frame* target, const String& newDomain);
+
+    // Pass command-line flags to the JS engine
+    static void setFlags(const char* str, int length);
+
+    // Protect and unprotect the JS wrapper from garbage collected.
+    static void gcProtectJSWrapper(void* object);
+    static void gcUnprotectJSWrapper(void* object);
+
+    // Get/Set RecordPlaybackMode flag.
+    // This is a special mode where JS helps the browser implement
+    // playback/record mode.  Generally, in this mode, some functions
+    // of client-side randomness are removed.  For example, in
+    // this mode Math.random() and Date.getTime() may not return
+    // values which vary.
+    static bool RecordPlaybackMode() { return m_recordPlaybackMode; }
+    static void setRecordPlaybackMode(bool value) { m_recordPlaybackMode = value; }
+
+    void finishedWithEvent(Event*);
+    void setEventHandlerLineno(int lineno);
+
+    void setProcessingTimerCallback(bool b) { m_processingTimerCallback = b; }
+    bool processingUserGesture() const;
+
+    void setPaused(bool b) { m_paused = b; }
+    bool isPaused() const { return m_paused; }
+
+    const String* sourceURL() const { return m_sourceURL; } // 0 if we are not evaluating any script
+
+    void clearWindowShell();
+    void updateDocument();
+
+    void pauseTimeouts(OwnPtr<PausedTimeouts>&);
+    void resumeTimeouts(OwnPtr<PausedTimeouts>&);
+
+    void clearScriptObjects();
+    void cleanupScriptObjectsForPlugin(void*);
+
+#if ENABLE(NETSCAPE_PLUGIN_API)
+    NPObject* createScriptObjectForPluginElement(HTMLPlugInElement*);
+    NPObject* windowScriptNPObject();
+#endif
+
+private:
+    static bool m_recordPlaybackMode;
+
+    Frame* m_frame;
+    const String* m_sourceURL;
+
+    bool m_processingTimerCallback;
+    bool m_paused;
+
+#if USE(V8)
+    OwnPtr<V8Proxy> m_proxy;
+    typedef HashMap<void*, NPObject*> PluginObjectMap;
+#endif
+
+#if USE(JSC)
+    // The root object used for objects bound outside the context of a plugin.
+    RefPtr<KJS::Bindings::RootObject> m_bindingRootObject; 
+    RootObjectMap m_rootObjects;
+#elif USE(V8)
+    // A mapping between Widgets and their corresponding script object.
+    // This list is used so that when the plugin dies, we can immediately
+    // invalidate all sub-objects which are associated with that plugin.
+    // The frame keeps a NPObject reference for each item on the list.
+    PluginObjectMap m_pluginObjects;
+#endif
+#if ENABLE(NETSCAPE_PLUGIN_API)
+    NPObject* m_windowScriptNPObject;
+#endif
+};
+
+// JSInstance is an abstraction for a wrapped C class.  JSC and V8
+// have very different implementations.
+class JSInstanceHolder {
+public:
+    JSInstanceHolder();
+    JSInstanceHolder(JSInstance);
+    ~JSInstanceHolder();
+    // Returns true if the holder is empty.
+    bool IsEmpty();
+    // Get the contained JSInstance.
+    JSInstance Get();
+    // Clear the contained JSInstance.
+    void Clear();
+    JSInstanceHolder& operator=(JSInstance);
+    static JSInstance EmptyInstance();
+
+private:
+    JSPersistentInstance m_instance;
+};
+
+}  // namespace WebCore
+
+#endif  // ScriptController_h