Update Crashpad to b47bf6c250c6b825dee1c5fbad9152c2c962e828

third_party/crashpad/crashpad/util/stdlib/string_number_conversion.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "util/stdlib/string_number_conversion.h"
 
 #include <ctype.h>
 #include <errno.h>
+#include <inttypes.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <limits>
 
 #include "base/logging.h"
 #include "util/stdlib/cxx.h"
 
 // CONSTEXPR_STATIC_ASSERT will be a normal static_assert if the C++ library is
 // the C++11 library. If using an older C++ library, the
@@ skipping 66 matching lines @@
 struct StringToIntTraits : public StringToSignedIntegerTraits<int, long> {
   static LongType Convert(const char* str, char** end, int base) {
     return strtol(str, end, base);
   }
 };
 
 struct StringToUnsignedIntTraits
     : public StringToUnsignedIntegerTraits<unsigned int, unsigned long> {
   static LongType Convert(const char* str, char** end, int base) {
     if (str[0] == '-') {
+      *end = const_cast<char*>(str);
       return 0;
     }
     return strtoul(str, end, base);
   }
 };
 
+struct StringToUnsignedInt64Traits
+    : public StringToUnsignedIntegerTraits<uint64_t, uint64_t> {
+  static LongType Convert(const char* str, char** end, int base) {
+    if (str[0] == '-') {
+      *end = const_cast<char*>(str);
+      return 0;
+    }
+    return strtoull(str, end, base);
+  }
+};
+
 template <typename Traits>
 bool StringToIntegerInternal(const base::StringPiece& string,
                              typename Traits::IntType* number) {
   using IntType = typename Traits::IntType;
   using LongType = typename Traits::LongType;
 
   Traits::TypeCheck();
 
   if (string.empty() || isspace(string[0])) {
     return false;
@@ skipping 25 matching lines @@
 namespace crashpad {
 
 bool StringToNumber(const base::StringPiece& string, int* number) {
   return StringToIntegerInternal<StringToIntTraits>(string, number);
 }
 
 bool StringToNumber(const base::StringPiece& string, unsigned int* number) {
   return StringToIntegerInternal<StringToUnsignedIntTraits>(string, number);
 }
 
+bool StringToNumber(const base::StringPiece& string, uint64_t* number) {
+  return StringToIntegerInternal<StringToUnsignedInt64Traits>(string, number);
+}
+
 }  // namespace crashpad