Replace v8::Handle with v8::Local and v8::Persistent with v8::Global

fpdfsdk/src/javascript/JS_Value.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
  
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "../../include/javascript/JavaScript.h"
 #include "../../include/javascript/JS_Define.h"
 #include "../../include/javascript/JS_Object.h"
 #include "../../include/javascript/JS_Value.h"
 #include "../../include/javascript/Document.h"
 
 /* ---------------------------- CJS_Value ---------------------------- */
 
 CJS_Value::CJS_Value(v8::Isolate* isolate) : m_eType(VT_unknown),m_isolate(isolate)
 {
 }
-CJS_Value::CJS_Value(v8::Isolate* isolate, v8::Handle<v8::Value> pValue,FXJSVALUETYPE t) :
+CJS_Value::CJS_Value(v8::Isolate* isolate, v8::Local<v8::Value> pValue,FXJSVALUETYPE t) :
         m_pValue(pValue), m_eType(t), m_isolate(isolate)
 {
 }
 
 CJS_Value::CJS_Value(v8::Isolate* isolate, const int &iValue):m_isolate(isolate)
 {
         operator =(iValue);
 }
 
 CJS_Value::CJS_Value(v8::Isolate* isolate, const bool &bValue):m_isolate(isolate)
@@ skipping 40 matching lines @@
 
 CJS_Value::CJS_Value(v8::Isolate* isolate, CJS_Array& array):m_isolate(isolate) 
 {
         operator = (array);
 }
 
 CJS_Value::~CJS_Value()
 {
 }
 
-void CJS_Value::Attach(v8::Handle<v8::Value> pValue,FXJSVALUETYPE t)
+void CJS_Value::Attach(v8::Local<v8::Value> pValue,FXJSVALUETYPE t)
 {
         m_pValue = pValue;
         m_eType = t;
 }
 
 void CJS_Value::Attach(CJS_Value *pValue)
 {
         if (pValue)
                 Attach(pValue->ToV8Value(), pValue->GetType());
 }
 
 void CJS_Value::Detach()
 {
-        m_pValue = v8::Handle<v8::Value>();
+        m_pValue = v8::Local<v8::Value>();
         m_eType = VT_unknown;
 }
 
 /* ---------------------------------------------------------------------------------------- */
 
 int CJS_Value::ToInt() const
 {
         return JS_ToInt32(m_isolate, m_pValue);
 }
 
 bool CJS_Value::ToBool() const
 {
         return JS_ToBoolean(m_isolate, m_pValue);
 }
 
 double CJS_Value::ToDouble() const
 {
         return JS_ToNumber(m_isolate, m_pValue);
 }
 
 float CJS_Value::ToFloat() const
 {
         return (float)ToDouble();
 }
 
 CJS_Object* CJS_Value::ToCJSObject() const
 {
-        v8::Handle<v8::Object>  pObj = JS_ToObject(m_isolate, m_pValue);
+        v8::Local<v8::Object>   pObj = JS_ToObject(m_isolate, m_pValue);
         return (CJS_Object*)JS_GetPrivate(m_isolate, pObj);
 }
 
-v8::Handle<v8::Object> CJS_Value::ToV8Object() const
+v8::Local<v8::Object> CJS_Value::ToV8Object() const
 {
         return JS_ToObject(m_isolate, m_pValue);
 }
 
 CFX_WideString CJS_Value::ToCFXWideString() const
 {
         return JS_ToString(m_isolate, m_pValue);
 }
 
 CFX_ByteString CJS_Value::ToCFXByteString() const
 {
         return CFX_ByteString::FromUnicode(ToCFXWideString());
 }
 
-v8::Handle<v8::Value> CJS_Value::ToV8Value() const
+v8::Local<v8::Value> CJS_Value::ToV8Value() const
 {
         return m_pValue;
 }
 
-v8::Handle<v8::Array>CJS_Value::ToV8Array() const
+v8::Local<v8::Array>CJS_Value::ToV8Array() const
 {
         if (IsArrayObject())
-                return v8::Handle<v8::Array>::Cast(JS_ToObject(m_isolate, m_pValue));
-        return v8::Handle<v8::Array>();
+                return v8::Local<v8::Array>::Cast(JS_ToObject(m_isolate, m_pValue));
+        return v8::Local<v8::Array>();
 }
 
 /* ---------------------------------------------------------------------------------------- */
 
 void CJS_Value::operator =(int iValue)
 {
         m_pValue = JS_NewNumber(m_isolate, iValue);
 
         m_eType = VT_number;
 }
@@ skipping 11 matching lines @@
 
         m_eType = VT_number;
 }
 
 void CJS_Value::operator = (float fValue)
 {
         m_pValue = JS_NewNumber(m_isolate,fValue);
         m_eType = VT_number;
 }
 
