Use Local<> instead of Handle<>

Source/bindings/core/v8/DOMWrapperWorld.h

 /*
  * 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
@@ skipping 50 matching lines @@
 
     static const int mainWorldExtensionGroup = 0;
     static const int privateScriptIsolatedWorldExtensionGroup = 1;
     static PassRefPtr<DOMWrapperWorld> ensureIsolatedWorld(v8::Isolate*, int worldId, int extensionGroup);
     ~DOMWrapperWorld();
     void dispose();
 
     static bool isolatedWorldsExist() { return isolatedWorldCount; }
     static void allWorldsInMainThread(Vector<RefPtr<DOMWrapperWorld>>& worlds);
 
-    static DOMWrapperWorld& world(v8::Handle<v8::Context> context)
+    static DOMWrapperWorld& world(v8::Local<v8::Context> context)
     {
         return ScriptState::from(context)->world();
     }
 
     static DOMWrapperWorld& current(v8::Isolate* isolate)
     {
         if (isMainThread() && worldOfInitializingWindow) {
             // It's possible that current() is being called while window is being initialized.
             // In order to make current() workable during the initialization phase,
             // we cache the world of the initializing window on worldOfInitializingWindow.
@@ skipping 37 matching lines @@
 
     static void setWorldOfInitializingWindow(DOMWrapperWorld* world)
     {
         ASSERT(isMainThread());
         worldOfInitializingWindow = world;
     }
 
 private:
     class DOMObjectHolderBase {
     public:
-        DOMObjectHolderBase(v8::Isolate* isolate, v8::Handle<v8::Value> wrapper)
+        DOMObjectHolderBase(v8::Isolate* isolate, v8::Local<v8::Value> wrapper)
             : m_wrapper(isolate, wrapper)
             , m_world(0)
         {
         }
         virtual ~DOMObjectHolderBase() { }
 
         DOMWrapperWorld* world() const { return m_world; }
         void setWorld(DOMWrapperWorld* world) { m_world = world; }
         void setWeak(void (*callback)(const v8::WeakCallbackInfo<DOMObjectHolderBase>&))
         {
             m_wrapper.setWeak(this, callback);
         }
 
     private:
         ScopedPersistent<v8::Value> m_wrapper;
         DOMWrapperWorld* m_world;
     };
 
     template<typename T>
     class DOMObjectHolder : public DOMObjectHolderBase {
     public:
-        static PassOwnPtr<DOMObjectHolder<T>> create(v8::Isolate* isolate, T* object, v8::Handle<v8::Value> wrapper)
+        static PassOwnPtr<DOMObjectHolder<T>> create(v8::Isolate* isolate, T* object, v8::Local<v8::Value> wrapper)
         {
             return adoptPtr(new DOMObjectHolder(isolate, object, wrapper));
         }
 
     private:
-        DOMObjectHolder(v8::Isolate* isolate, T* object, v8::Handle<v8::Value> wrapper)
+        DOMObjectHolder(v8::Isolate* isolate, T* object, v8::Local<v8::Value> wrapper)
             : DOMObjectHolderBase(isolate, wrapper)
             , m_object(object)
         {
         }
 
         Persistent<T> m_object;
     };
 
 public:
     template<typename T>
-    void registerDOMObjectHolder(v8::Isolate* isolate, T* object, v8::Handle<v8::Value> wrapper)
+    void registerDOMObjectHolder(v8::Isolate* isolate, T* object, v8::Local<v8::Value> wrapper)
     {
         registerDOMObjectHolderInternal(DOMObjectHolder<T>::create(isolate, object, wrapper));
     }
 
 private:
     DOMWrapperWorld(v8::Isolate*, int worldId, int extensionGroup);
 
     static void weakCallbackForDOMObjectHolder(const v8::WeakCallbackInfo<DOMObjectHolderBase>&);
     void registerDOMObjectHolderInternal(PassOwnPtr<DOMObjectHolderBase>);
     void unregisterDOMObjectHolder(DOMObjectHolderBase*);
 
     static unsigned isolatedWorldCount;
     static DOMWrapperWorld* worldOfInitializingWindow;
 
     const int m_worldId;
     const int m_extensionGroup;
     OwnPtr<DOMDataStore> m_domDataStore;
     HashSet<OwnPtr<DOMObjectHolderBase>> m_domObjectHolders;
 };
 
 } // namespace blink
 
 #endif // DOMWrapperWorld_h