Tag some of Mojo heap allocations for the heap profiler.

media/mojo/common/mojo_decoder_buffer_converter.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 "media/mojo/common/mojo_decoder_buffer_converter.h"
 
 #include <memory>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 45 matching lines @@
     mojo::ScopedDataPipeProducerHandle* producer_handle) {
   DVLOG(1) << __func__;
   std::unique_ptr<mojo::DataPipe> data_pipe = CreateDataPipe(type);
   *producer_handle = std::move(data_pipe->producer_handle);
   return base::WrapUnique(
       new MojoDecoderBufferReader(std::move(data_pipe->consumer_handle)));
 }
 
 MojoDecoderBufferReader::MojoDecoderBufferReader(
     mojo::ScopedDataPipeConsumerHandle consumer_handle)
-    : consumer_handle_(std::move(consumer_handle)), bytes_read_(0) {
+    : consumer_handle_(std::move(consumer_handle)),
+      pipe_watcher_(FROM_HERE),
+      bytes_read_(0) {
   DVLOG(1) << __func__;
 
   MojoResult result =
       pipe_watcher_.Start(consumer_handle_.get(), MOJO_HANDLE_SIGNAL_READABLE,
                           base::Bind(&MojoDecoderBufferReader::OnPipeReadable,
                                      base::Unretained(this)));
   if (result != MOJO_RESULT_OK) {
     DVLOG(1) << __func__
              << ": Failed to start watching the pipe. result=" << result;
     consumer_handle_.reset();
@@ skipping 99 matching lines @@
     mojo::ScopedDataPipeConsumerHandle* consumer_handle) {
   DVLOG(1) << __func__;
   std::unique_ptr<mojo::DataPipe> data_pipe = CreateDataPipe(type);
   *consumer_handle = std::move(data_pipe->consumer_handle);
   return base::WrapUnique(
       new MojoDecoderBufferWriter(std::move(data_pipe->producer_handle)));
 }
 
 MojoDecoderBufferWriter::MojoDecoderBufferWriter(
     mojo::ScopedDataPipeProducerHandle producer_handle)
-    : producer_handle_(std::move(producer_handle)), bytes_written_(0) {
+    : producer_handle_(std::move(producer_handle)),
+      pipe_watcher_(FROM_HERE),
+      bytes_written_(0) {
   DVLOG(1) << __func__;
 
   MojoResult result =
       pipe_watcher_.Start(producer_handle_.get(), MOJO_HANDLE_SIGNAL_WRITABLE,
                           base::Bind(&MojoDecoderBufferWriter::OnPipeWritable,
                                      base::Unretained(this)));
   if (result != MOJO_RESULT_OK) {
     DVLOG(1) << __func__
              << ": Failed to start watching the pipe. result=" << result;
     producer_handle_.reset();
@@ skipping 78 matching lines @@
     if (bytes_written_ == buffer_size) {
       media_buffer_ = nullptr;
       bytes_written_ = 0;
     }
   }
 
   return result;
 }
 
 }  // namespace media