Use stricter type checking in UMA_HISTOGRAM_ENUMERATION

content/browser/browser_child_process_host_impl.cc

 // Copyright (c) 2012 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 "content/browser/browser_child_process_host_impl.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
@@ skipping 294 matching lines @@
     const std::string& interface_name,
     mojo::ScopedMessagePipeHandle interface_pipe) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!child_connection_)
     return;
 
   child_connection_->BindInterface(interface_name, std::move(interface_pipe));
 }
 
 void BrowserChildProcessHostImpl::HistogramBadMessageTerminated(
-    int process_type) {
+    ProcessType process_type) {
   UMA_HISTOGRAM_ENUMERATION("ChildProcess.BadMessgeTerminated", process_type,
                             PROCESS_TYPE_MAX);
 }
 
 base::TerminationStatus BrowserChildProcessHostImpl::GetTerminationStatus(
     bool known_dead, int* exit_code) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!child_process_)  // If the delegate doesn't use Launch() helper.
     return base::GetTerminationStatus(data_.handle, exit_code);
   return child_process_->GetChildTerminationStatus(known_dead,
@@ skipping 36 matching lines @@
 
 void BrowserChildProcessHostImpl::OnBadMessageReceived(
     const IPC::Message& message) {
   std::string log_message =
       base::StringPrintf("Bad message received of type: %u", message.type());
   TerminateOnBadMessageReceived(log_message);
 }
 
 void BrowserChildProcessHostImpl::TerminateOnBadMessageReceived(
     const std::string& error) {
-  HistogramBadMessageTerminated(data_.process_type);
+  HistogramBadMessageTerminated(static_cast<ProcessType>(data_.process_type));
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableKillAfterBadIPC)) {
     return;
   }
   LOG(ERROR) << "Terminating child process for bad IPC message: " << error;
   // Create a memory dump. This will contain enough stack frames to work out
   // what the bad message was.
   base::debug::DumpWithoutCrashing();
 
   child_process_->GetProcess().Terminate(RESULT_CODE_KILLED_BAD_MESSAGE, false);
@@ skipping 19 matching lines @@
     base::TerminationStatus status = GetTerminationStatus(
         true /* known_dead */, &exit_code);
     switch (status) {
       case base::TERMINATION_STATUS_PROCESS_CRASHED:
       case base::TERMINATION_STATUS_ABNORMAL_TERMINATION: {
         delegate_->OnProcessCrashed(exit_code);
         BrowserThread::PostTask(
             BrowserThread::UI, FROM_HERE,
             base::Bind(&NotifyProcessCrashed, data_, exit_code));
         UMA_HISTOGRAM_ENUMERATION("ChildProcess.Crashed2",
-                                  data_.process_type,
+                                  static_cast<ProcessType>(data_.process_type),
                                   PROCESS_TYPE_MAX);
         break;
       }
 #if defined(OS_ANDROID)
       case base::TERMINATION_STATUS_OOM_PROTECTED:
 #endif
 #if defined(OS_CHROMEOS)
       case base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM:
 #endif
       case base::TERMINATION_STATUS_PROCESS_WAS_KILLED: {
         delegate_->OnProcessCrashed(exit_code);
         BrowserThread::PostTask(
             BrowserThread::UI, FROM_HERE,
             base::Bind(&NotifyProcessKilled, data_, exit_code));
         // Report that this child process was killed.
         UMA_HISTOGRAM_ENUMERATION("ChildProcess.Killed2",
-                                  data_.process_type,
+                                  static_cast<ProcessType>(data_.process_type),
                                   PROCESS_TYPE_MAX);
         break;
       }
       case base::TERMINATION_STATUS_STILL_RUNNING: {
         UMA_HISTOGRAM_ENUMERATION("ChildProcess.DisconnectedAlive2",
-                                  data_.process_type,
+                                  static_cast<ProcessType>(data_.process_type),
                                   PROCESS_TYPE_MAX);
       }
       default:
         break;
     }
     UMA_HISTOGRAM_ENUMERATION("ChildProcess.Disconnected2",
-                              data_.process_type,
+                              static_cast<ProcessType>(data_.process_type),
                               PROCESS_TYPE_MAX);
 #if defined(OS_CHROMEOS)
     if (status == base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM) {
       UMA_HISTOGRAM_ENUMERATION("ChildProcess.Killed2.OOM",
-                                data_.process_type,
+                                static_cast<ProcessType>(data_.process_type),
                                 PROCESS_TYPE_MAX);
     }
 #endif
   }
   channel_ = nullptr;
   delete delegate_;  // Will delete us
 }
 
 bool BrowserChildProcessHostImpl::Send(IPC::Message* message) {
   return child_process_host_->Send(message);
@@ skipping 119 matching lines @@
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     const std::string& error) {
   if (!task_runner->BelongsToCurrentThread()) {
     task_runner->PostTask(
         FROM_HERE, base::Bind(&BrowserChildProcessHostImpl::OnMojoError,
                               process, task_runner, error));
     return;
   }
   if (!process)
     return;
-  HistogramBadMessageTerminated(process->data_.process_type);
+  HistogramBadMessageTerminated(
+      static_cast<ProcessType>(process->data_.process_type));
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableKillAfterBadIPC)) {
     return;
   }
   LOG(ERROR) << "Terminating child process for bad Mojo message: " << error;
 
   // Create a memory dump with the error message aliased. This will make it easy
   // to determine details about what interface call failed.
   base::debug::Alias(&error);
   base::debug::DumpWithoutCrashing();
   process->child_process_->GetProcess().Terminate(
       RESULT_CODE_KILLED_BAD_MESSAGE, false);
 }
 
 #if defined(OS_WIN)
 
 void BrowserChildProcessHostImpl::OnObjectSignaled(HANDLE object) {
   OnChildDisconnected();
 }
 
 #endif
 
 }  // namespace content