Replace v8::Handle<> with v8::Local<> in bindings/core/v8/*

Source/bindings/core/v8/V8StringResource.cpp

 /*
  * 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:
  * 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
@@ skipping 17 matching lines @@
 
 #include "bindings/core/v8/V8Binding.h"
 #include "core/inspector/BindingVisitors.h"
 #include "wtf/MainThread.h"
 
 namespace blink {
 
 template<class StringClass> struct StringTraits {
     static const StringClass& fromStringResource(WebCoreStringResourceBase*);
     template <typename V8StringTrait>
-    static StringClass fromV8String(v8::Handle<v8::String>, int);
+    static StringClass fromV8String(v8::Local<v8::String>, int);
 };
 
 template<>
 struct StringTraits<String> {
     static const String& fromStringResource(WebCoreStringResourceBase* resource)
     {
         return resource->webcoreString();
     }
     template <typename V8StringTrait>
-    static String fromV8String(v8::Handle<v8::String>, int);
+    static String fromV8String(v8::Local<v8::String>, int);
 };
 
 template<>
 struct StringTraits<AtomicString> {
     static const AtomicString& fromStringResource(WebCoreStringResourceBase* resource)
     {
         return resource->atomicString();
     }
     template <typename V8StringTrait>
-    static AtomicString fromV8String(v8::Handle<v8::String>, int);
+    static AtomicString fromV8String(v8::Local<v8::String>, int);
 };
 
 struct V8StringTwoBytesTrait {
     typedef UChar CharType;
-    ALWAYS_INLINE static void write(v8::Handle<v8::String> v8String, CharType* buffer, int length)
+    ALWAYS_INLINE static void write(v8::Local<v8::String> v8String, CharType* buffer, int length)
     {
         v8String->Write(reinterpret_cast<uint16_t*>(buffer), 0, length);
     }
 };
 
 struct V8StringOneByteTrait {
     typedef LChar CharType;
-    ALWAYS_INLINE static void write(v8::Handle<v8::String> v8String, CharType* buffer, int length)
+    ALWAYS_INLINE static void write(v8::Local<v8::String> v8String, CharType* buffer, int length)
     {
         v8String->WriteOneByte(buffer, 0, length);
     }
 };
 
 template <typename V8StringTrait>
-String StringTraits<String>::fromV8String(v8::Handle<v8::String> v8String, int length)
+String StringTraits<String>::fromV8String(v8::Local<v8::String> v8String, int length)
 {
     ASSERT(v8String->Length() == length);
     typename V8StringTrait::CharType* buffer;
     String result = String::createUninitialized(length, buffer);
     V8StringTrait::write(v8String, buffer, length);
     return result;
 }
 
 template <typename V8StringTrait>
-AtomicString StringTraits<AtomicString>::fromV8String(v8::Handle<v8::String> v8String, int length)
+AtomicString StringTraits<AtomicString>::fromV8String(v8::Local<v8::String> v8String, int length)
 {
     ASSERT(v8String->Length() == length);
     static const int inlineBufferSize = 32 / sizeof(typename V8StringTrait::CharType);
     if (length <= inlineBufferSize) {
         typename V8StringTrait::CharType inlineBuffer[inlineBufferSize];
         V8StringTrait::write(v8String, inlineBuffer, length);
         return AtomicString(inlineBuffer, length);
     }
     typename V8StringTrait::CharType* buffer;
     String string = String::createUninitialized(length, buffer);
     V8StringTrait::write(v8String, buffer, length);
     return AtomicString(string);
 }
 
 template<typename StringType>
-StringType v8StringToWebCoreString(v8::Handle<v8::String> v8String, ExternalMode external)
+StringType v8StringToWebCoreString(v8::Local<v8::String> v8String, ExternalMode external)
 {
     {
         // This portion of this function is very hot in certain Dromeao benchmarks.
         v8::String::Encoding encoding;
         v8::String::ExternalStringResourceBase* resource = v8String->GetExternalStringResourceBase(&encoding);
         if (LIKELY(!!resource)) {
             WebCoreStringResourceBase* base;
             if (encoding == v8::String::ONE_BYTE_ENCODING)
                 base = static_cast<WebCoreStringResource8*>(resource);
             else
@@ skipping 19 matching lines @@
     } else {
         WebCoreStringResource16* stringResource = new WebCoreStringResource16(result);
         if (UNLIKELY(!v8String->MakeExternal(stringResource)))
             delete stringResource;
     }
     return result;
 }
 
 // Explicitly instantiate the above template with the expected parameterizations,
 // to ensure the compiler generates the code; otherwise link errors can result in GCC 4.4.
-template String v8StringToWebCoreString<String>(v8::Handle<v8::String>, ExternalMode);
-template AtomicString v8StringToWebCoreString<AtomicString>(v8::Handle<v8::String>, ExternalMode);
+template String v8StringToWebCoreString<String>(v8::Local<v8::String>, ExternalMode);
+template AtomicString v8StringToWebCoreString<AtomicString>(v8::Local<v8::String>, ExternalMode);
 
 // Fast but non thread-safe version.
 String int32ToWebCoreStringFast(int value)
 {
     // Caching of small strings below is not thread safe: newly constructed AtomicString
     // are not safely published.
     ASSERT(isMainThread());
 
     // Most numbers used are <= 100. Even if they aren't used there's very little cost in using the space.
     const int kLowNumbers = 100;
@@ skipping 14 matching lines @@
 
 String int32ToWebCoreString(int value)
 {
     // If we are on the main thread (this should always true for non-workers), call the faster one.
     if (isMainThread())
         return int32ToWebCoreStringFast(value);
     return String::number(value);
 }
 
 } // namespace blink