FREEZE.unindexed

ui/gl/gl_image_egl.cc

 // Copyright (c) 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 "ui/gl/gl_image_egl.h"
 
 #include "ui/gl/egl_util.h"
 #include "ui/gl/gl_surface_egl.h"
 
 namespace gfx {
 
 GLImageEGL::GLImageEGL(const gfx::Size& size)
-    : egl_image_(EGL_NO_IMAGE_KHR), size_(size) {
-}
+    : egl_image_(EGL_NO_IMAGE_KHR), size_(size) {}
 
 GLImageEGL::~GLImageEGL() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(EGL_NO_IMAGE_KHR, egl_image_);
 }
 
-bool GLImageEGL::Initialize(EGLenum target,
-                            EGLClientBuffer buffer,
-                            const EGLint* attrs) {
+bool GLImageEGL::Initialize(
+    base::trace_event::GenericSharedMemoryId shared_memory_id,
+    EGLenum target,
+    EGLClientBuffer buffer,
+    const EGLint* attrs) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(EGL_NO_IMAGE_KHR, egl_image_);
   egl_image_ = eglCreateImageKHR(GLSurfaceEGL::GetHardwareDisplay(),
-                                 EGL_NO_CONTEXT,
-                                 target,
-                                 buffer,
-                                 attrs);
+                                 EGL_NO_CONTEXT, target, buffer, attrs);
   if (egl_image_ == EGL_NO_IMAGE_KHR) {
     DLOG(ERROR) << "Error creating EGLImage: " << ui::GetLastEGLErrorString();
     return false;
   }
 
+  shared_memory_id_ = shared_memory_id;
   return true;
 }
 
 void GLImageEGL::Destroy(bool have_context) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (egl_image_ != EGL_NO_IMAGE_KHR) {
     EGLBoolean result =
         eglDestroyImageKHR(GLSurfaceEGL::GetHardwareDisplay(), egl_image_);
     if (result == EGL_FALSE) {
       DLOG(ERROR) << "Error destroying EGLImage: "
@@ skipping 22 matching lines @@
 }
 
 bool GLImageEGL::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                       int z_order,
                                       OverlayTransform transform,
                                       const Rect& bounds_rect,
                                       const RectF& crop_rect) {
   return false;
 }
 
+void GLImageEGL::DumpMemory(base::trace_event::ProcessMemoryDump* pmd,
+                            uint64_t process_tracing_id,
+                            const std::string& dump_name) {
+  // TODO(ericrk): Don't always assume 4BPP.
+  const size_t bytes_per_pixel = 4;
+  size_t size_in_bytes =
+      bytes_per_pixel * GetSize().width() * GetSize().height();
+
+  base::trace_event::MemoryAllocatorDump* dump =
+      pmd->CreateAllocatorDump(dump_name);
+  dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                  base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                  static_cast<uint64_t>(size_in_bytes));
+
+  auto guid = base::trace_event::GetGenericSharedMemoryGUIDForTracing(
+      process_tracing_id, shared_memory_id_);
+  pmd->CreateSharedGlobalAllocatorDump(guid);
+  pmd->AddOwnershipEdge(dump->guid(), guid);
+}
+
 }  // namespace gfx