Changeset 50846 in webkit


Ignore:
Timestamp:
Nov 11, 2009 4:11:22 PM (14 years ago)
Author:
snej@chromium.org
Message:

The Big De-Inlining. 450k code size reduction (32-bit x86.)

  • Various inline functions in V8Binding.h made non-inline.
  • Some renaming for consistency.
  • New function createRawTemplate().

​https://bugs.webkit.org/show_bug.cgi?id=31383

Reviewed by Dimitri Glazkov.

  • bindings/scripts/CodeGeneratorV8.pm:
  • bindings/v8/V8Binding.cpp:

(WebCore::v8DOMWrapperToNative):
(WebCore::v8ValueToWebCoreString):
(WebCore::v8ValueToAtomicWebCoreString):
(WebCore::toInt32):
(WebCore::toWebCoreString):
(WebCore::toWebCoreStringWithNullCheck):
(WebCore::toAtomicWebCoreStringWithNullCheck):
(WebCore::toWebCoreStringWithNullOrUndefinedCheck):
(WebCore::isUndefinedOrNull):
(WebCore::v8Boolean):
(WebCore::v8UndetectableString):
(WebCore::v8StringOrNull):
(WebCore::v8StringOrUndefined):
(WebCore::v8StringOrFalse):
(WebCore::v8StringToWebCoreString):
(WebCore::v8ExternalString):
(WebCore::createRawTemplate): New function.

  • bindings/v8/V8Binding.h:

(WebCore::v8DOMWrapperTo):
(WebCore::v8DOMWrapperToNode):
(WebCore::v8StringToWebCoreString):
(WebCore::v8StringToAtomicWebCoreString):

