Fixes for re-enabling more MSVC level 4 warnings: base/ edition #2

base/strings/string_util.cc

 // Copyright 2013 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_util.h"
 
 #include <ctype.h>
 #include <errno.h>
 #include <math.h>
 #include <stdarg.h>
@@ skipping 205 matching lines @@
   int32 truncation_length = static_cast<int32>(byte_size);
   int32 char_index = truncation_length - 1;
   const char* data = input.data();
 
   // Using CBU8, we will move backwards from the truncation point
   // to the beginning of the string looking for a valid UTF8
   // character.  Once a full UTF8 character is found, we will
   // truncate the string to the end of that character.
   while (char_index >= 0) {
     int32 prev = char_index;
-    uint32 code_point = 0;
+    base_icu::UChar32 code_point = 0;
     CBU8_NEXT(data, char_index, truncation_length, code_point);
     if (!IsValidCharacter(code_point) ||
         !IsValidCodepoint(code_point)) {
       char_index = prev - 1;
     } else {
       break;
     }
   }
 
   if (char_index >= 0 )
@@ skipping 490 matching lines @@
       escape = *pattern;
       next(pattern, pattern_end);
       continue;
     }
 
     // Check if the chars match, if so, increment the ptrs.
     const CHAR* pattern_next = *pattern;
     const CHAR* string_next = *string;
     base_icu::UChar32 pattern_char = next(&pattern_next, pattern_end);
     if (pattern_char == next(&string_next, string_end) &&
-        pattern_char != (base_icu::UChar32) CBU_SENTINEL) {
+        pattern_char != CBU_SENTINEL) {
       *pattern = pattern_next;
       *string = string_next;
     } else {
-      // Uh ho, it did not match, we are done. If the last char was an
+      // Uh oh, it did not match, we are done. If the last char was an
       // escapement, that means that it was an error to advance the ptr here,
       // let's put it back where it was. This also mean that the MatchPattern
       // function will return false because if we can't match an escape char
       // here, then no one will.
       if (escape) {
         *pattern = escape;
       }
       return;
     }
 
@@ skipping 131 matching lines @@
 }
 
 }  // namespace
 
 size_t base::strlcpy(char* dst, const char* src, size_t dst_size) {
   return lcpyT<char>(dst, src, dst_size);
 }
 size_t base::wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size) {
   return lcpyT<wchar_t>(dst, src, dst_size);
 }