[Inspector] Deprecate usage of v8::Handle with v8::Local as replacement.

Source/core/inspector/PromiseTracker.cpp

 // 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.
 
 #include "config.h"
 #include "core/inspector/PromiseTracker.h"
 
 #include "bindings/core/v8/ScopedPersistent.h"
 #include "bindings/core/v8/ScriptCallStackFactory.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/WeakPtr.h"
 
 using blink::TypeBuilder::Array;
 using blink::TypeBuilder::Console::CallFrame;
 using blink::TypeBuilder::Debugger::PromiseDetails;
 
 namespace blink {
 
 class PromiseTracker::PromiseData final : public RefCountedWillBeGarbageCollectedFinalized<PromiseData> {
 public:
-    static PassRefPtrWillBeRawPtr<PromiseData> create(ScriptState* scriptState, int promiseHash, int promiseId, v8::Handle<v8::Object> promise)
+    static PassRefPtrWillBeRawPtr<PromiseData> create(ScriptState* scriptState, int promiseHash, int promiseId, v8::Local<v8::Object> promise)
     {
         return adoptRefWillBeNoop(new PromiseData(scriptState, promiseHash, promiseId, promise));
     }
 
     int promiseHash() const { return m_promiseHash; }
     int promiseId() const { return m_promiseId; }
     ScopedPersistent<v8::Object>& promise() { return m_promise; }
 
 #if ENABLE(OILPAN)
     void dispose()
     {
         m_promise.clear();
         m_parentPromise.clear();
     }
 #else
     WeakPtr<PromiseData> createWeakPtr()
     {
         return m_weakPtrFactory.createWeakPtr();
     }
 #endif
 
     void trace(Visitor* visitor)
     {
         visitor->trace(m_callStack);
     }
 
 private:
     friend class PromiseTracker;
 
-    PromiseData(ScriptState* scriptState, int promiseHash, int promiseId, v8::Handle<v8::Object> promise)
+    PromiseData(ScriptState* scriptState, int promiseHash, int promiseId, v8::Local<v8::Object> promise)
         : m_scriptState(scriptState)
         , m_promiseHash(promiseHash)
         , m_promiseId(promiseId)
         , m_promise(scriptState->isolate(), promise)
         , m_parentPromiseId(0)
         , m_status(0)
         , m_creationTime(0)
         , m_settlementTime(0)
 #if !ENABLE(OILPAN)
         , m_weakPtrFactory(this)
@@ skipping 130 matching lines @@
 }
 
 int PromiseTracker::circularSequentialId()
 {
     ++m_circularSequentialId;
     if (m_circularSequentialId <= 0)
         m_circularSequentialId = 1;
     return m_circularSequentialId;
 }
 
-PassRefPtrWillBeRawPtr<PromiseTracker::PromiseData> PromiseTracker::createPromiseDataIfNeeded(ScriptState* scriptState, v8::Handle<v8::Object> promise)
+PassRefPtrWillBeRawPtr<PromiseTracker::PromiseData> PromiseTracker::createPromiseDataIfNeeded(ScriptState* scriptState, v8::Local<v8::Object> promise)
 {
     int promiseHash = promise->GetIdentityHash();
     RawPtr<PromiseDataVector> vector = nullptr;
     PromiseDataMap::iterator it = m_promiseDataMap.find(promiseHash);
     if (it != m_promiseDataMap.end()) {
         vector = &it->value;
         int index = indexOf(vector, ScopedPersistent<v8::Object>(scriptState->isolate(), promise));
         if (index != -1)
             return vector->at(index);
     } else {
@@ skipping 12 matching lines @@
     OwnPtr<PromiseDataWrapper> wrapper = dataWrapper.release();
 #endif
     data->m_promise.setWeak(wrapper.leakPtr(), &PromiseDataWrapper::didRemovePromise);
     vector->append(data);
 
     m_promiseIdToDataMap.set(promiseId, data);
 
     return data.release();
 }
 
-void PromiseTracker::didReceiveV8PromiseEvent(ScriptState* scriptState, v8::Handle<v8::Object> promise, v8::Handle<v8::Value> parentPromise, int status)
+void PromiseTracker::didReceiveV8PromiseEvent(ScriptState* scriptState, v8::Local<v8::Object> promise, v8::Local<v8::Value> parentPromise, int status)
 {
     ASSERT(isEnabled());
 
     RefPtrWillBeRawPtr<PromiseData> data = createPromiseDataIfNeeded(scriptState, promise);
     if (!parentPromise.IsEmpty() && parentPromise->IsObject()) {
-        v8::Handle<v8::Object> handle = parentPromise->ToObject(scriptState->isolate());
+        v8::Local<v8::Object> handle = parentPromise->ToObject(scriptState->isolate());
         RefPtrWillBeRawPtr<PromiseData> parentData = createPromiseDataIfNeeded(scriptState, handle);
         data->m_parentPromiseId = parentData->m_promiseId;
         data->m_parentPromise.set(scriptState->isolate(), handle);
     } else {
         ASSERT(!data->m_status);
         data->m_status = status;
         if (!status) {
             if (!data->m_creationTime)
                 data->m_creationTime = currentTimeMS();
             if (!data->m_callStack) {
@@ skipping 49 matching lines @@
     if (it == m_promiseIdToDataMap.end())
         return ScriptValue();
     RefPtrWillBeRawPtr<PromiseData> data = it->value;
     ASSERT(data && data->m_promiseId == promiseId);
     ScriptState* scriptState = data->m_scriptState.get();
     v8::HandleScope scope(scriptState->isolate());
     return ScriptValue(scriptState, data->m_promise.newLocal(scriptState->isolate()));
 }
 
 } // namespace blink