Tag some of Mojo heap allocations for the heap profiler.

mojo/public/cpp/system/watcher.cc

 // Copyright 2016 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 "mojo/public/cpp/system/watcher.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/trace_event/heap_profiler.h"
 #include "mojo/public/c/system/functions.h"
 
 namespace mojo {
 
-Watcher::Watcher(scoped_refptr<base::SingleThreadTaskRunner> runner)
+Watcher::Watcher(const tracked_objects::Location& from_here,
+                 scoped_refptr<base::SingleThreadTaskRunner> runner)
     : task_runner_(std::move(runner)),
       is_default_task_runner_(task_runner_ ==
                               base::ThreadTaskRunnerHandle::Get()),
+      heap_profiler_tag_(from_here.ToString()),

[ssid, 2017/01/12 21:50:03]

Can you please just use file_name() here instead of ToString. We currently do
not tag the allocations with each functions in the type column. This is to limit
the number of categories we have.

[Jay Civelli, 2017/01/13 01:09:27]

Done.

       weak_factory_(this) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   weak_self_ = weak_factory_.GetWeakPtr();
 }
 
 Watcher::~Watcher() {
   if(IsWatching())
     Cancel();
 }
 
@@ skipping 59 matching lines @@
 void Watcher::CallOnHandleReady(uintptr_t context,
                                 MojoResult result,
                                 MojoHandleSignalsState signals_state,
                                 MojoWatchNotificationFlags flags) {
   // NOTE: It is safe to assume the Watcher still exists because this callback
   // will never be run after the Watcher's destructor.
   //
   // TODO: Maybe we should also expose |signals_state| through the Watcher API.
   // Current HandleWatcher users have no need for it, so it's omitted here.
   Watcher* watcher = reinterpret_cast<Watcher*>(context);
+
+  TRACE_HEAP_PROFILER_API_SCOPED_TASK_EXECUTION event(
+      watcher->heap_profiler_tag_.c_str());
+
   if ((flags & MOJO_WATCH_NOTIFICATION_FLAG_FROM_SYSTEM) &&
       watcher->task_runner_->RunsTasksOnCurrentThread() &&
       watcher->is_default_task_runner_) {
     // System notifications will trigger from the task runner passed to
     // mojo::edk::InitIPCSupport(). In Chrome this happens to always be the
     // default task runner for the IO thread.
     watcher->OnHandleReady(result);
   } else {
     watcher->task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&Watcher::OnHandleReady, watcher->weak_self_, result));
   }
 }
 
 }  // namespace mojo