Location:
trunk/WebCore
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r50844 r50846  
     12009-11-11  Jens Alfke  <snej@chromium.org>
     2
     3        Reviewed by Dimitri Glazkov.
     4
     5        The Big De-Inlining. 450k code size reduction (32-bit x86.)
     6        - Various inline functions in V8Binding.h made non-inline.
     7        - Some renaming for consistency.
     8        - New function createRawTemplate().
     9        https://bugs.webkit.org/show_bug.cgi?id=31383
     10
     11        * bindings/scripts/CodeGeneratorV8.pm:
     12        * bindings/v8/V8Binding.cpp:
     13        (WebCore::v8DOMWrapperToNative):
     14        (WebCore::v8ValueToWebCoreString):
     15        (WebCore::v8ValueToAtomicWebCoreString):
     16        (WebCore::toInt32):
     17        (WebCore::toWebCoreString):
     18        (WebCore::toWebCoreStringWithNullCheck):
     19        (WebCore::toAtomicWebCoreStringWithNullCheck):
     20        (WebCore::toWebCoreStringWithNullOrUndefinedCheck):
     21        (WebCore::isUndefinedOrNull):
     22        (WebCore::v8Boolean):
     23        (WebCore::v8UndetectableString):
     24        (WebCore::v8StringOrNull):
     25        (WebCore::v8StringOrUndefined):
     26        (WebCore::v8StringOrFalse):
     27        (WebCore::v8StringToWebCoreString):
     28        (WebCore::v8ExternalString):
     29        (WebCore::createRawTemplate):  New function.
     30        * bindings/v8/V8Binding.h:
     31        (WebCore::v8DOMWrapperTo):
     32        (WebCore::v8DOMWrapperToNode):
     33        (WebCore::v8StringToWebCoreString):
     34        (WebCore::v8StringToAtomicWebCoreString):
     35
    1362009-11-11  Jens Alfke  <snej@chromium.org>
    237

  • trunk/WebCore/bindings/scripts/CodeGeneratorV8.pm

    r50844 r50846  
    351351    my $implClassName = shift;
    352352    my $classIndex = shift;
     353    my $holder = shift || "holder";   # optional param
    353354
    354355    if (IsNodeSubType($dataNode)) {
    355356        push(@implContentDecls, <<END);
    356     $implClassName* imp = V8DOMWrapper::convertDOMWrapperToNode<$implClassName>(holder);
     357    $implClassName* imp = v8DOMWrapperToNode<$implClassName>($holder);
    357358END
    358359
    359360    } else {
    360361        push(@implContentDecls, <<END);
    361     $implClassName* imp = V8DOMWrapper::convertToNativeObject<$implClassName>(V8ClassIndex::$classIndex, holder);
     362    $implClassName* imp = v8DOMWrapperTo<$implClassName>(V8ClassIndex::$classIndex, $holder);
    362363END
    363364
    … …  
    398399END
    399400
    400   HolderToNative($dataNode, $implClassName, $classIndex);
     401    HolderToNative($dataNode, $implClassName, $classIndex);
    401402
    402403    push(@implContentDecls, <<END);
    … …  
    429430    if ($classIndex eq "DOMWINDOW") {
    430431        push(@implContentDecls, <<END);
    431     DOMWindow* window = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, info.Holder());
     432    DOMWindow* window = v8DOMWrapperTo<DOMWindow>(V8ClassIndex::DOMWINDOW, info.Holder());
    432433    // Get the proxy corresponding to the DOMWindow if possible to
    433434    // make sure that the constructor function is constructed in the
    … …  
    438439        $implIncludes{"WorkerContextExecutionProxy.h"} = 1;
    439440        push(@implContentDecls, <<END);
    440     WorkerContext* workerContext = V8DOMWrapper::convertToNativeObject<WorkerContext>(V8ClassIndex::WORKERCONTEXT, info.Holder());
     441    WorkerContext* workerContext = v8DOMWrapperTo<WorkerContext>(V8ClassIndex::WORKERCONTEXT, info.Holder());
    441442    return V8DOMWrapper::getConstructor(type, workerContext);
    442443END
    … …  
    505506    if ($isPodType) {
    506507        push(@implContentDecls, <<END);
    507     V8SVGPODTypeWrapper<$implClassName>* imp_wrapper = V8DOMWrapper::convertToNativeObject<V8SVGPODTypeWrapper<$implClassName> >(V8ClassIndex::$classIndex, info.Holder());
     508    V8SVGPODTypeWrapper<$implClassName>* imp_wrapper = v8DOMWrapperTo<V8SVGPODTypeWrapper<$implClassName> >(V8ClassIndex::$classIndex, info.Holder());
    508509    $implClassName imp_instance = *imp_wrapper;
    509510END
    … …  
    526527END
    527528      }
    528         HolderToNative($dataNode, $implClassName, $classIndex);
     529        HolderToNative($dataNode, $implClassName, $classIndex, "info");
    529530    } else {
    530531        push(@implContentDecls, <<END);
    531532    v8::Handle<v8::Object> holder = info.Holder();
    532533END
    533         HolderToNative($dataNode, $implClassName, $classIndex);
     534        HolderToNative($dataNode, $implClassName, $classIndex, "info");
    534535    }
    535536
    … …  
    576577    } else {
    577578        $getterString = "imp_instance";
    578     }
    579 
    580     if ($nativeType eq "String") {
    581         $getterString = "toString($getterString)";
    582579    }
    583580
    … …  
    695692        $implClassName = GetNativeType($implClassName);
    696693        $implIncludes{"V8SVGPODTypeWrapper.h"} = 1;
    697         push(@implContentDecls, "    V8SVGPODTypeWrapper<$implClassName>* wrapper = V8DOMWrapper::convertToNativeObject<V8SVGPODTypeWrapper<$implClassName> >(V8ClassIndex::$classIndex, info.Holder());\n");
     694        push(@implContentDecls, "    V8SVGPODTypeWrapper<$implClassName>* wrapper = v8DOMWrapperTo<V8SVGPODTypeWrapper<$implClassName> >(V8ClassIndex::$classIndex, info.Holder());\n");
    698695        push(@implContentDecls, "    $implClassName imp_instance = *wrapper;\n");
    699696        push(@implContentDecls, "    $implClassName* imp = &imp_instance;\n");
    … …  
    711708END
    712709      }
    713         HolderToNative($dataNode, $implClassName, $classIndex);
     710        HolderToNative($dataNode, $implClassName, $classIndex, "info");
    714711    } else {
    715712        push(@implContentDecls, <<END);
    716713    v8::Handle<v8::Object> holder = info.Holder();
    717714END
    718         HolderToNative($dataNode, $implClassName, $classIndex);
     715        HolderToNative($dataNode, $implClassName, $classIndex, "info");
    719716    }
    720717
    … …  
    846843    if (IsPodType($implClassName)) {
    847844        my $nativeClassName = GetNativeType($implClassName);
    848         push(@implContentDecls, "    V8SVGPODTypeWrapper<$nativeClassName>* imp_wrapper = V8DOMWrapper::convertToNativeObject<V8SVGPODTypeWrapper<$nativeClassName> >(V8ClassIndex::$classIndex, args.Holder());\n");
     845        push(@implContentDecls, "    V8SVGPODTypeWrapper<$nativeClassName>* imp_wrapper = v8DOMWrapperTo<V8SVGPODTypeWrapper<$nativeClassName> >(V8ClassIndex::$classIndex, args.Holder());\n");
    849846        push(@implContentDecls, "    $nativeClassName imp_instance = *imp_wrapper;\n");
    850847        push(@implContentDecls, "    $nativeClassName* imp = &imp_instance;\n");
    … …  
    14021399
    14031400v8::Persistent<v8::FunctionTemplate> ${className}::GetRawTemplate() {
    1404   static v8::Persistent<v8::FunctionTemplate> ${className}_raw_cache_;
    1405   if (${className}_raw_cache_.IsEmpty()) {
    1406     v8::HandleScope scope;
    1407     v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New(V8Proxy::checkNewLegal);
    1408     ${className}_raw_cache_ = v8::Persistent<v8::FunctionTemplate>::New(result);
    1409   }
     1401  static v8::Persistent<v8::FunctionTemplate> ${className}_raw_cache_ = createRawTemplate();
    14101402  return ${className}_raw_cache_;
    14111403}
    14121404
    14131405v8::Persistent<v8::FunctionTemplate> ${className}::GetTemplate() {
    1414   static v8::Persistent<v8::FunctionTemplate> ${className}_cache_;
    1415   if (${className}_cache_.IsEmpty())
    1416     ${className}_cache_ = Configure${className}Template(GetRawTemplate());
     1406  static v8::Persistent<v8::FunctionTemplate> ${className}_cache_ = Configure${className}Template(GetRawTemplate());
    14171407  return ${className}_cache_;
    14181408}
    … …  
    16211611
    16221612    my $type = $codeGenerator->StripModule($signature->type);
    1623     if (($type eq "DOMString") && $signature->extendedAttributes->{"HintAtomic"}) {
     1613    if (($type eq "DOMString") && ($signature->extendedAttributes->{"HintAtomic"} || $signature->extendedAttributes->{"Reflect"})) {
    16241614        $type = "AtomicString";
    16251615    }
    … …  
    19141904
    19151905    if ($type eq "AtomicString") {
    1916         return "v8ValueToAtomicWebCoreStringWithNullCheck($value)" if $signature->extendedAttributes->{"ConvertNullToNullString"};
     1906        return "toAtomicWebCoreStringWithNullCheck($value)" if $signature->extendedAttributes->{"ConvertNullToNullString"};
    19171907        return "v8ValueToAtomicWebCoreString($value)";
    19181908    }
    19191909
    1920     return "toWebCoreString($value)" if $type eq "DOMUserData";
     1910    if ($type eq "DOMUserData") {
     1911        return "toWebCoreString(args, $1)" if $value =~ /args\[(\d+)]/;
     1912        return "toWebCoreString($value)";
     1913    }
    19211914    if ($type eq "DOMString") {
    19221915        return "toWebCoreStringWithNullCheck($value)" if $signature->extendedAttributes->{"ConvertNullToNullString"};
    19231916        return "toWebCoreStringWithNullOrUndefinedCheck($value)" if $signature->extendedAttributes->{"ConvertUndefinedOrNullToNullString"};
     1917       
     1918        return "toWebCoreString(args, $1)" if $value =~ /args\[(\d+)]/;
    19241919        return "toWebCoreString($value)";
    19251920    }
    … …  
    19481943
    19491944        # EventTarget is not in DOM hierarchy, but all Nodes are EventTarget.
    1950         return "V8Node::HasInstance($value) ? V8DOMWrapper::convertDOMWrapperToNode<Node>(v8::Handle<v8::Object>::Cast($value)) : 0";
     1945        return "V8Node::HasInstance($value) ? v8DOMWrapperToNode<Node>(v8::Handle<v8::Object>::Cast($value)) : 0";
    19511946    }
    19521947
    … …  
    19631958        # Perform type checks on the parameter, if it is expected Node type,
    19641959        # return NULL.
    1965         return "V8${type}::HasInstance($value) ? V8DOMWrapper::convertDOMWrapperToNode<${type}>(v8::Handle<v8::Object>::Cast($value)) : 0";
     1960        return "V8${type}::HasInstance($value) ? v8DOMWrapperToNode<${type}>(v8::Handle<v8::Object>::Cast($value)) : 0";
    19661961    } else {
    19671962        # TODO: Temporary to avoid Window name conflict.
    … …  
    19821977        # Perform type checks on the parameter, if it is expected Node type,
    19831978        # return NULL.
    1984         return "V8${type}::HasInstance($value) ? V8DOMWrapper::convertToNativeObject<${implClassName}>(V8ClassIndex::${classIndex}, v8::Handle<v8::Object>::Cast($value)) : 0";
     1979        return "V8${type}::HasInstance($value) ? v8DOMWrapperTo<${implClassName}>(V8ClassIndex::${classIndex}, v8::Handle<v8::Object>::Cast($value)) : 0";
    19851980    }
    19861981}
    … …  
    21152110
    21162111    return "return v8::Date::New(static_cast<double>($value))" if $type eq "DOMTimeStamp";
    2117     return "return $value ? v8::True() : v8::False()" if $type eq "boolean";
    2118     return "return v8::Handle<v8::Value>()" if $type eq "void";
     2112    return "return v8Boolean($value)" if $type eq "boolean";
     2113    return "return v8::Handle<v8::Value>()" if $type eq "void";     # equivalent to v8::Undefined()
    21192114
    21202115    # For all the types where we use 'int' as the representation type,

  • trunk/WebCore/bindings/v8/V8Binding.cpp

    r48305 r50846  
    129129};
    130130
    131 enum ExternalMode {
    132     Externalize,
    133     DoNotExternalize
    134 };
     131
     132void* v8DOMWrapperToNative(v8::Handle<v8::Object> object) {
     133    return object->GetPointerFromInternalField(V8Custom::kDOMWrapperObjectIndex);
     134}
     135   
     136void* v8DOMWrapperToNative(const v8::AccessorInfo& info) {
     137    return info.Holder()->GetPointerFromInternalField(V8Custom::kDOMWrapperObjectIndex);
     138}
     139   
     140
     141String v8ValueToWebCoreString(v8::Handle<v8::Value> value)
     142{
     143    if (value->IsString())
     144        return v8StringToWebCoreString(v8::Handle<v8::String>::Cast(value));
     145    return v8NonStringValueToWebCoreString(value);
     146}
     147
     148AtomicString v8ValueToAtomicWebCoreString(v8::Handle<v8::Value> value)
     149{
     150    if (value->IsString())
     151        return v8StringToAtomicWebCoreString(v8::Handle<v8::String>::Cast(value));
     152    return v8NonStringValueToAtomicWebCoreString(value);
     153}
     154
     155int toInt32(v8::Handle<v8::Value> value, bool& ok)
     156{
     157    ok = true;
     158   
     159    // Fast case.  The value is already a 32-bit integer.
     160    if (value->IsInt32())
     161        return value->Int32Value();
     162   
     163    // Can the value be converted to a number?
     164    v8::Local<v8::Number> numberObject = value->ToNumber();
     165    if (numberObject.IsEmpty()) {
     166        ok = false;
     167        return 0;
     168    }
     169   
     170    // Does the value convert to nan or to an infinity?
     171    double numberValue = numberObject->Value();
     172    if (isnan(numberValue) || isinf(numberValue)) {
     173        ok = false;
     174        return 0;
     175    }
     176   
     177    // Can the value be converted to a 32-bit integer?
     178    v8::Local<v8::Int32> intValue = value->ToInt32();
     179    if (intValue.IsEmpty()) {
     180        ok = false;
     181        return 0;
     182    }
     183   
     184    // Return the result of the int32 conversion.
     185    return intValue->Value();
     186}
     187   
     188String toWebCoreString(const v8::Arguments& args, int index) {
     189    return v8ValueToWebCoreString(args[index]);
     190}
     191
     192   
     193String toWebCoreStringWithNullCheck(v8::Handle<v8::Value> value)
     194{
     195    if (value->IsNull())
     196        return String();
     197    return v8ValueToWebCoreString(value);
     198}
     199
     200AtomicString toAtomicWebCoreStringWithNullCheck(v8::Handle<v8::Value> value)
     201{
     202    if (value->IsNull())
     203        return AtomicString();
     204    return v8ValueToAtomicWebCoreString(value);
     205}
     206
     207String toWebCoreStringWithNullOrUndefinedCheck(v8::Handle<v8::Value> value)
     208{
     209    if (value->IsNull() || value->IsUndefined())
     210        return String();
     211    return toWebCoreString(value);
     212}
     213
     214bool isUndefinedOrNull(v8::Handle<v8::Value> value)
     215{
     216    return value->IsNull() || value->IsUndefined();
     217}
     218
     219v8::Handle<v8::Boolean> v8Boolean(bool value)
     220{
     221    return value ? v8::True() : v8::False();
     222}
     223
     224v8::Handle<v8::String> v8UndetectableString(const String& str)
     225{
     226    return v8::String::NewUndetectable(fromWebCoreString(str), str.length());
     227}
     228
     229v8::Handle<v8::Value> v8StringOrNull(const String& str)
     230{
     231    return str.isNull() ? v8::Handle<v8::Value>(v8::Null()) : v8::Handle<v8::Value>(v8String(str));
     232}
     233
     234v8::Handle<v8::Value> v8StringOrUndefined(const String& str)
     235{
     236    return str.isNull() ? v8::Handle<v8::Value>(v8::Undefined()) : v8::Handle<v8::Value>(v8String(str));
     237}
     238
     239v8::Handle<v8::Value> v8StringOrFalse(const String& str)
     240{
     241    return str.isNull() ? v8::Handle<v8::Value>(v8::False()) : v8::Handle<v8::Value>(v8String(str));
     242}
     243
    135244
    136245template <typename StringType>
    137 static StringType v8StringToWebCoreString(v8::Handle<v8::String> v8String, ExternalMode external)
     246StringType v8StringToWebCoreString(v8::Handle<v8::String> v8String, ExternalMode external)
    138247{
    139248    WebCoreStringResource* stringResource = WebCoreStringResource::toStringResource(v8String);
    … …  
    168277    }
    169278    return result;
    170 }
    171 
    172 String v8StringToWebCoreString(v8::Handle<v8::String> v8String)
    173 {
    174     return v8StringToWebCoreString<String>(v8String, Externalize);
    175 }
    176 
    177 AtomicString v8StringToAtomicWebCoreString(v8::Handle<v8::String> v8String)
    178 {
    179     return v8StringToWebCoreString<AtomicString>(v8String, Externalize);
    180279}
    181280
    … …  
    255354v8::Local<v8::String> v8ExternalString(const String& string)
    256355{
    257     if (!string.length())
     356    StringImpl* stringImpl = string.impl();
     357    if (!stringImpl || !stringImpl->length())
    258358        return v8::String::Empty();
    259359
    … …  
    261361        return makeExternalString(string);
    262362
    263     StringImpl* stringImpl = string.impl();
    264363    StringCache& stringCache = getStringCache();
    265364    v8::String* cachedV8String = stringCache.get(stringImpl);
    … …  
    281380    return newString;
    282381}
     382   
     383v8::Persistent<v8::FunctionTemplate> createRawTemplate()
     384{
     385    v8::HandleScope scope;
     386    v8::Local<v8::FunctionTemplate> result = v8::FunctionTemplate::New(V8Proxy::checkNewLegal);
     387    return v8::Persistent<v8::FunctionTemplate>::New(result);
     388}       
    283389
    284390} // namespace WebCore

  • trunk/WebCore/bindings/v8/V8Binding.h

    r49890 r50846  
    3535#include "MathExtras.h"
    3636#include "PlatformString.h"
     37#include "V8DOMWrapper.h"
     38#include "V8Index.h"
    3739
    3840#include <v8.h>
    3941
    4042namespace WebCore {
     43   
     44    class EventListener;
     45    class EventTarget;
     46   
     47    // A helper function extract native object pointer from a DOM wrapper
     48    // and cast to the specified type.
     49    void* v8DOMWrapperToNative(v8::Handle<v8::Object>);
     50   
     51    template <class C>
     52    C* v8DOMWrapperTo(v8::Handle<v8::Object> object)
     53    {
     54        ASSERT(V8DOMWrapper::maybeDOMWrapper(object));
     55        return reinterpret_cast<C*>(v8DOMWrapperToNative(object));
     56    }
     57    template <class C>
     58    C* v8DOMWrapperToNode(v8::Handle<v8::Object> object)
     59    {
     60        ASSERT(V8DOMWrapper::maybeDOMWrapper(object));
     61        ASSERT(V8DOMWrapper::domWrapperType(object) == V8ClassIndex::NODE);
     62        return reinterpret_cast<C*>(v8DOMWrapperToNative(object));
     63    }
     64   
     65    void* v8DOMWrapperToNative(const v8::AccessorInfo&);
     66   
     67    template <class C>
     68    C* v8DOMWrapperTo(const v8::AccessorInfo& info) {
     69        ASSERT(V8DOMWrapper::maybeDOMWrapper(info.Holder()));
     70        return reinterpret_cast<C*>(v8DOMWrapperToNative(info));
     71    }
     72    template <class C>
     73    C* v8DOMWrapperToNode(const v8::AccessorInfo& info) {
     74        ASSERT(V8DOMWrapper::domWrapperType(info.Holder()) == V8ClassIndex::NODE);
     75        return reinterpret_cast<C*>(v8DOMWrapperToNative(info));
     76    }
     77   
     78    template <class C>
     79    C* v8DOMWrapperTo(V8ClassIndex::V8WrapperType type, v8::Handle<v8::Object> object)
     80    {
     81        // Native event listener is per frame, it cannot be handled by this generic function.
     82        ASSERT(type != V8ClassIndex::EVENTLISTENER);
     83        ASSERT(type != V8ClassIndex::EVENTTARGET);
     84       
     85        ASSERT(V8DOMWrapper::maybeDOMWrapper(object));
     86       
     87#ifndef NDEBUG
     88        const bool typeIsValid =
     89#define MAKE_CASE(TYPE, NAME) (type != V8ClassIndex::TYPE) &&
     90        DOM_NODE_TYPES(MAKE_CASE)
     91#if ENABLE(SVG)
     92        SVG_NODE_TYPES(MAKE_CASE)
     93#endif
     94#undef MAKE_CASE
     95        true;
     96        ASSERT(typeIsValid);
     97#endif
     98       
     99        return v8DOMWrapperTo<C>(object);
     100    }
     101   
     102    template <class C>
     103    C* v8DOMWrapperTo(V8ClassIndex::V8WrapperType type, const v8::AccessorInfo& info)
     104    {
     105#ifndef NDEBUG
     106        return v8DOMWrapperTo<C>(type, info.Holder());
     107#else
     108        return reinterpret_cast<C*>(v8DOMWrapperToNative(info));
     109#endif
     110    }
     111
     112   
     113    enum ExternalMode {
     114        Externalize,
     115        DoNotExternalize
     116    };
     117   
     118    template <typename StringType>
     119    StringType v8StringToWebCoreString(v8::Handle<v8::String> v8String, ExternalMode external);
    41120
    42121    // Convert v8 types to a WebCore::String. If the V8 string is not already
    43122    // an external string then it is transformed into an external string at this
    44123    // point to avoid repeated conversions.
    45     String v8StringToWebCoreString(v8::Handle<v8::String>);
     124    inline String v8StringToWebCoreString(v8::Handle<v8::String> v8String)
     125    {
     126        return v8StringToWebCoreString<String>(v8String, Externalize);
     127    }
    46128    String v8NonStringValueToWebCoreString(v8::Handle<v8::Value>);
    47     inline String v8ValueToWebCoreString(v8::Handle<v8::Value> value)
    48     {
    49         if (value->IsString())
    50             return v8StringToWebCoreString(v8::Handle<v8::String>::Cast(value));
    51         return v8NonStringValueToWebCoreString(value);
    52     }
     129    String v8ValueToWebCoreString(v8::Handle<v8::Value> value);
    53130
    54131    // Convert v8 types to a WebCore::AtomicString.
    55     AtomicString v8StringToAtomicWebCoreString(v8::Handle<v8::String>);
     132    inline AtomicString v8StringToAtomicWebCoreString(v8::Handle<v8::String> v8String)
     133    {
     134        return v8StringToWebCoreString<AtomicString>(v8String, Externalize);
     135    }
    56136    AtomicString v8NonStringValueToAtomicWebCoreString(v8::Handle<v8::Value>);
    57     inline AtomicString v8ValueToAtomicWebCoreString(v8::Handle<v8::Value> value)
    58     {
    59         if (value->IsString())
    60             return v8StringToAtomicWebCoreString(v8::Handle<v8::String>::Cast(value));
    61         return v8NonStringValueToAtomicWebCoreString(value);
    62     }
    63 
    64     inline const String& toString(const String& string)
    65     {
    66         return string;
    67     }
     137    AtomicString v8ValueToAtomicWebCoreString(v8::Handle<v8::Value> value);
    68138
    69139    // Return a V8 external string that shares the underlying buffer with the given
    … …  
    85155    // Convert a value to a 32-bit integer.  The conversion fails if the
    86156    // value cannot be converted to an integer or converts to nan or to an infinity.
    87     inline int toInt32(v8::Handle<v8::Value> value, bool& ok)
    88     {
    89         ok = true;
    90 
    91         // Fast case.  The value is already a 32-bit integer.
    92         if (value->IsInt32())
    93             return value->Int32Value();
    94 
    95         // Can the value be converted to a number?
    96         v8::Local<v8::Number> numberObject = value->ToNumber();
    97         if (numberObject.IsEmpty()) {
    98             ok = false;
    99             return 0;
    100         }
    101 
    102         // Does the value convert to nan or to an infinity?
    103         double numberValue = numberObject->Value();
    104         if (isnan(numberValue) || isinf(numberValue)) {
    105             ok = false;
    106             return 0;
    107         }
    108 
    109         // Can the value be converted to a 32-bit integer?
    110         v8::Local<v8::Int32> intValue = value->ToInt32();
    111         if (intValue.IsEmpty()) {
    112             ok = false;
    113             return 0;
    114         }
    115 
    116         // Return the result of the int32 conversion.
    117         return intValue->Value();
    118     }
     157    int toInt32(v8::Handle<v8::Value> value, bool& ok);
    119158
    120159    // Convert a value to a 32-bit integer assuming the conversion cannot fail.
    … …  
    135174        return v8ValueToWebCoreString(object);
    136175    }
     176   
     177    String toWebCoreString(const v8::Arguments&, int index);
    137178
    138179    // The string returned by this function is still owned by the argument
    … …  
    143184    }
    144185
    145     inline bool isUndefinedOrNull(v8::Handle<v8::Value> value)
    146     {
    147         return value->IsNull() || value->IsUndefined();
    148     }
    149 
    150     inline v8::Handle<v8::Boolean> v8Boolean(bool value)
    151     {
    152         return value ? v8::True() : v8::False();
    153     }
    154 
    155     inline String toWebCoreStringWithNullCheck(v8::Handle<v8::Value> value)
    156     {
    157         if (value->IsNull())
    158             return String();
    159         return v8ValueToWebCoreString(value);
    160     }
    161 
    162     inline AtomicString v8ValueToAtomicWebCoreStringWithNullCheck(v8::Handle<v8::Value> value)
    163     {
    164         if (value->IsNull())
    165             return AtomicString();
    166         return v8ValueToAtomicWebCoreString(value);
    167     }
    168 
    169     inline String toWebCoreStringWithNullOrUndefinedCheck(v8::Handle<v8::Value> value)
    170     {
    171         if (value->IsNull() || value->IsUndefined())
    172             return String();
    173         return toWebCoreString(value);
    174     }
     186    bool isUndefinedOrNull(v8::Handle<v8::Value> value);
     187
     188    v8::Handle<v8::Boolean> v8Boolean(bool value);
     189
     190    String toWebCoreStringWithNullCheck(v8::Handle<v8::Value> value);
     191
     192    AtomicString toAtomicWebCoreStringWithNullCheck(v8::Handle<v8::Value> value);
     193
     194    String toWebCoreStringWithNullOrUndefinedCheck(v8::Handle<v8::Value> value);
    175195 
    176     inline v8::Handle<v8::String> v8UndetectableString(const String& str)
    177     {
    178         return v8::String::NewUndetectable(fromWebCoreString(str), str.length());
    179     }
    180 
    181     inline v8::Handle<v8::Value> v8StringOrNull(const String& str)
    182     {
    183         return str.isNull() ? v8::Handle<v8::Value>(v8::Null()) : v8::Handle<v8::Value>(v8String(str));
    184     }
    185 
    186     inline v8::Handle<v8::Value> v8StringOrUndefined(const String& str)
    187     {
    188         return str.isNull() ? v8::Handle<v8::Value>(v8::Undefined()) : v8::Handle<v8::Value>(v8String(str));
    189     }
    190 
    191     inline v8::Handle<v8::Value> v8StringOrFalse(const String& str)
    192     {
    193         return str.isNull() ? v8::Handle<v8::Value>(v8::False()) : v8::Handle<v8::Value>(v8String(str));
    194     }
     196    v8::Handle<v8::String> v8UndetectableString(const String& str);
     197
     198    v8::Handle<v8::Value> v8StringOrNull(const String& str);
     199
     200    v8::Handle<v8::Value> v8StringOrUndefined(const String& str);
     201
     202    v8::Handle<v8::Value> v8StringOrFalse(const String& str);
     203   
     204    v8::Persistent<v8::FunctionTemplate> createRawTemplate();
     205
    195206} // namespace WebCore
    196207
Note: See TracChangeset for help on using the changeset viewer.