Creating a framework for suppressing pollution of the profiler data

base/threading/worker_pool_win.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 "base/threading/worker_pool.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/pending_task.h"
 #include "base/threading/thread_local.h"
 #include "base/tracked_objects.h"
 
 namespace base {
 
 namespace {
 
 base::LazyInstance<ThreadLocalBoolean>::Leaky
     g_worker_pool_running_on_this_thread = LAZY_INSTANCE_INITIALIZER;
 
 DWORD CALLBACK WorkItemCallback(void* param) {
   PendingTask* pending_task = static_cast<PendingTask*>(param);
   TRACE_EVENT2("toplevel", "WorkItemCallback::Run",
                "src_file", pending_task->posted_from.file_name(),
                "src_func", pending_task->posted_from.function_name());
 
-  tracked_objects::TrackedTime start_time =
-      tracked_objects::ThreadData::NowForStartOfRun(pending_task->birth_tally);
+  tracked_objects::TaskStopwatch stopwatch;

[jar (doing other things), 2014/08/26 04:09:09]

nit/Question: Is there ever a case where we don't construct a TaskStopwatch, and
then immediately call its Start() method?  

I was wondering why the constructor doesn't take the argument to the Start()
method, and be done with it??

[vadimt, 2014/08/26 19:15:04]

No, but since there is method Stop, I thought it would be strange to have:
tracked_objects::TaskStopwatch stopwatch(time);
stopwatch.Stop()

You might argue that the stopwatch could be stopped inside
TallyRunOnWorkerThreadIfTracking(), but this would make code harder to
understand. Basically, if you start the stopwatch in constructor, you should
stop it in destructor, which is not the case here.
Note that we have asserts that the stopwatch passed to
TallyRunOnWorkerThreadIfTracking() was started and stopped.

+  stopwatch.Start(
+    tracked_objects::ThreadData::NowForStartOfRun(pending_task->birth_tally));
 
   g_worker_pool_running_on_this_thread.Get().Set(true);
   pending_task->task.Run();
   g_worker_pool_running_on_this_thread.Get().Set(false);
 
+  stopwatch.Stop(tracked_objects::ThreadData::NowForEndOfRun());
+
   tracked_objects::ThreadData::TallyRunOnWorkerThreadIfTracking(
       pending_task->birth_tally,
-      tracked_objects::TrackedTime(pending_task->time_posted), start_time,
-      tracked_objects::ThreadData::NowForEndOfRun());
+      tracked_objects::TrackedTime(pending_task->time_posted),
+      stopwatch);
 
   delete pending_task;
   return 0;
 }
 
 // Takes ownership of |pending_task|
 bool PostTaskInternal(PendingTask* pending_task, bool task_is_slow) {
   ULONG flags = 0;
   if (task_is_slow)
     flags |= WT_EXECUTELONGFUNCTION;
@@ skipping 15 matching lines @@
   PendingTask* pending_task = new PendingTask(from_here, task);
   return PostTaskInternal(pending_task, task_is_slow);
 }
 
 // static
 bool WorkerPool::RunsTasksOnCurrentThread() {
   return g_worker_pool_running_on_this_thread.Get().Get();
 }
 
 }  // namespace base