Add CVPixelBufferRef memory tracking

media/gpu/vt_video_decode_accelerator_mac.cc

 // Copyright 2014 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/gpu/vt_video_decode_accelerator_mac.h"
 
 #include <CoreVideo/CoreVideo.h>
 #include <OpenGL/CGLIOSurface.h>
 #include <OpenGL/gl.h>
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
 
+#include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/mac/mac_logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/strings/stringprintf.h"
 #include "base/sys_byteorder.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/trace_event/memory_dump_manager.h"
 #include "base/version.h"
 #include "media/base/limits.h"
 #include "media/gpu/shared_memory_region.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image_io_surface.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/scoped_binders.h"
 
 #define NOTIFY_STATUS(name, status, session_failure) \
   do {                                               \
     OSSTATUS_DLOG(ERROR, status) << name;            \
     NotifyError(PLATFORM_FAILURE, session_failure);  \
   } while (0)
 
 namespace media {
 
 namespace {
 
+// A sequence of ids for memory tracing.
+base::StaticAtomicSequenceNumber g_memory_dump_ids;
+
+// A sequence of shared memory ids for CVPixelBufferRefs.
+base::StaticAtomicSequenceNumber g_cv_pixel_buffer_ids;
+
 // Only H.264 with 4:2:0 chroma sampling is supported.
 const VideoCodecProfile kSupportedProfiles[] = {
     H264PROFILE_BASELINE, H264PROFILE_EXTENDED, H264PROFILE_MAIN,
     H264PROFILE_HIGH,
 
     // TODO(hubbe): Re-enable this once software fallback is working.
     // http://crbug.com/605790
     // H264PROFILE_HIGH10PROFILE,
 
     // TODO(sandersd): Find and test media with these profiles before enabling.
@@ skipping 236 matching lines @@
     const MakeGLContextCurrentCallback& make_context_current_cb,
     const BindGLImageCallback& bind_image_cb)
     : make_context_current_cb_(make_context_current_cb),
       bind_image_cb_(bind_image_cb),
       gpu_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       decoder_thread_("VTDecoderThread"),
       weak_this_factory_(this) {
   callback_.decompressionOutputCallback = OutputThunk;
   callback_.decompressionOutputRefCon = this;
   weak_this_ = weak_this_factory_.GetWeakPtr();
+
+  memory_dump_id_ = g_memory_dump_ids.GetNext();
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+      this, "VTVideoDecodeAccelerator", gpu_task_runner_);
 }
 
 VTVideoDecodeAccelerator::~VTVideoDecodeAccelerator() {
   DVLOG(1) << __func__;
   DCHECK(gpu_task_runner_->BelongsToCurrentThread());
+
+  base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+      this);
+}
+
+bool VTVideoDecodeAccelerator::OnMemoryDump(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  for (const auto& it : picture_info_map_) {
+    int32_t picture_id = it.first;
+    PictureInfo* picture_info = it.second.get();
+    if (picture_info->gl_image) {
+      std::string dump_name =
+          base::StringPrintf("media/vt_video_decode_accelerator_%d/picture_%d",
+                             memory_dump_id_, picture_id);
+      picture_info->gl_image->OnMemoryDump(pmd, 0, dump_name);
+    }
+  }
+  return true;
 }
 
 bool VTVideoDecodeAccelerator::Initialize(const Config& config,
                                           Client* client) {
   DVLOG(1) << __func__;
   DCHECK(gpu_task_runner_->BelongsToCurrentThread());
 
   if (make_context_current_cb_.is_null() || bind_image_cb_.is_null()) {
     NOTREACHED() << "GL callbacks are required for this VDA";
     return false;
@@ skipping 769 matching lines @@
 
   if (!make_context_current_cb_.Run()) {
     DLOG(ERROR) << "Failed to make GL context current";
     NotifyError(PLATFORM_FAILURE, SFT_PLATFORM_ERROR);
     return false;
   }
 
   scoped_refptr<gl::GLImageIOSurface> gl_image(
       new gl::GLImageIOSurface(frame.image_size, GL_BGRA_EXT));
   if (!gl_image->InitializeWithCVPixelBuffer(
-          frame.image.get(), gfx::GenericSharedMemoryId(),
+          frame.image.get(),
+          gfx::GenericSharedMemoryId(g_cv_pixel_buffer_ids.GetNext()),
           gfx::BufferFormat::YUV_420_BIPLANAR)) {
     NOTIFY_STATUS("Failed to initialize GLImageIOSurface", PLATFORM_FAILURE,
                   SFT_PLATFORM_ERROR);
   }
 
   if (!bind_image_cb_.Run(picture_info->client_texture_id,
                           GL_TEXTURE_RECTANGLE_ARB, gl_image, false)) {
     DLOG(ERROR) << "Failed to bind image";
     NotifyError(PLATFORM_FAILURE, SFT_PLATFORM_ERROR);
     return false;
@@ skipping 89 matching lines @@
     SupportedProfile profile;
     profile.profile = supported_profile;
     profile.min_resolution.SetSize(16, 16);
     profile.max_resolution.SetSize(4096, 2160);
     profiles.push_back(profile);
   }
   return profiles;
 }
 
 }  // namespace media