Convert some methods to std::lower_bound and std::find_if.

xfa/fxfa/parser/xfa_basic_imp.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 "xfa/fxfa/parser/xfa_basic_imp.h"
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
@@ skipping 162 matching lines @@
     return *(CXFA_Measurement*)pValue;
   }
   return CXFA_Measurement();
 }
 
 XFA_Element XFA_GetElementTypeForName(const CFX_WideStringC& wsName) {
   if (wsName.IsEmpty())
     return XFA_Element::Unknown;
 
   uint32_t uHash = FX_HashCode_GetW(wsName, false);
-  int32_t iStart = 0;
-  int32_t iEnd = g_iXFAElementCount - 1;
-  do {
-    int32_t iMid = (iStart + iEnd) / 2;
-    const XFA_ELEMENTINFO* pInfo = g_XFAElementData + iMid;
-    if (uHash == pInfo->uHash)
-      return pInfo->eName;
-    if (uHash < pInfo->uHash)
-      iEnd = iMid - 1;
-    else
-      iStart = iMid + 1;
-  } while (iStart <= iEnd);
+  const XFA_ELEMENTINFO* pEnd = g_XFAElementData + g_iXFAElementCount;
+  auto pInfo = std::lower_bound(g_XFAElementData, pEnd, uHash,
+                                [](const XFA_ELEMENTINFO& info, uint32_t hash) {
+                                  return info.uHash < hash;
+                                });
+  if (pInfo < pEnd && pInfo->uHash == uHash)
+    return pInfo->eName;
   return XFA_Element::Unknown;
 }
+
 const XFA_ELEMENTINFO* XFA_GetElementByID(XFA_Element eName) {
   return eName == XFA_Element::Unknown
              ? nullptr
              : g_XFAElementData + static_cast<int32_t>(eName);
 }
 
 const uint8_t* XFA_GetElementAttributes(XFA_Element eElement, int32_t& iCount) {
   if (eElement == XFA_Element::Unknown)
     return nullptr;
 
@@ skipping 24 matching lines @@
 const XFA_PROPERTY* XFA_GetElementProperties(XFA_Element eElement,
                                              int32_t& iCount) {
   if (eElement == XFA_Element::Unknown)
     return nullptr;
 
   const XFA_ELEMENTHIERARCHY* pElement =
       g_XFAElementPropertyIndex + static_cast<int32_t>(eElement);
   iCount = pElement->wCount;
   return g_XFAElementPropertyData + pElement->wStart;
 }
+
 const XFA_PROPERTY* XFA_GetPropertyOfElement(XFA_Element eElement,
                                              XFA_Element eProperty,
                                              uint32_t dwPacket) {
   int32_t iCount = 0;
-  const XFA_PROPERTY* pProperty = XFA_GetElementProperties(eElement, iCount);
-  if (!pProperty || iCount < 1) {
+  const XFA_PROPERTY* pProperties = XFA_GetElementProperties(eElement, iCount);
+  if (!pProperties || iCount < 1)
     return nullptr;
-  }
-  int32_t iStart = 0, iEnd = iCount - 1, iMid;
-  do {
-    iMid = (iStart + iEnd) / 2;
-    XFA_Element eName = pProperty[iMid].eName;
-    if (eProperty == eName) {
-      break;
-    } else if (eProperty < eName) {
-      iEnd = iMid - 1;
-    } else {
-      iStart = iMid + 1;
-    }
-  } while (iStart <= iEnd);
-  if (iStart > iEnd) {
+
+  auto it = std::find_if(pProperties, pProperties + iCount,

[dsinclair, 2016/06/30 03:40:16]

I'm looking into generating some of these tables. Not having to have this data
in a specific sort order will make that a lot simpler. The number of items
search is small, so I think this shouldn't be a performance issue.

+                         [eProperty](const XFA_PROPERTY& prop) {
+                           return prop.eName == eProperty;
+                         });
+  if (it == pProperties + iCount)
     return nullptr;
-  }
+
   const XFA_ELEMENTINFO* pInfo = XFA_GetElementByID(eProperty);
   ASSERT(pInfo);
-  if (dwPacket == XFA_XDPPACKET_UNKNOWN)
-    return pProperty + iMid;
-  return (dwPacket & pInfo->dwPackets) ? (pProperty + iMid) : nullptr;
+  if (dwPacket != XFA_XDPPACKET_UNKNOWN && !(dwPacket & pInfo->dwPackets))
+    return nullptr;
+  return it;
 }
+
 const XFA_NOTSUREATTRIBUTE* XFA_GetNotsureAttribute(XFA_Element eElement,
                                                     XFA_ATTRIBUTE eAttribute,
                                                     XFA_ATTRIBUTETYPE eType) {
   int32_t iStart = 0, iEnd = g_iXFANotsureCount - 1;
   do {
     int32_t iMid = (iStart + iEnd) / 2;
     const XFA_NOTSUREATTRIBUTE* pAttr = g_XFANotsureAttributes + iMid;
     if (eElement == pAttr->eElement) {
       if (pAttr->eAttribute == eAttribute) {
         if (eType == XFA_ATTRIBUTETYPE_NOTSURE || eType == pAttr->eType) {
@@ skipping 312 matching lines @@
   return nullptr;
 }
 
 void CXFA_WideTextRead::Lock() {}
 
 void CXFA_WideTextRead::Unlock() {}
 
 CFX_WideString CXFA_WideTextRead::GetSrcText() const {
   return m_wsBuffer;
 }