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

base/strings/safe_sprintf.h

 // 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.
 
 #ifndef BASE_STRINGS_SAFE_SPRINTF_H_
 #define BASE_STRINGS_SAFE_SPRINTF_H_
 
 #include "build/build_config.h"
 
 #include <stddef.h>
@@ skipping 121 matching lines @@
 
 namespace internal {
 // Helpers that use C++ overloading, templates, and specializations to deduce
 // and record type information from function arguments. This allows us to
 // later write a type-safe version of snprintf().
 
 struct Arg {
   enum Type { INT, UINT, STRING, POINTER };
 
   // Any integer-like value.
-  Arg(signed char c)        : i(c), width(sizeof(char)),      type(INT)  { }
-  Arg(unsigned char c)      : i(c), width(sizeof(char)),      type(UINT) { }
-  Arg(signed short j)       : i(j), width(sizeof(short)),     type(INT)  { }
-  Arg(unsigned short j)     : i(j), width(sizeof(short)),     type(UINT) { }
-  Arg(signed int j)         : i(j), width(sizeof(int)),       type(INT)  { }
-  Arg(unsigned int j)       : i(j), width(sizeof(int)),       type(UINT) { }
-  Arg(signed long j)        : i(j), width(sizeof(long)),      type(INT)  { }
-  Arg(unsigned long j)      : i(j), width(sizeof(long)),      type(UINT) { }
-  Arg(signed long long j)   : i(j), width(sizeof(long long)), type(INT)  { }
-  Arg(unsigned long long j) : i(j), width(sizeof(long long)), type(UINT) { }
+  Arg(signed char c) : type(INT) {
+    integer.i = c;
+    integer.width = sizeof(char);
+  }
+  Arg(unsigned char c) : type(UINT) {
+    integer.i = c;
+    integer.width = sizeof(char);
+  }
+  Arg(signed short j) : type(INT) {
+    integer.i = j;
+    integer.width = sizeof(short);
+  }
+  Arg(unsigned short j) : type(UINT) {
+    integer.i = j;
+    integer.width = sizeof(short);
+  }
+  Arg(signed int j) : type(INT) {
+    integer.i = j;
+    integer.width = sizeof(int);
+  }
+  Arg(unsigned int j) : type(UINT) {
+    integer.i = j;
+    integer.width = sizeof(int);
+  }
+  Arg(signed long j) : type(INT) {
+    integer.i = j;
+    integer.width = sizeof(long);
+  }
+  Arg(unsigned long j) : type(UINT) {
+    integer.i = j;
+    integer.width = sizeof(long);
+  }
+  Arg(signed long long j) : type(INT) {
+    integer.i = j;
+    integer.width = sizeof(long long);
+  }
+  Arg(unsigned long long j) : type(UINT) {
+    integer.i = j;
+    integer.width = sizeof(long long);
+  }
 
   // A C-style text string.
   Arg(const char* s) : str(s), type(STRING) { }
   Arg(char* s)       : str(s), type(STRING) { }
 
   // Any pointer value that can be cast to a "void*".
   template<class T> Arg(T* p) : ptr((void*)p), type(POINTER) { }
 
   union {
     // An integer-like value.
     struct {
       int64_t       i;
       unsigned char width;
-    };
+    } integer;
 
     // A C-style text string.
     const char* str;
 
     // A pointer to an arbitrary object.
     const void* ptr;
   };
   const enum Type type;
 };
 
@@ skipping 232 matching lines @@
 BASE_EXPORT ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt);
 template<size_t N>
 inline ssize_t SafeSPrintf(char (&buf)[N], const char* fmt) {
   return SafeSNPrintf(buf, N, fmt);
 }
 
 }  // namespace strings
 }  // namespace base
 
 #endif  // BASE_STRINGS_SAFE_SPRINTF_H_