Remove FX_BOOL from fpdfsdk.

fpdfsdk/javascript/global.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 "fpdfsdk/javascript/global.h"
 
 #include <vector>
 
@@ skipping 21 matching lines @@
 void CJS_Global::InitInstance(IJS_Runtime* pIRuntime) {
   CJS_Runtime* pRuntime = static_cast<CJS_Runtime*>(pIRuntime);
   JSGlobalAlternate* pGlobal =
       static_cast<JSGlobalAlternate*>(GetEmbedObject());
   pGlobal->Initial(pRuntime->GetFormFillEnv());
 }
 
 JSGlobalData::JSGlobalData()
     : nType(JS_GlobalDataType::NUMBER),
       dData(0),
-      bData(FALSE),
+      bData(false),
       sData(""),
-      bPersistent(FALSE),
-      bDeleted(FALSE) {}
+      bPersistent(false),
+      bDeleted(false) {}
 
 JSGlobalData::~JSGlobalData() {
   pData.Reset();
 }
 
 JSGlobalAlternate::JSGlobalAlternate(CJS_Object* pJSObject)
     : CJS_EmbedObj(pJSObject), m_pFormFillEnv(nullptr) {}
 
 JSGlobalAlternate::~JSGlobalAlternate() {
   DestroyGlobalPersisitentVariables();
   m_pGlobalData->Release();
 }
 
 void JSGlobalAlternate::Initial(CPDFSDK_FormFillEnvironment* pFormFillEnv) {
   m_pFormFillEnv = pFormFillEnv;
   m_pGlobalData = CJS_GlobalData::GetRetainedInstance(pFormFillEnv);
   UpdateGlobalPersistentVariables();
 }
 
