Replace deprecated with non-deprecated V8 APIs

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"
@@ skipping 80 matching lines @@
 void CJS_Value::Detach()
 {
         m_pValue = v8::Handle<v8::Value>();
         m_eType = VT_unknown;
 }
 
 /* ---------------------------------------------------------------------------------------- */
 
 int CJS_Value::ToInt() const
 {
-        return JS_ToInt32(m_pValue);
+        return JS_ToInt32(m_isolate, m_pValue);
 }
 
 bool CJS_Value::ToBool() const
 {
-        return JS_ToBoolean(m_pValue);
+        return JS_ToBoolean(m_isolate, m_pValue);
 }
 
 double CJS_Value::ToDouble() const
 {
-        return JS_ToNumber(m_pValue);
+        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_pValue);
+        v8::Handle<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
 {
-        return JS_ToObject(m_pValue);
+        return JS_ToObject(m_isolate, m_pValue);
 }
 
 CFX_WideString CJS_Value::ToCFXWideString() const
 {
-        return JS_ToString(m_pValue);
+        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
 {
         return m_pValue;
 }
 
 v8::Handle<v8::Array>CJS_Value::ToV8Array() const
 {
         if (IsArrayObject())
-                return v8::Handle<v8::Array>::Cast(JS_ToObject(m_pValue));
+                return v8::Handle<v8::Array>::Cast(JS_ToObject(m_isolate, m_pValue));
         return v8::Handle<v8::Array>();
 }
 
 /* ---------------------------------------------------------------------------------------- */
 
 void CJS_Value::operator =(int iValue)
 {
         m_pValue = JS_NewNumber(m_isolate, iValue);
 
         m_eType = VT_number;
@@ skipping 72 matching lines @@
         m_pValue = JS_NewDate(m_isolate, (double)date);
 
         m_eType = VT_date;
 }
 
 void CJS_Value::operator = (CJS_Value value)
 {
         m_pValue = value.ToV8Value();
 
         m_eType = value.m_eType;
+        m_isolate = value.m_isolate;
 }
 
 /* ---------------------------------------------------------------------------------------- */
 
 FXJSVALUETYPE CJS_Value::GetType() const
 {
         if(m_pValue.IsEmpty()) return VT_unknown;
         if(m_pValue->IsString()) return VT_string;
         if(m_pValue->IsNumber()) return VT_number;
         if(m_pValue->IsBoolean()) return VT_boolean;
@@ skipping 14 matching lines @@
 {
         if(m_pValue.IsEmpty()) return FALSE;
         return m_pValue->IsDate();
 }
 
 //CJS_Value::operator CJS_Array()
 FX_BOOL CJS_Value::ConvertToArray(CJS_Array &array) const
 {
         if (IsArrayObject())
         {
-                array.Attach(JS_ToArray(m_pValue));
+                array.Attach(JS_ToArray(m_isolate, m_pValue));
                 return TRUE;
         }
 
         return FALSE;
 }
 
 FX_BOOL CJS_Value::ConvertToDate(CJS_Date &date) const
 {
 //      if (GetType() == VT_date)
 //      {
@@ skipping 195 matching lines @@
 
 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_GetArrayElemnet(m_pArray,index);
+        v8::Handle<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_pArray, index, value.ToV8Value(), value.GetType());
+        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>()
@@ skipping 27 matching lines @@
         return JS_MakeDate(JS_MakeDay(year,mon,day), JS_MakeTime(hour,min,sec,ms));
 }
 
 CJS_Date::~CJS_Date()
 {
 }
 
 FX_BOOL CJS_Date::IsValidDate()
 {
         if(m_pDate.IsEmpty()) return FALSE;
-        return !JS_PortIsNan(JS_ToNumber(m_pDate));
+        return !JS_PortIsNan(JS_ToNumber(m_isolate, m_pDate));
 }
 
 void CJS_Date::Attach(v8::Handle<v8::Value> pDate)
 {
         m_pDate = pDate;
 }
 
 int CJS_Date::GetYear()
 {
         if (IsValidDate())
-                return JS_GetYearFromTime(JS_LocalTime(JS_ToNumber(m_pDate)));
+                return JS_GetYearFromTime(JS_LocalTime(JS_ToNumber(m_isolate, m_pDate)));
 
         return 0;
 }
 
 void CJS_Date::SetYear(int iYear)
 {
         double date = MakeDate(iYear,GetMonth(),GetDay(),GetHours(),GetMinutes(),GetSeconds(),0);
         JS_ValueCopy(m_pDate, JS_NewDate(m_isolate,date));
 }
 
 int CJS_Date::GetMonth()
 {
         if (IsValidDate())
-                return JS_GetMonthFromTime(JS_LocalTime(JS_ToNumber(m_pDate)));
+                return JS_GetMonthFromTime(JS_LocalTime(JS_ToNumber(m_isolate, m_pDate)));
 
         return 0;
 }
 
 void CJS_Date::SetMonth(int iMonth)
 {
 
         double date = MakeDate(GetYear(),iMonth,GetDay(),GetHours(),GetMinutes(),GetSeconds(),0);
         JS_ValueCopy(m_pDate, JS_NewDate(m_isolate,date));
 
 }
 
 int CJS_Date::GetDay()
 {
         if (IsValidDate())
-                return JS_GetDayFromTime(JS_LocalTime(JS_ToNumber(m_pDate)));
+                return JS_GetDayFromTime(JS_LocalTime(JS_ToNumber(m_isolate, m_pDate)));
 
         return 0;
 }
 
 void CJS_Date::SetDay(int iDay)
 {
 
         double date = MakeDate(GetYear(),GetMonth(),iDay,GetHours(),GetMinutes(),GetSeconds(),0);
         JS_ValueCopy(m_pDate,JS_NewDate(m_isolate,date));
 
 }
 
 int CJS_Date::GetHours()
 {
         if (IsValidDate())
-                return JS_GetHourFromTime(JS_LocalTime(JS_ToNumber(m_pDate)));
+                return JS_GetHourFromTime(JS_LocalTime(JS_ToNumber(m_isolate, m_pDate)));
 
         return 0;
 }
 
 void CJS_Date::SetHours(int iHours)
 {
         double date = MakeDate(GetYear(),GetMonth(),GetDay(),iHours,GetMinutes(),GetSeconds(),0);
         JS_ValueCopy(m_pDate,JS_NewDate(m_isolate,date));
 }
 
 int CJS_Date::GetMinutes()
 {
         if (IsValidDate())
-                return JS_GetMinFromTime(JS_LocalTime(JS_ToNumber(m_pDate)));
+                return JS_GetMinFromTime(JS_LocalTime(JS_ToNumber(m_isolate, m_pDate)));
 
         return 0;
 }
 
 void CJS_Date::SetMinutes(int minutes)
 {
         double date = MakeDate(GetYear(),GetMonth(),GetDay(),GetHours(),minutes,GetSeconds(),0);
         JS_ValueCopy(m_pDate,JS_NewDate(m_isolate,date));
 }
 
 int CJS_Date::GetSeconds()
 {
         if (IsValidDate())
-                return JS_GetSecFromTime(JS_LocalTime(JS_ToNumber(m_pDate)));
+                return JS_GetSecFromTime(JS_LocalTime(JS_ToNumber(m_isolate, m_pDate)));
 
         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>()
 {
         return m_pDate;
 }
 
 CJS_Date::operator double() const
 {
         if(m_pDate.IsEmpty())
                 return 0.0;
-        return JS_ToNumber(m_pDate);
+        return JS_ToNumber(m_isolate, m_pDate);
 }
 
 CFX_WideString CJS_Date::ToString() const
 {
         if(m_pDate.IsEmpty())
                 return L"";
-        return JS_ToString(m_pDate);
+        return JS_ToString(m_isolate, m_pDate);
 }