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

base/strings/safe_sprintf.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/safe_sprintf.h"
 
 #include <limits>
 
 #if !defined(NDEBUG)
 // In debug builds, we use RAW_CHECK() to print useful error messages, if
@@ skipping 490 matching lines @@
         const Arg& arg = args[cur_arg++];
         if (arg.type != Arg::INT && arg.type != Arg::UINT) {
           DEBUG_CHECK(arg.type == Arg::INT || arg.type == Arg::UINT);
           goto fail_to_expand;
         }
 
         // Apply padding, if needed.
         buffer.Pad(' ', padding, 1);
 
         // Convert the argument to an ASCII character and output it.
-        char ch = static_cast<char>(arg.i);
+        char ch = static_cast<char>(arg.integer.i);
         if (!ch) {
           goto end_of_output_buffer;
         }
         buffer.Out(ch);
         break; }
       case 'd':    // Output a possibly signed decimal value.
       case 'o':    // Output an unsigned octal value.
       case 'x':    // Output an unsigned hexadecimal value.
       case 'X':
       case 'p': {  // Output a pointer value.
         // Check that there are arguments left to be inserted.
         if (cur_arg >= max_args) {
           DEBUG_CHECK(cur_arg < max_args);
           goto fail_to_expand;
         }
 
         const Arg& arg = args[cur_arg++];
         int64_t i;
         const char* prefix = NULL;
         if (ch != 'p') {
           // Check that the argument has the expected type.
           if (arg.type != Arg::INT && arg.type != Arg::UINT) {
             DEBUG_CHECK(arg.type == Arg::INT || arg.type == Arg::UINT);
             goto fail_to_expand;
           }
-          i = arg.i;
+          i = arg.integer.i;
 
           if (ch != 'd') {
             // The Arg() constructor automatically performed sign expansion on
             // signed parameters. This is great when outputting a %d decimal
             // number, but can result in unexpected leading 0xFF bytes when
             // outputting a %x hexadecimal number. Mask bits, if necessary.
             // We have to do this here, instead of in the Arg() constructor, as
             // the Arg() constructor cannot tell whether we will output a %d
             // or a %x. Only the latter should experience masking.
-            if (arg.width < sizeof(int64_t)) {
-              i &= (1LL << (8*arg.width)) - 1;
+            if (arg.integer.width < sizeof(int64_t)) {
+              i &= (1LL << (8*arg.integer.width)) - 1;
             }
           }
         } else {
           // Pointer values require an actual pointer or a string.
           if (arg.type == Arg::POINTER) {
             i = reinterpret_cast<uintptr_t>(arg.ptr);
           } else if (arg.type == Arg::STRING) {
             i = reinterpret_cast<uintptr_t>(arg.str);
-          } else if (arg.type == Arg::INT && arg.width == sizeof(NULL) &&
-                     arg.i == 0) {  // Allow C++'s version of NULL
+          } else if (arg.type == Arg::INT &&
+                     arg.integer.width == sizeof(NULL) &&
+                     arg.integer.i == 0) {  // Allow C++'s version of NULL
             i = 0;
           } else {
             DEBUG_CHECK(arg.type == Arg::POINTER || arg.type == Arg::STRING);
             goto fail_to_expand;
           }
 
           // Pointers always include the "0x" prefix.
           prefix = "0x";
         }
 
@@ skipping 12 matching lines @@
         if (cur_arg >= max_args) {
           DEBUG_CHECK(cur_arg < max_args);
           goto fail_to_expand;
         }
 
         // Check that the argument has the expected type.
         const Arg& arg = args[cur_arg++];
         const char *s;
         if (arg.type == Arg::STRING) {
           s = arg.str ? arg.str : "<NULL>";
-        } else if (arg.type == Arg::INT && arg.width == sizeof(NULL) &&
-                   arg.i == 0) {  // Allow C++'s version of NULL
+        } else if (arg.type == Arg::INT && arg.integer.width == sizeof(NULL) &&
+                   arg.integer.i == 0) {  // Allow C++'s version of NULL
           s = "<NULL>";
         } else {
           DEBUG_CHECK(arg.type == Arg::STRING);
           goto fail_to_expand;
         }
 
         // Apply padding, if needed. This requires us to first check the
         // length of the string that we are outputting.
         if (padding) {
           size_t len = 0;
@@ skipping 70 matching lines @@
     DEBUG_CHECK(src[0] != '%' || src[1] == '%');
     if (src[0] == '%' && src[1] == '%') {
       ++src;
     }
   }
   return buffer.GetCount();
 }
 
 }  // namespace strings
 }  // namespace base