StringToUint should output zero on negative numbers.

base/strings/string_number_conversions.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/strings/string_number_conversions.h"
 
 #include <ctype.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <wctype.h>
@@ skipping 122 matching lines @@
   typedef typename traits::value_type value_type;
 
   // Generalized iterator-range-to-number conversion.
   //
   static bool Invoke(const_iterator begin,
                      const_iterator end,
                      value_type* output) {
     bool valid = true;
 
     while (begin != end && LocalIsWhitespace(*begin)) {
       valid = false;

[Nico, 2016/02/11 21:40:31]

this also can return false and doesn't write to output

[davidben, 2016/02/11 21:47:22]

This just falls through to later, so I think it's fine? Looks like we return
false but will still give a number if there's leading whitespace. Kinda weird,
but fine...

       ++begin;
     }
 
     if (begin != end && *begin == '-') {
       if (!std::numeric_limits<value_type>::is_signed) {
+        *output = 0;
         valid = false;
       } else if (!Negative::Invoke(begin + 1, end, output)) {
         valid = false;
       }
     } else {
       if (begin != end && *begin == '+') {
         ++begin;
       }
       if (!Positive::Invoke(begin, end, output)) {
         valid = false;
@@ skipping 121 matching lines @@
     HexIteratorRangeToInt64Traits;
 
 typedef BaseHexIteratorRangeToUInt64Traits<StringPiece::const_iterator>
     HexIteratorRangeToUInt64Traits;
 
 template <typename STR>
 bool HexStringToBytesT(const STR& input, std::vector<uint8_t>* output) {
   DCHECK_EQ(output->size(), 0u);
   size_t count = input.size();
   if (count == 0 || (count % 2) != 0)
     return false;

[Nico, 2016/02/11 21:40:31]

(this also doesn't write to output from what i can tell)

[davidben, 2016/02/11 21:47:22]

Hrm. I dunno. I don't have strong opinions about whether this implies it should
write anything in that case:

// Similar to the previous functions, except that output is a vector of bytes.
// |*output| will contain as many bytes as were successfully parsed prior to the
// error.  There is no overflow, but input.size() must be evenly divisible by 2.
// Leading 0x or +/- are not allowed.

The count == 0 case is clearly within spec, although why it returns false
instead of true when count is size is a little puzzling. I would think the empty
string is a valid hex string? Though I'm not comfortable doing anything to that
without digging a bit.

Dunno about the odd case.

   for (uintptr_t i = 0; i < count / 2; ++i) {
     uint8_t msb = 0;  // most significant 4 bits
     uint8_t lsb = 0;  // least significant 4 bits
     if (!CharToDigit<16>(input[i * 2], &msb) ||
         !CharToDigit<16>(input[i * 2 + 1], &lsb))
       return false;
     output->push_back((msb << 4) | lsb);
   }
   return true;
 }
@@ skipping 175 matching lines @@
 bool HexStringToUInt64(const StringPiece& input, uint64_t* output) {
   return IteratorRangeToNumber<HexIteratorRangeToUInt64Traits>::Invoke(
       input.begin(), input.end(), output);
 }
 
 bool HexStringToBytes(const std::string& input, std::vector<uint8_t>* output) {
   return HexStringToBytesT(input, output);
 }
 
 }  // namespace base