Use implicit_cast<> instead of static_cast<> whenever possible

util/mach/symbolic_constants_mach.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,
@@ skipping 174 matching lines @@
   return std::string(flavor_data, flavor_len);
 }
 
 }  // namespace
 
 namespace crashpad {
 
 std::string ExceptionToString(exception_type_t exception,
                               SymbolicConstantToStringOptions options) {
   const char* exception_name =
-      static_cast<size_t>(exception) < arraysize(kExceptionNames)
+      implicit_cast<size_t>(exception) < arraysize(kExceptionNames)
           ? kExceptionNames[exception]
           : nullptr;
   if (!exception_name) {
     if (options & kUnknownIsNumeric) {
       return base::StringPrintf("%d", exception);
     }
     return std::string();
   }
 
   if (options & kUseShortName) {
     return std::string(exception_name);
   }
   return base::StringPrintf("%s%s", kExcPrefix, exception_name);
 }
 
 bool StringToException(const base::StringPiece& string,
                        StringToSymbolicConstantOptions options,
                        exception_type_t* exception) {
   if ((options & kAllowFullName) || (options & kAllowShortName)) {
     bool can_match_full =
         (options & kAllowFullName) &&
         string.substr(0, strlen(kExcPrefix)).compare(kExcPrefix) == 0;
     base::StringPiece short_string =
         can_match_full ? string.substr(strlen(kExcPrefix)) : string;
     for (exception_type_t index = 0;
-         index < static_cast<exception_type_t>(arraysize(kExceptionNames));
+         index < implicit_cast<exception_type_t>(arraysize(kExceptionNames));
          ++index) {
       const char* exception_name = kExceptionNames[index];
       if (!exception_name) {
         continue;
       }
       if (can_match_full && short_string.compare(exception_name) == 0) {
         *exception = index;
         return true;
       }
       if ((options & kAllowShortName) && string.compare(exception_name) == 0) {
@@ skipping 83 matching lines @@
     return true;
   }
 
   if ((options & kAllowFullName) || (options & kAllowShortName)) {
     bool can_match_full =
         (options & kAllowFullName) &&
         string.substr(0, strlen(kExcMaskPrefix)).compare(kExcMaskPrefix) == 0;
     base::StringPiece short_string =
         can_match_full ? string.substr(strlen(kExcMaskPrefix)) : string;
     for (exception_type_t index = 0;
-         index < static_cast<exception_type_t>(arraysize(kExceptionNames));
+         index < implicit_cast<exception_type_t>(arraysize(kExceptionNames));
          ++index) {
       const char* exception_name = kExceptionNames[index];
       if (!exception_name) {
         continue;
       }
       if (can_match_full && short_string.compare(exception_name) == 0) {
         *exception_mask = 1 << index;
         return true;
       }
       if ((options & kAllowShortName) && string.compare(exception_name) == 0) {
@@ skipping 18 matching lines @@
   }
 
   return false;
 }
 
 std::string ExceptionBehaviorToString(exception_behavior_t behavior,
                                       SymbolicConstantToStringOptions options) {
   const exception_behavior_t basic_behavior = ExceptionBehaviorBasic(behavior);
 
   const char* behavior_name =
-      static_cast<size_t>(basic_behavior) < arraysize(kBehaviorNames)
+      implicit_cast<size_t>(basic_behavior) < arraysize(kBehaviorNames)
           ? kBehaviorNames[basic_behavior]
           : nullptr;
   if (!behavior_name) {
     if (options & kUnknownIsNumeric) {
       return base::StringPrintf("%#x", behavior);
     }
     return std::string();
   }
 
   std::string behavior_string;
@@ skipping 46 matching lines @@
     }
   }
 
   if ((options & kAllowFullName) || (options & kAllowShortName)) {
     bool can_match_full =
         (options & kAllowFullName) &&
         sp.substr(0, strlen(kBehaviorPrefix)).compare(kBehaviorPrefix) == 0;
     base::StringPiece short_string =
         can_match_full ? sp.substr(strlen(kBehaviorPrefix)) : sp;
     for (exception_behavior_t index = 0;
-         index < static_cast<exception_behavior_t>(arraysize(kBehaviorNames));
+         index < implicit_cast<exception_behavior_t>(arraysize(kBehaviorNames));
          ++index) {
       const char* behavior_name = kBehaviorNames[index];
       if (!behavior_name) {
         continue;
       }
       if (can_match_full && short_string.compare(behavior_name) == 0) {
         build_behavior |= index;
         *behavior = build_behavior;
         return true;
       }
@@ skipping 14 matching lines @@
     *behavior = build_behavior;
     return true;
   }
 
   return false;
 }
 
 std::string ThreadStateFlavorToString(thread_state_flavor_t flavor,
                                       SymbolicConstantToStringOptions options) {
   const char* flavor_name =
-      static_cast<size_t>(flavor) < arraysize(kFlavorNames)
+      implicit_cast<size_t>(flavor) < arraysize(kFlavorNames)
           ? kFlavorNames[flavor]
           : nullptr;
 
   if (!flavor_name) {
     for (size_t generic_flavor_index = 0;
          generic_flavor_index < arraysize(kGenericFlavorNames);
          ++generic_flavor_index) {
       if (flavor == kGenericFlavorNames[generic_flavor_index].flavor) {
         flavor_name = kGenericFlavorNames[generic_flavor_index].name;
         break;
@@ skipping 12 matching lines @@
     return ThreadStateFlavorFullToShort(flavor_name);
   }
   return std::string(flavor_name);
 }
 
 bool StringToThreadStateFlavor(const base::StringPiece& string,
                                StringToSymbolicConstantOptions options,
                                thread_state_flavor_t* flavor) {
   if ((options & kAllowFullName) || (options & kAllowShortName)) {
     for (thread_state_flavor_t index = 0;
-         index < static_cast<thread_state_flavor_t>(arraysize(kFlavorNames));
+         index < implicit_cast<thread_state_flavor_t>(arraysize(kFlavorNames));
          ++index) {
       const char* flavor_name = kFlavorNames[index];
       if (!flavor_name) {
         continue;
       }
       if ((options & kAllowFullName) && string.compare(flavor_name) == 0) {
         *flavor = index;
         return true;
       }
       if (options & kAllowShortName) {
@@ skipping 26 matching lines @@
   }
 
   if (options & kAllowNumber) {
     return StringToNumber(string, reinterpret_cast<unsigned int*>(flavor));
   }
 
   return false;
 }
 
 }  // namespace crashpad