Use implicit_cast<> instead of static_cast<> whenever possible

snapshot/mac/process_types_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,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "snapshot/mac/process_types.h"
 
 #include <AvailabilityMacros.h>
 #include <mach/mach.h>
 #include <string.h>
 
 #include <vector>
 
+#include "base/basictypes.h"
 #include "base/strings/stringprintf.h"
 #include "gtest/gtest.h"
 #include "util/mac/mac_util.h"
 #include "util/test/mac/dyld.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 #define TEST_STRING(process_reader, self_view, proctype_view, field)        \
@@ skipping 81 matching lines @@
   }
   if (proctype_image_infos.version >= 3) {
     EXPECT_EQ(reinterpret_cast<uint64_t>(self_image_infos->jitInfo),
               proctype_image_infos.jitInfo);
   }
   if (proctype_image_infos.version >= 5) {
     EXPECT_EQ(reinterpret_cast<uint64_t>(self_image_infos->dyldVersion),
               proctype_image_infos.dyldVersion);
     EXPECT_EQ(reinterpret_cast<uint64_t>(self_image_infos->errorMessage),
               proctype_image_infos.errorMessage);
-    EXPECT_EQ(static_cast<uint64_t>(self_image_infos->terminationFlags),
+    EXPECT_EQ(implicit_cast<uint64_t>(self_image_infos->terminationFlags),
               proctype_image_infos.terminationFlags);
 
     TEST_STRING(
         process_reader, self_image_infos, proctype_image_infos, dyldVersion);
     TEST_STRING(
         process_reader, self_image_infos, proctype_image_infos, errorMessage);
   }
   if (proctype_image_infos.version >= 6) {
     EXPECT_EQ(
         reinterpret_cast<uint64_t>(self_image_infos->coreSymbolicationShmPage),
         proctype_image_infos.coreSymbolicationShmPage);
   }
   if (proctype_image_infos.version >= 7) {
-    EXPECT_EQ(static_cast<uint64_t>(self_image_infos->systemOrderFlag),
+    EXPECT_EQ(implicit_cast<uint64_t>(self_image_infos->systemOrderFlag),
               proctype_image_infos.systemOrderFlag);
   }
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
   if (proctype_image_infos.version >= 8) {
-    EXPECT_EQ(static_cast<uint64_t>(self_image_infos->uuidArrayCount),
+    EXPECT_EQ(implicit_cast<uint64_t>(self_image_infos->uuidArrayCount),
               proctype_image_infos.uuidArrayCount);
   }
   if (proctype_image_infos.version >= 9) {
     EXPECT_EQ(
         reinterpret_cast<uint64_t>(self_image_infos->dyldAllImageInfosAddress),
         proctype_image_infos.dyldAllImageInfosAddress);
   }
   if (proctype_image_infos.version >= 10) {
-    EXPECT_EQ(static_cast<uint64_t>(self_image_infos->initialImageCount),
+    EXPECT_EQ(implicit_cast<uint64_t>(self_image_infos->initialImageCount),
               proctype_image_infos.initialImageCount);
   }
   if (proctype_image_infos.version >= 11) {
-    EXPECT_EQ(static_cast<uint64_t>(self_image_infos->errorKind),
+    EXPECT_EQ(implicit_cast<uint64_t>(self_image_infos->errorKind),
               proctype_image_infos.errorKind);
     EXPECT_EQ(
         reinterpret_cast<uint64_t>(self_image_infos->errorClientOfDylibPath),
         proctype_image_infos.errorClientOfDylibPath);
     EXPECT_EQ(
         reinterpret_cast<uint64_t>(self_image_infos->errorTargetDylibPath),
         proctype_image_infos.errorTargetDylibPath);
     EXPECT_EQ(reinterpret_cast<uint64_t>(self_image_infos->errorSymbol),
               proctype_image_infos.errorSymbol);
 
     TEST_STRING(process_reader,
                 self_image_infos,
                 proctype_image_infos,
                 errorClientOfDylibPath);
     TEST_STRING(process_reader,
                 self_image_infos,
                 proctype_image_infos,
                 errorTargetDylibPath);
     TEST_STRING(
         process_reader, self_image_infos, proctype_image_infos, errorSymbol);
   }
   if (proctype_image_infos.version >= 12) {
-    EXPECT_EQ(static_cast<uint64_t>(self_image_infos->sharedCacheSlide),
+    EXPECT_EQ(implicit_cast<uint64_t>(self_image_infos->sharedCacheSlide),
               proctype_image_infos.sharedCacheSlide);
   }
 #endif
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_9
   if (proctype_image_infos.version >= 13) {
     EXPECT_EQ(0,
               memcmp(self_image_infos->sharedCacheUUID,
                      proctype_image_infos.sharedCacheUUID,
                      sizeof(self_image_infos->sharedCacheUUID)));
   }
   if (proctype_image_infos.version >= 14) {
     for (size_t index = 0; index < arraysize(self_image_infos->reserved);
          ++index) {
-      EXPECT_EQ(static_cast<uint64_t>(self_image_infos->reserved[index]),
+      EXPECT_EQ(implicit_cast<uint64_t>(self_image_infos->reserved[index]),
                 proctype_image_infos.reserved[index])
           << "index " << index;
     }
   }
 #endif
 
   if (proctype_image_infos.version >= 1) {
     std::vector<process_types::dyld_image_info> proctype_image_info_vector(
         proctype_image_infos.infoArrayCount);
     ASSERT_TRUE(process_types::dyld_image_info::ReadArrayInto(
         &process_reader,
         proctype_image_infos.infoArray,
         proctype_image_info_vector.size(),
         &proctype_image_info_vector[0]));
 
     for (size_t index = 0; index < proctype_image_infos.infoArrayCount;
          ++index) {
       const dyld_image_info* self_image_info =
           &self_image_infos->infoArray[index];
       const process_types::dyld_image_info& proctype_image_info =
           proctype_image_info_vector[index];
 
       EXPECT_EQ(reinterpret_cast<uint64_t>(self_image_info->imageLoadAddress),
                 proctype_image_info.imageLoadAddress)
           << "index " << index;
       EXPECT_EQ(reinterpret_cast<uint64_t>(self_image_info->imageFilePath),
                 proctype_image_info.imageFilePath)
           << "index " << index;
-      EXPECT_EQ(static_cast<uint64_t>(self_image_info->imageFileModDate),
+      EXPECT_EQ(implicit_cast<uint64_t>(self_image_info->imageFileModDate),
                 proctype_image_info.imageFileModDate)
           << "index " << index;
 
       TEST_STRING(
           process_reader, self_image_info, proctype_image_info, imageFilePath);
     }
   }
 
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
   if (proctype_image_infos.version >= 8) {
@@ skipping 21 matching lines @@
                        sizeof(self_uuid_info->imageUUID)))
           << "index " << index;
     }
   }
 #endif
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad