Make constructors recognize char[n] vs. char* and avoid strlen calls.

core/include/fxcrt/fx_string.h

 // 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
 
 #ifndef _FX_STRING_H_
 #define _FX_STRING_H_
 
 #include <stdint.h>  // For intptr_t.
 #include <algorithm>
 
 #include "fx_memory.h"
 
 class CFX_BinaryBuf;
 class CFX_ByteString;
 class CFX_WideString;
 struct CFX_CharMap;
 typedef int FX_STRSIZE;
 
+// Technique upon which we build code to allow the compiler to tell
+// the difference between a  pointer for which it doesn't know the size,
+// and an array where it does know the size (typically a const char string
+// literal), until std::enable_if becomes available. See also:
+// http://en.wikipedia.org/wiki/Substitution_failure_is_not_an_error
+template <typename T, typename U> struct FX_SFINAE { typedef T nonesuch; };
+template <typename T> struct FX_SFINAE<T, T> { typedef T type; };
+
 // An immutable string with caller-provided storage which must outlive the
 // string itself.
 class CFX_ByteStringC
 {
 public:
     typedef FX_CHAR value_type;
 
     CFX_ByteStringC()
     {
         m_Ptr = NULL;
         m_Length = 0;
     }
 
     CFX_ByteStringC(FX_LPCBYTE ptr, FX_STRSIZE size)
     {
         m_Ptr = ptr;
         m_Length = size;
     }
 
-    CFX_ByteStringC(FX_LPCSTR ptr)
-    {
-        m_Ptr = (FX_LPCBYTE)ptr;
-        m_Length = ptr ? (FX_STRSIZE)FXSYS_strlen(ptr) : 0;
-    }
+    // For the case where the compiler can't deduce the length.
+    template<typename T, typename = typename FX_SFINAE<T, char>::type>
+    CFX_ByteStringC(const T* const& ptr)
+            : CFX_ByteStringC(ptr, ptr ? (FX_STRSIZE)FXSYS_strlen(ptr) : 0) { }
+
+    // For the case where the compiler can deduce the length of a literal.
+    template<size_t N>
+    CFX_ByteStringC(const char (&ptr)[N])
+            : CFX_ByteStringC(ptr, N - 1) { }

[brucedawson, 2015/12/15 00:45:10]

I don't think we have any guarantee that this is a literal. It could simply be
an array that is const. This won't happen often because arrays that are only
partially filled cannot (practically speaking) be const, but they can become
const, by passing them to a function which takes a const array and then that
function passing them to CFX_ByteString.

+
+    // For the case where the compiler can deduce the length, but not a literal.
+    template<size_t N>
+    CFX_ByteStringC(char (&ptr)[N])
+            : CFX_ByteStringC(ptr, ptr ? (FX_STRSIZE)FXSYS_strlen(ptr) : 0) { }
 
     // |ch| must be an lvalue that outlives the the CFX_ByteStringC. However,
     // the use of char rvalues are not caught at compile time.  They are
     // implicitly promoted to CFX_ByteString (see below) and then the
     // CFX_ByteStringC is constructed from the CFX_ByteString via the alternate
     // constructor below. The CFX_ByteString then typically goes out of scope
     // and |m_Ptr| may be left pointing to invalid memory. Beware.
     // TODO(tsepez): Mark single-argument string constructors as explicit.
     CFX_ByteStringC(FX_CHAR& ch)
     {
@@ skipping 142 matching lines @@
 
     CFX_ByteString()
     {
         m_pData = NULL;
     }
 
     CFX_ByteString(const CFX_ByteString& str);
 
     CFX_ByteString(char ch);
 
-    CFX_ByteString(FX_LPCSTR ptr)
+    // For the case where the compiler can't deduce the length.
+    template<typename T, typename = typename FX_SFINAE<T, char>::type>
+    CFX_ByteString(const T* const& ptr)
             : CFX_ByteString(ptr, ptr ? FXSYS_strlen(ptr) : 0) { }
 
+    // For the case where the compiler can deduce the length of a literal.
+    template<size_t N>
+    CFX_ByteString(const char (&ptr)[N])
+            : CFX_ByteString(ptr, N - 1) { }
+
+    // For the case where the compiler can deduce the length, but not a literal.
+    template<size_t N>
+    CFX_ByteString(char (&ptr)[N])
+            : CFX_ByteString(ptr, ptr ? FXSYS_strlen(ptr) : 0) { }
+
+
     CFX_ByteString(FX_LPCSTR ptr, FX_STRSIZE len);
-
     CFX_ByteString(FX_LPCBYTE ptr, FX_STRSIZE len);
 
     CFX_ByteString(FX_BSTR bstrc);
     CFX_ByteString(FX_BSTR bstrc1, FX_BSTR bstrc2);
 
     ~CFX_ByteString();
 
     static CFX_ByteString       FromUnicode(FX_LPCWSTR ptr, FX_STRSIZE len = -1);
 
     static CFX_ByteString       FromUnicode(const CFX_WideString& str);
@@ skipping 234 matching lines @@
 {
 public:
     typedef FX_WCHAR value_type;
 
     CFX_WideStringC()
     {
         m_Ptr = NULL;
         m_Length = 0;
     }
 
-    CFX_WideStringC(FX_LPCWSTR ptr)
-    {
-        m_Ptr = ptr;
-        m_Length = ptr ? (FX_STRSIZE)FXSYS_wcslen(ptr) : 0;
-    }
-
     CFX_WideStringC(FX_WCHAR& ch)
     {
         m_Ptr = &ch;
         m_Length = 1;
     }
 
+    // For the case where the compiler can't deduce the length.
+    template<typename T, typename = typename FX_SFINAE<T, wchar_t>::type>
+    CFX_WideStringC(const T* const& ptr)
+            : CFX_WideStringC(ptr, ptr ? (FX_STRSIZE)FXSYS_wcslen(ptr) : 0) { }
+
+    // For the case where the compiler can deduce the length of a literal.
+    template<size_t N>
+    CFX_WideStringC(const wchar_t (&ptr)[N])
+            : CFX_WideStringC(ptr, N - 1) { }
+
+    // For the case where the compiler can deduce the length, but not a literal.
+    template<size_t N>
+    CFX_WideStringC(wchar_t (&ptr)[N])
+            : CFX_WideStringC(ptr, ptr ? (FX_STRSIZE)FXSYS_wcslen(ptr) : 0) { }
+
     CFX_WideStringC(FX_LPCWSTR ptr, FX_STRSIZE len)
     {
         m_Ptr = ptr;
         if (len == -1) {
             m_Length = (FX_STRSIZE)FXSYS_wcslen(ptr);
         } else {
             m_Length = len;
         }
     }
 
@@ skipping 134 matching lines @@
 public:
     typedef FX_WCHAR value_type;
 
     CFX_WideString()
     {
         m_pData = NULL;
     }
 
     CFX_WideString(const CFX_WideString& str);
 
-    CFX_WideString(FX_LPCWSTR ptr)
+    // For the case where the compiler can't deduce the length.
+    template<typename T, typename = typename FX_SFINAE<T, wchar_t>::type>
+    CFX_WideString(const T* const& ptr)
+            : CFX_WideString(ptr, ptr ? FXSYS_wcslen(ptr) : 0) { }
+
+    // For the case where the compiler can deduce the length of a literal.
+    template<size_t N>
+    CFX_WideString(const wchar_t (&ptr)[N])
+            : CFX_WideString(ptr, N - 1) { }
+
+    // For the case where the compiler can deduce the length, but not a literal.
+    template<size_t N>
+    CFX_WideString(wchar_t (&ptr)[N])
             : CFX_WideString(ptr, ptr ? FXSYS_wcslen(ptr) : 0) { }
 
     CFX_WideString(FX_LPCWSTR ptr, FX_STRSIZE len);
 
     CFX_WideString(FX_WCHAR ch);
 
     CFX_WideString(const CFX_WideStringC& str);
 
     CFX_WideString(const CFX_WideStringC& str1, const CFX_WideStringC& str2);
 
@@ skipping 229 matching lines @@
 CFX_ByteString  FX_UTF8Encode(FX_LPCWSTR pwsStr, FX_STRSIZE len);
 inline CFX_ByteString   FX_UTF8Encode(FX_WSTR wsStr)
 {
     return FX_UTF8Encode(wsStr.GetPtr(), wsStr.GetLength());
 }
 inline CFX_ByteString   FX_UTF8Encode(const CFX_WideString &wsStr)
 {
     return FX_UTF8Encode(wsStr.c_str(), wsStr.GetLength());
 }
 #endif