-FX_BOOL JSGlobalAlternate::QueryProperty(const FX_WCHAR* propname) {
+bool JSGlobalAlternate::QueryProperty(const FX_WCHAR* propname) {
   return CFX_WideString(propname) != L"setPersistent";
 }
 
-FX_BOOL JSGlobalAlternate::DelProperty(IJS_Context* cc,
-                                       const FX_WCHAR* propname,
-                                       CFX_WideString& sError) {
+bool JSGlobalAlternate::DelProperty(IJS_Context* cc,
+                                    const FX_WCHAR* propname,
+                                    CFX_WideString& sError) {
   auto it = m_mapGlobal.find(CFX_ByteString::FromUnicode(propname));
   if (it == m_mapGlobal.end())
-    return FALSE;
+    return false;
 
-  it->second->bDeleted = TRUE;
-  return TRUE;
+  it->second->bDeleted = true;
+  return true;
 }
 
-FX_BOOL JSGlobalAlternate::DoProperty(IJS_Context* cc,
-                                      const FX_WCHAR* propname,
-                                      CJS_PropValue& vp,
-                                      CFX_WideString& sError) {
+bool JSGlobalAlternate::DoProperty(IJS_Context* cc,
+                                   const FX_WCHAR* propname,
+                                   CJS_PropValue& vp,
+                                   CFX_WideString& sError) {
   CJS_Runtime* pRuntime = CJS_Runtime::FromContext(cc);
   if (vp.IsSetting()) {
     CFX_ByteString sPropName = CFX_ByteString::FromUnicode(propname);
     switch (vp.GetJSValue()->GetType()) {
       case CJS_Value::VT_number: {
         double dData;
         vp >> dData;
         return SetGlobalVariables(sPropName, JS_GlobalDataType::NUMBER, dData,
-                                  false, "", v8::Local<v8::Object>(), FALSE);
+                                  false, "", v8::Local<v8::Object>(), false);
       }
       case CJS_Value::VT_boolean: {
         bool bData;
         vp >> bData;
         return SetGlobalVariables(sPropName, JS_GlobalDataType::BOOLEAN, 0,
-                                  bData, "", v8::Local<v8::Object>(), FALSE);
+                                  bData, "", v8::Local<v8::Object>(), false);
       }
       case CJS_Value::VT_string: {
         CFX_ByteString sData;
         vp >> sData;
         return SetGlobalVariables(sPropName, JS_GlobalDataType::STRING, 0,
-                                  false, sData, v8::Local<v8::Object>(), FALSE);
+                                  false, sData, v8::Local<v8::Object>(), false);
       }
       case CJS_Value::VT_object: {
         v8::Local<v8::Object> pData;
         vp >> pData;
         return SetGlobalVariables(sPropName, JS_GlobalDataType::OBJECT, 0,
-                                  false, "", pData, FALSE);
+                                  false, "", pData, false);
       }
       case CJS_Value::VT_null: {
         return SetGlobalVariables(sPropName, JS_GlobalDataType::NULLOBJ, 0,
-                                  false, "", v8::Local<v8::Object>(), FALSE);
+                                  false, "", v8::Local<v8::Object>(), false);
       }
       case CJS_Value::VT_undefined: {
         DelProperty(cc, propname, sError);
-        return TRUE;
+        return true;
       }
       default:
         break;
     }
   } else {
     auto it = m_mapGlobal.find(CFX_ByteString::FromUnicode(propname));
     if (it == m_mapGlobal.end()) {
       vp.GetJSValue()->SetNull(pRuntime);
-      return TRUE;
+      return true;
     }
     JSGlobalData* pData = it->second;
     if (pData->bDeleted) {
       vp.GetJSValue()->SetNull(pRuntime);
-      return TRUE;
+      return true;
     }
     switch (pData->nType) {
       case JS_GlobalDataType::NUMBER:
         vp << pData->dData;
-        return TRUE;
+        return true;
       case JS_GlobalDataType::BOOLEAN:
         vp << pData->bData;
-        return TRUE;
+        return true;
       case JS_GlobalDataType::STRING:
         vp << pData->sData;
-        return TRUE;
+        return true;
       case JS_GlobalDataType::OBJECT: {
         v8::Local<v8::Object> obj = v8::Local<v8::Object>::New(
             vp.GetJSRuntime()->GetIsolate(), pData->pData);
         vp << obj;
-        return TRUE;
+        return true;
       }
       case JS_GlobalDataType::NULLOBJ:
         vp.GetJSValue()->SetNull(pRuntime);
-        return TRUE;
+        return true;
       default:
         break;
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL JSGlobalAlternate::setPersistent(IJS_Context* cc,
-                                         const std::vector<CJS_Value>& params,
-                                         CJS_Value& vRet,
-                                         CFX_WideString& sError) {
+bool JSGlobalAlternate::setPersistent(IJS_Context* cc,
+                                      const std::vector<CJS_Value>& params,
+                                      CJS_Value& vRet,
+                                      CFX_WideString& sError) {
   if (params.size() != 2) {
     sError = JSGetStringFromID(IDS_STRING_JSPARAMERROR);
-    return FALSE;
+    return false;
   }
 
   CJS_Runtime* pRuntime = CJS_Runtime::FromContext(cc);
   auto it = m_mapGlobal.find(params[0].ToCFXByteString(pRuntime));
   if (it != m_mapGlobal.end()) {
     JSGlobalData* pData = it->second;
     if (!pData->bDeleted) {
       pData->bPersistent = params[1].ToBool(pRuntime);
-      return TRUE;
+      return true;
     }
   }
 
   sError = JSGetStringFromID(IDS_STRING_JSNOGLOBAL);
-  return FALSE;
+  return false;
 }
 
 void JSGlobalAlternate::UpdateGlobalPersistentVariables() {
   CJS_Runtime* pRuntime =
       static_cast<CJS_Runtime*>(CFXJS_Engine::CurrentEngineFromIsolate(
           m_pJSObject->ToV8Object()->GetIsolate()));
 
   for (int i = 0, sz = m_pGlobalData->GetSize(); i < sz; i++) {
     CJS_GlobalData_Element* pData = m_pGlobalData->GetAt(i);
     switch (pData->data.nType) {
@@ skipping 161 matching lines @@
   }
 }
 
 void JSGlobalAlternate::DestroyGlobalPersisitentVariables() {
   for (const auto& pair : m_mapGlobal) {
     delete pair.second;
   }
   m_mapGlobal.clear();
 }
 
-FX_BOOL JSGlobalAlternate::SetGlobalVariables(const CFX_ByteString& propname,
-                                              JS_GlobalDataType nType,
-                                              double dData,
-                                              bool bData,
-                                              const CFX_ByteString& sData,
-                                              v8::Local<v8::Object> pData,
-                                              bool bDefaultPersistent) {
+bool JSGlobalAlternate::SetGlobalVariables(const CFX_ByteString& propname,
+                                           JS_GlobalDataType nType,
+                                           double dData,
+                                           bool bData,
+                                           const CFX_ByteString& sData,
+                                           v8::Local<v8::Object> pData,
+                                           bool bDefaultPersistent) {
   if (propname.IsEmpty())
-    return FALSE;
+    return false;
 
   auto it = m_mapGlobal.find(propname);
   if (it != m_mapGlobal.end()) {
     JSGlobalData* pTemp = it->second;
     if (pTemp->bDeleted || pTemp->nType != nType) {
       pTemp->dData = 0;
       pTemp->bData = 0;
       pTemp->sData = "";
       pTemp->nType = nType;
     }
 
-    pTemp->bDeleted = FALSE;
+    pTemp->bDeleted = false;
     switch (nType) {
       case JS_GlobalDataType::NUMBER: {
         pTemp->dData = dData;
       } break;
       case JS_GlobalDataType::BOOLEAN: {
         pTemp->bData = bData;
       } break;
       case JS_GlobalDataType::STRING: {
         pTemp->sData = sData;
       } break;
       case JS_GlobalDataType::OBJECT: {
         pTemp->pData.Reset(pData->GetIsolate(), pData);
       } break;
       case JS_GlobalDataType::NULLOBJ:
         break;
       default:
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
   }
 
   JSGlobalData* pNewData = nullptr;
 
   switch (nType) {
     case JS_GlobalDataType::NUMBER: {
       pNewData = new JSGlobalData;
       pNewData->nType = JS_GlobalDataType::NUMBER;
       pNewData->dData = dData;
       pNewData->bPersistent = bDefaultPersistent;
@@ skipping 15 matching lines @@
       pNewData->nType = JS_GlobalDataType::OBJECT;
       pNewData->pData.Reset(pData->GetIsolate(), pData);
       pNewData->bPersistent = bDefaultPersistent;
     } break;
     case JS_GlobalDataType::NULLOBJ: {
       pNewData = new JSGlobalData;
       pNewData->nType = JS_GlobalDataType::NULLOBJ;
       pNewData->bPersistent = bDefaultPersistent;
     } break;
     default:
-      return FALSE;
+      return false;
   }
 
   m_mapGlobal[propname] = pNewData;
-  return TRUE;
+  return true;
 }