Measure how many tasks are cancelled in MessageLoop.

base/message_loop/message_loop.cc

 // 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.
 
 #include "base/message_loop/message_loop.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_pump_default.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/run_loop.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/thread_id_name_manager.h"
 #include "base/threading/thread_local.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 
 #if defined(OS_MACOSX)
 #include "base/message_loop/message_pump_mac.h"
 #endif
@@ skipping 504 matching lines @@
   // queue that are ready to run.  To increase efficiency when we fall behind,
   // we will only call Time::Now() intermittently, and then process all tasks
   // that are ready to run before calling it again.  As a result, the more we
   // fall behind (and have a lot of ready-to-run delayed tasks), the more
   // efficient we'll be at handling the tasks.
 
   TimeTicks next_run_time = delayed_work_queue_.top().delayed_run_time;
   if (next_run_time > recent_time_) {
     recent_time_ = TimeTicks::Now();  // Get a better view of Now();
     if (next_run_time > recent_time_) {
+      UMA_HISTOGRAM_BOOLEAN("TaskRunner.WokeUpTooSoonTaskIsCancelled",
+                            delayed_work_queue_.top().task.IsCancelled());
       *next_delayed_work_time = next_run_time;
       return false;
     }
   }
 
   PendingTask pending_task =
       std::move(const_cast<PendingTask&>(delayed_work_queue_.top()));
   delayed_work_queue_.pop();
 
-  if (!delayed_work_queue_.empty())
+  UMA_HISTOGRAM_BOOLEAN("TaskRunner.ExecutingDelayedTaskIsCancelled",
+                        pending_task.task.IsCancelled());
+
+  if (!delayed_work_queue_.empty()) {
+    UMA_HISTOGRAM_BOOLEAN("TaskRunner.ScheduledTaskIsCancelled",
+                          delayed_work_queue_.top().task.IsCancelled());
     *next_delayed_work_time = delayed_work_queue_.top().delayed_run_time;
+  }
 
   return DeferOrRunPendingTask(std::move(pending_task));
 }
 
 bool MessageLoop::DoIdleWork() {
   if (ProcessNextDelayedNonNestableTask())
     return true;
 
   if (run_loop_->quit_when_idle_received_)
     pump_->Quit();
@@ skipping 91 matching lines @@
       persistent,
       mode,
       controller,
       delegate);
 }
 #endif
 
 #endif  // !defined(OS_NACL_SFI)
 
 }  // namespace base