diff -r 000000000000 -r 4f2f89ce4247 WebCore/bindings/v8/V8Binding.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/WebCore/bindings/v8/V8Binding.h	Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,238 @@
+/*
+* Copyright (C) 2009 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.
+*/
+
+#ifndef V8Binding_h
+#define V8Binding_h
+
+#include "AtomicString.h"
+#include "BindingSecurity.h"
+#include "MathExtras.h"
+#include "PlatformString.h"
+#include "V8DOMWrapper.h"
+
+#include <v8.h>
+
+namespace WebCore {
+    
+    class EventListener;
+    class EventTarget;
+    class V8BindingDOMWindow;
+
+    // Instantiate binding template classes for V8.
+    class V8Binding {
+    public:
+        typedef v8::Handle<v8::Value> Value;
+        typedef V8BindingDOMWindow DOMWindow;
+    };
+    typedef BindingSecurity<V8Binding> V8BindingSecurity;
+    
+    enum ExternalMode {
+        Externalize,
+        DoNotExternalize
+    };
+    
+    template <typename StringType>
+    StringType v8StringToWebCoreString(v8::Handle<v8::String> v8String, ExternalMode external);
+
+    // Convert v8 types to a WebCore::String. If the V8 string is not already
+    // an external string then it is transformed into an external string at this
+    // point to avoid repeated conversions.
+    inline String v8StringToWebCoreString(v8::Handle<v8::String> v8String)
+    {
+        return v8StringToWebCoreString<String>(v8String, Externalize);
+    }
+    String v8NonStringValueToWebCoreString(v8::Handle<v8::Value>);
+    String v8ValueToWebCoreString(v8::Handle<v8::Value> value);
+
+    // Convert v8 types to a WebCore::AtomicString.
+    inline AtomicString v8StringToAtomicWebCoreString(v8::Handle<v8::String> v8String)
+    {
+        return v8StringToWebCoreString<AtomicString>(v8String, Externalize);
+    }
+    AtomicString v8NonStringValueToAtomicWebCoreString(v8::Handle<v8::Value>);
+    AtomicString v8ValueToAtomicWebCoreString(v8::Handle<v8::Value> value);
+
+    // Note: RefPtr is a must as we cache by StringImpl* equality, not identity
+    // hence lastStringImpl might be not a key of the cache (in sense of identity)
+    // and hence it's not refed on addition.
+    extern RefPtr<StringImpl> lastStringImpl;
+    extern v8::Persistent<v8::String> lastV8String;
+    v8::Local<v8::String> v8ExternalStringSlow(StringImpl* stringImpl);
+
+    // Return a V8 external string that shares the underlying buffer with the given
+    // WebCore string. The reference counting mechanism is used to keep the
+    // underlying buffer alive while the string is still live in the V8 engine.
+    inline v8::Local<v8::String> v8ExternalString(const String& string)
+    {
+        StringImpl* stringImpl = string.impl();
+        if (!stringImpl)
+            return v8::String::Empty();
+
+        if (lastStringImpl.get() == stringImpl) {
+            ASSERT(!lastV8String.IsNearDeath());
+            ASSERT(!lastV8String.IsEmpty());
+            return v8::Local<v8::String>::New(lastV8String);
+        }
+
+        return v8ExternalStringSlow(stringImpl);
+    }
+
+    // Convert a string to a V8 string.
+    inline v8::Handle<v8::String> v8String(const String& string)
+    {
+        return v8ExternalString(string);
+    }
+
+    // Enables caching v8 wrappers created for WebCore::StringImpl.  Currently this cache requires
+    // all the calls (both to convert WebCore::String to v8::String and to GC the handle)
+    // to be performed on the main thread.
+    void enableStringImplCache();
+
+    // Convert a value to a 32-bit integer.  The conversion fails if the
+    // value cannot be converted to an integer or converts to nan or to an infinity.
+    int toInt32(v8::Handle<v8::Value> value, bool& ok);
+
+    // Convert a value to a 32-bit integer assuming the conversion cannot fail.
+    inline int toInt32(v8::Handle<v8::Value> value)
+    {
+        bool ok;
+        return toInt32(value, ok);
+    }
+
+    // Convert a value to a 32-bit unsigned integer.  The conversion fails if the
+    // value cannot be converted to an unsigned integer or converts to nan or to an infinity.
+    uint32_t toUInt32(v8::Handle<v8::Value> value, bool& ok);
+
+    // Convert a value to a 32-bit unsigned integer assuming the conversion cannot fail.
+    inline uint32_t toUInt32(v8::Handle<v8::Value> value)
+    {
+        bool ok;
+        return toUInt32(value, ok);
+    }
+
+    inline float toFloat(v8::Local<v8::Value> value)
+    {
+        return static_cast<float>(value->NumberValue());
+    }
+
+    inline long long toInt64(v8::Local<v8::Value> value)
+    {
+        return static_cast<long long>(value->IntegerValue());
+    }
+
+    // FIXME: Drop this in favor of the type specific v8ValueToWebCoreString when we rework the code generation.
+    inline String toWebCoreString(v8::Handle<v8::Value> object)
+    {
+        return v8ValueToWebCoreString(object);
+    }
+    
+    String toWebCoreString(const v8::Arguments&, int index);
+
+    // The string returned by this function is still owned by the argument
+    // and will be deallocated when the argument is deallocated.
+    inline const uint16_t* fromWebCoreString(const String& str)
+    {
+        return reinterpret_cast<const uint16_t*>(str.characters());
+    }
+
+    bool isUndefinedOrNull(v8::Handle<v8::Value> value);
+
+    v8::Handle<v8::Boolean> v8Boolean(bool value);
+
+    String toWebCoreStringWithNullCheck(v8::Handle<v8::Value> value);
+
+    AtomicString toAtomicWebCoreStringWithNullCheck(v8::Handle<v8::Value> value);
+
+    String toWebCoreStringWithNullOrUndefinedCheck(v8::Handle<v8::Value> value);
+ 
+    v8::Handle<v8::String> v8UndetectableString(const String& str);
+
+    v8::Handle<v8::Value> v8StringOrNull(const String& str);
+
+    v8::Handle<v8::Value> v8StringOrUndefined(const String& str);
+
+    v8::Handle<v8::Value> v8StringOrFalse(const String& str);
+
+    double toWebCoreDate(v8::Handle<v8::Value> object);
+
+    v8::Handle<v8::Value> v8DateOrNull(double value);
+    
+    v8::Persistent<v8::FunctionTemplate> createRawTemplate();
+
+    struct BatchedAttribute;
+    struct BatchedCallback;
+    
+    v8::Local<v8::Signature> configureTemplate(v8::Persistent<v8::FunctionTemplate>,
+                                               const char* interfaceName,
+                                               v8::Persistent<v8::FunctionTemplate> parentClass,
+                                               int fieldCount,
+                                               const BatchedAttribute*, 
+                                               size_t attributeCount,
+                                               const BatchedCallback*,
+                                               size_t callbackCount);
+    
+    v8::Handle<v8::Value> getElementStringAttr(const v8::AccessorInfo&,
+                                               const QualifiedName&);
+    void setElementStringAttr(const v8::AccessorInfo&,
+                              const QualifiedName&,
+                              v8::Local<v8::Value>);
+
+    
+    v8::Persistent<v8::String> getToStringName();
+    v8::Persistent<v8::FunctionTemplate> getToStringTemplate();
+    
+    // V8Parameter is an adapter class that converts V8 values to Strings
+    // or AtomicStrings as appropriate, using multiple typecast operators.
+    enum V8ParameterMode {
+        DefaultMode,
+        WithNullCheck,
+        WithUndefinedOrNullCheck
+    };
+    template <V8ParameterMode MODE = DefaultMode>
+    class V8Parameter {
+    public:
+        V8Parameter (v8::Local<v8::Value> object) :m_v8Object(object) { }
+        operator String();
+        operator AtomicString();
+    private:
+        v8::Local<v8::Value> m_v8Object;
+    };
+    
+    template<> inline V8Parameter<DefaultMode>::operator String() { return toWebCoreString(m_v8Object); }
+    template<> inline V8Parameter<WithNullCheck>::operator String() { return toWebCoreStringWithNullCheck(m_v8Object); }
+    template<> inline V8Parameter<WithUndefinedOrNullCheck>::operator String() { return toWebCoreStringWithNullOrUndefinedCheck(m_v8Object); }
+
+    template<> inline V8Parameter<DefaultMode>::operator AtomicString() { return v8ValueToAtomicWebCoreString(m_v8Object); }
+    template<> inline V8Parameter<WithNullCheck>::operator AtomicString() { return toAtomicWebCoreStringWithNullCheck(m_v8Object); }
+    template<> inline V8Parameter<WithUndefinedOrNullCheck>::operator AtomicString() { return toAtomicWebCoreStringWithNullCheck(m_v8Object); }
+
+} // namespace WebCore
+
+#endif // V8Binding_h