Use implicit_cast<> instead of static_cast<> whenever possible

client/simulate_crash_mac_test.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 106 matching lines @@
     } else {
       EXPECT_EQ(flavor_, *flavor);
       switch (*flavor) {
 #if defined(ARCH_CPU_X86_FAMILY)
         case x86_THREAD_STATE: {
           EXPECT_EQ(x86_THREAD_STATE_COUNT, old_state_count);
           const x86_thread_state* state =
               reinterpret_cast<const x86_thread_state*>(old_state);
           switch (state->tsh.flavor) {
             case x86_THREAD_STATE32:
-              EXPECT_EQ(static_cast<int>(x86_THREAD_STATE32_COUNT),
+              EXPECT_EQ(implicit_cast<int>(x86_THREAD_STATE32_COUNT),
                         state->tsh.count);
               break;
             case x86_THREAD_STATE64:
-              EXPECT_EQ(static_cast<int>(x86_THREAD_STATE64_COUNT),
+              EXPECT_EQ(implicit_cast<int>(x86_THREAD_STATE64_COUNT),
                         state->tsh.count);
               break;
             default:
               ADD_FAILURE() << "unexpected tsh.flavor " << state->tsh.flavor;
               break;
           }
           break;
         }
         case x86_FLOAT_STATE: {
           EXPECT_EQ(x86_FLOAT_STATE_COUNT, old_state_count);
           const x86_float_state* state =
               reinterpret_cast<const x86_float_state*>(old_state);
           switch (state->fsh.flavor) {
             case x86_FLOAT_STATE32:
-              EXPECT_EQ(static_cast<int>(x86_FLOAT_STATE32_COUNT),
+              EXPECT_EQ(implicit_cast<int>(x86_FLOAT_STATE32_COUNT),
                         state->fsh.count);
               break;
             case x86_FLOAT_STATE64:
-              EXPECT_EQ(static_cast<int>(x86_FLOAT_STATE64_COUNT),
+              EXPECT_EQ(implicit_cast<int>(x86_FLOAT_STATE64_COUNT),
                         state->fsh.count);
               break;
             default:
               ADD_FAILURE() << "unexpected fsh.flavor " << state->fsh.flavor;
               break;
           }
           break;
         }
         case x86_DEBUG_STATE: {
           EXPECT_EQ(x86_DEBUG_STATE_COUNT, old_state_count);
           const x86_debug_state* state =
               reinterpret_cast<const x86_debug_state*>(old_state);
           switch (state->dsh.flavor) {
             case x86_DEBUG_STATE32:
-              EXPECT_EQ(static_cast<int>(x86_DEBUG_STATE32_COUNT),
+              EXPECT_EQ(implicit_cast<int>(x86_DEBUG_STATE32_COUNT),
                         state->dsh.count);
               break;
             case x86_DEBUG_STATE64:
-              EXPECT_EQ(static_cast<int>(x86_DEBUG_STATE64_COUNT),
+              EXPECT_EQ(implicit_cast<int>(x86_DEBUG_STATE64_COUNT),
                         state->dsh.count);
               break;
             default:
               ADD_FAILURE() << "unexpected dsh.flavor " << state->dsh.flavor;
               break;
           }
           break;
         }
         case x86_THREAD_STATE32:
           EXPECT_EQ(x86_THREAD_STATE32_COUNT, old_state_count);
@@ skipping 188 matching lines @@
           test_simulate_crash_mac.Run();
         }
       }
     }
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad