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

Source/bindings/core/v8/ScriptState.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef ScriptState_h
 #define ScriptState_h
 
 #include "bindings/core/v8/ScopedPersistent.h"
 #include "bindings/core/v8/V8PerContextData.h"
 #include "core/CoreExport.h"
@@ skipping 26 matching lines @@
             m_context->Enter();
         }
 
         ~Scope()
         {
             m_context->Exit();
         }
 
     private:
         v8::HandleScope m_handleScope;
-        v8::Handle<v8::Context> m_context;
+        v8::Local<v8::Context> m_context;
     };
 
-    static PassRefPtr<ScriptState> create(v8::Handle<v8::Context>, PassRefPtr<DOMWrapperWorld>);
+    static PassRefPtr<ScriptState> create(v8::Local<v8::Context>, PassRefPtr<DOMWrapperWorld>);
     virtual ~ScriptState();
 
     static ScriptState* current(v8::Isolate* isolate)
     {
         return from(isolate->GetCurrentContext());
     }
 
-    static ScriptState* from(v8::Handle<v8::Context> context)
+    static ScriptState* from(v8::Local<v8::Context> context)
     {
         ASSERT(!context.IsEmpty());
         ScriptState* scriptState = static_cast<ScriptState*>(context->GetAlignedPointerFromEmbedderData(v8ContextPerContextDataIndex));
         // ScriptState::from() must not be called for a context that does not have
         // valid embedder data in the embedder field.
         RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(scriptState);
         RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(scriptState->context() == context);
         return scriptState;
     }
 
     static ScriptState* forMainWorld(LocalFrame*);
 
     v8::Isolate* isolate() const { return m_isolate; }
     DOMWrapperWorld& world() const { return *m_world; }
     LocalDOMWindow* domWindow() const;
     virtual ExecutionContext* executionContext() const;
     virtual void setExecutionContext(ExecutionContext*);
 
     // This can return an empty handle if the v8::Context is gone.
-    v8::Handle<v8::Context> context() const { return m_context.newLocal(m_isolate); }
+    v8::Local<v8::Context> context() const { return m_context.newLocal(m_isolate); }
     bool contextIsValid() const { return !m_context.isEmpty() && m_perContextData; }
     void detachGlobalObject();
     void clearContext() { return m_context.clear(); }
 #if ENABLE(ASSERT)
     bool isGlobalObjectDetached() const { return m_globalObjectDetached; }
 #endif
 
     V8PerContextData* perContextData() const { return m_perContextData.get(); }
     void disposePerContextData();
 
     class Observer {
     public:
         virtual ~Observer() { }
         virtual void willDisposeScriptState(ScriptState*) = 0;
     };
     void addObserver(Observer*);
     void removeObserver(Observer*);
 
     bool evalEnabled() const;
     void setEvalEnabled(bool);
     ScriptValue getFromGlobalObject(const char* name);
 
 protected:
-    ScriptState(v8::Handle<v8::Context>, PassRefPtr<DOMWrapperWorld>);
+    ScriptState(v8::Local<v8::Context>, PassRefPtr<DOMWrapperWorld>);
 
 private:
     v8::Isolate* m_isolate;
     // This persistent handle is weak.
     ScopedPersistent<v8::Context> m_context;
 
     // This RefPtr doesn't cause a cycle because all persistent handles that DOMWrapperWorld holds are weak.
     RefPtr<DOMWrapperWorld> m_world;
 
     // This OwnPtr causes a cycle:
@@ skipping 29 matching lines @@
     }
 
 private:
     RefPtr<ScriptState> m_scriptState;
     ScopedPersistent<v8::Context> m_context;
 };
 
 }
 
 #endif // ScriptState_h