-void CJS_Value::operator =(v8::Handle<v8::Object> pObj)
+void CJS_Value::operator =(v8::Local<v8::Object> pObj)
 {
 
         m_pValue = JS_NewObject(m_isolate,pObj);
 
         m_eType = VT_fxobject;
 }
 
 void CJS_Value::operator =(CJS_Object * pObj)
 {
         if (pObj)
@@ skipping 22 matching lines @@
         m_eType = VT_null;
 }
 
 void CJS_Value::operator = (FX_LPCSTR pStr)
 {       
         operator = (CFX_WideString::FromLocal(pStr).c_str());
 }
 
 void CJS_Value::operator = (CJS_Array & array)
 {
-        m_pValue = JS_NewObject2(m_isolate,(v8::Handle<v8::Array>)array);
+        m_pValue = JS_NewObject2(m_isolate,(v8::Local<v8::Array>)array);
 
         m_eType = VT_object;
 }
 
 void CJS_Value::operator = (CJS_Date & date)
 {
         m_pValue = JS_NewDate(m_isolate, (double)date);
 
         m_eType = VT_date;
 }
@@ skipping 219 matching lines @@
         ASSERT(m_bIsSetting);
         ConvertToDate(date);
 }
 
 void CJS_PropValue::operator<<(CJS_Date &date)
 {
         ASSERT(!m_bIsSetting);
         CJS_Value::operator=(date);
 }
 
-CJS_PropValue::operator v8::Handle<v8::Value>() const
+CJS_PropValue::operator v8::Local<v8::Value>() const
 {
         return m_pValue;
 }
 
 /* ======================================== CJS_Array ========================================= */
 CJS_Array::CJS_Array(v8::Isolate* isolate):m_isolate(isolate)
 {
 }
 
 CJS_Array::~CJS_Array()
 {               
 }
 
-void CJS_Array::Attach(v8::Handle<v8::Array> pArray)
+void CJS_Array::Attach(v8::Local<v8::Array> pArray)
 {
         m_pArray = pArray;
 }
 
 FX_BOOL CJS_Array::IsAttached()
 {
         return FALSE;
 }
 
 void CJS_Array::GetElement(unsigned index,CJS_Value &value)
 {
         if (m_pArray.IsEmpty())
                 return;
-        v8::Handle<v8::Value>  p = JS_GetArrayElement(m_isolate, m_pArray,index);
+        v8::Local<v8::Value>  p = JS_GetArrayElement(m_isolate, m_pArray,index);
         value.Attach(p,VT_object);
 }
 
 void CJS_Array::SetElement(unsigned index,CJS_Value value)
 {
         if (m_pArray.IsEmpty())
                 m_pArray = JS_NewArray(m_isolate);
 
         JS_PutArrayElement(m_isolate, m_pArray, index, value.ToV8Value(), value.GetType());
 }
 
 int CJS_Array::GetLength()
 {
         if (m_pArray.IsEmpty())
                 return 0;
         return JS_GetArrayLength(m_pArray);
 }
 
-CJS_Array:: operator v8::Handle<v8::Array>()
+CJS_Array:: operator v8::Local<v8::Array>()
 {
         if (m_pArray.IsEmpty())
                 m_pArray = JS_NewArray(m_isolate);
 
         return m_pArray;
 }
 
 /* ======================================== CJS_Date ========================================= */
 
 CJS_Date::CJS_Date(v8::Isolate* isolate) :m_isolate(isolate)
@@ skipping 20 matching lines @@
 CJS_Date::~CJS_Date()
 {
 }
 
 FX_BOOL CJS_Date::IsValidDate()
 {
         if(m_pDate.IsEmpty()) return FALSE;
         return !JS_PortIsNan(JS_ToNumber(m_isolate, m_pDate));
 }
 
-void CJS_Date::Attach(v8::Handle<v8::Value> pDate)
+void CJS_Date::Attach(v8::Local<v8::Value> pDate)
 {
         m_pDate = pDate;
 }
 
 int CJS_Date::GetYear()
 {
         if (IsValidDate())
                 return JS_GetYearFromTime(JS_LocalTime(JS_ToNumber(m_isolate, m_pDate)));
 
         return 0;
@@ skipping 72 matching lines @@
 
         return 0;
 }
 
 void CJS_Date::SetSeconds(int seconds)
 {
         double date = MakeDate(GetYear(),GetMonth(),GetDay(),GetHours(),GetMinutes(),seconds,0);
         JS_ValueCopy(m_pDate,JS_NewDate(m_isolate,date));
 }
 
-CJS_Date::operator v8::Handle<v8::Value>()
+CJS_Date::operator v8::Local<v8::Value>()
 {
         return m_pDate;
 }
 
 CJS_Date::operator double() const
 {
         if(m_pDate.IsEmpty())
                 return 0.0;
         return JS_ToNumber(m_isolate, m_pDate);
 }
 
 CFX_WideString CJS_Date::ToString() const
 {
         if(m_pDate.IsEmpty())
                 return L"";
         return JS_ToString(m_isolate, m_pDate);
 }