Move memory observer off OutputSurface/CompositorFrameSink

content/common/gpu/client/context_provider_command_buffer.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 "content/common/gpu/client/context_provider_command_buffer.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
+#include "base/optional.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/trace_event/memory_dump_manager.h"
 #include "cc/output/context_cache_controller.h"
 #include "cc/output/managed_memory_policy.h"
 #include "content/common/gpu/client/command_buffer_metrics.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_trace_implementation.h"
 #include "gpu/command_buffer/client/gpu_switches.h"
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/ipc/client/command_buffer_proxy_impl.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
 #include "gpu/skia_bindings/grcontext_for_gles2_interface.h"
+#include "third_party/skia/include/core/SkTraceMemoryDump.h"
 #include "third_party/skia/include/gpu/GrContext.h"
+#include "ui/gl/trace_util.h"
+
+class SkDiscardableMemory;
 
 namespace {
 
 // Similar to base::AutoReset but it sets the variable to the new value
 // when it is destroyed. Use Reset() to cancel setting the variable.
 class AutoSet {
  public:
   AutoSet(bool* b, bool set) : b_(b), set_(set) {}
   ~AutoSet() {
     if (b_)
       *b_ = set_;
   }
   // Stops us from setting b_ on destruction.
   void Reset() { b_ = nullptr; }
 
  private:
   bool* b_;
   const bool set_;
 };
-}
+
+// Derives from SkTraceMemoryDump and implements graphics specific memory
+// backing functionality.
+class SkiaGpuTraceMemoryDump : public SkTraceMemoryDump {
+ public:
+  // This should never outlive the provided ProcessMemoryDump, as it should
+  // always be scoped to a single OnMemoryDump funciton call.
+  explicit SkiaGpuTraceMemoryDump(base::trace_event::ProcessMemoryDump* pmd,

[ericrk, 2016/10/07 23:50:14]

nit: pre-existing, but can you drop the "explicit"

+                                  uint64_t share_group_tracing_guid)
+      : pmd_(pmd), share_group_tracing_guid_(share_group_tracing_guid) {}
+
+  // Overridden from SkTraceMemoryDump:
+  void dumpNumericValue(const char* dump_name,
+                        const char* value_name,
+                        const char* units,
+                        uint64_t value) override {
+    auto* dump = GetOrCreateAllocatorDump(dump_name);
+    dump->AddScalar(value_name, units, value);
+  }
+
+  void setMemoryBacking(const char* dump_name,
+                        const char* backing_type,
+                        const char* backing_object_id) override {
+    const uint64_t tracing_process_id =
+        base::trace_event::MemoryDumpManager::GetInstance()
+            ->GetTracingProcessId();
+
+    // For uniformity, skia provides this value as a string. Convert back to a
+    // uint32_t.
+    uint32_t gl_id =
+        std::strtoul(backing_object_id, nullptr /* str_end */, 10 /* base */);
+
+    // Constants used by SkiaGpuTraceMemoryDump to identify different memory
+    // types.
+    const char* kGLTextureBackingType = "gl_texture";
+    const char* kGLBufferBackingType = "gl_buffer";
+    const char* kGLRenderbufferBackingType = "gl_renderbuffer";
+
+    // Populated in if statements below.
+    base::trace_event::MemoryAllocatorDumpGuid guid;
+
+    if (strcmp(backing_type, kGLTextureBackingType) == 0) {
+      guid = gl::GetGLTextureClientGUIDForTracing(share_group_tracing_guid_,
+                                                  gl_id);
+    } else if (strcmp(backing_type, kGLBufferBackingType) == 0) {
+      guid = gl::GetGLBufferGUIDForTracing(tracing_process_id, gl_id);
+    } else if (strcmp(backing_type, kGLRenderbufferBackingType) == 0) {
+      guid = gl::GetGLRenderbufferGUIDForTracing(tracing_process_id, gl_id);
+    }
+
+    if (!guid.empty()) {
+      pmd_->CreateSharedGlobalAllocatorDump(guid);
+
+      auto* dump = GetOrCreateAllocatorDump(dump_name);
+
+      const int kImportance = 2;
+      pmd_->AddOwnershipEdge(dump->guid(), guid, kImportance);
+    }
+  }
+
+  void setDiscardableMemoryBacking(
+      const char* dump_name,
+      const SkDiscardableMemory& discardable_memory_object) override {
+    // We don't use this class for dumping discardable memory.
+    NOTREACHED();
+  }
+
+  LevelOfDetail getRequestedDetails() const override {
+    // TODO(ssid): Use MemoryDumpArgs to create light dumps when requested
+    // (crbug.com/499731).
+    return kObjectsBreakdowns_LevelOfDetail;
+  }
+
+ private:
+  // Helper to create allocator dumps.
+  base::trace_event::MemoryAllocatorDump* GetOrCreateAllocatorDump(
+      const char* dump_name) {
+    auto* dump = pmd_->GetAllocatorDump(dump_name);
+    if (!dump)
+      dump = pmd_->CreateAllocatorDump(dump_name);
+    return dump;
+  }
+
+  base::trace_event::ProcessMemoryDump* pmd_;
+  uint64_t share_group_tracing_guid_;
+
+  DISALLOW_COPY_AND_ASSIGN(SkiaGpuTraceMemoryDump);
+};
+
+}  // namespace
 
 namespace content {
 
 ContextProviderCommandBuffer::SharedProviders::SharedProviders() = default;
 ContextProviderCommandBuffer::SharedProviders::~SharedProviders() = default;
 
 ContextProviderCommandBuffer::ContextProviderCommandBuffer(
     scoped_refptr<gpu::GpuChannelHost> channel,
     int32_t stream_id,
     gpu::GpuStreamPriority stream_priority,
@@ skipping 34 matching lines @@
     if (it != shared_providers_->list.end())
       shared_providers_->list.erase(it);
   }
 
   if (bind_succeeded_) {
     // Clear the lock to avoid DCHECKs that the lock is being held during
     // shutdown.
     command_buffer_->SetLock(nullptr);
     // Disconnect lost callbacks during destruction.
     gles2_impl_->SetLostContextCallback(base::Closure());
+    // Unregister memory dump provider.
+    base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+        this);
   }
 }
 
 gpu::CommandBufferProxyImpl*
 ContextProviderCommandBuffer::GetCommandBufferProxy() {
   return command_buffer_.get();
 }
 
 uint32_t ContextProviderCommandBuffer::GetCopyTextureInternalFormat() {
   if (attributes_.alpha_size > 0)
     return GL_RGBA;
   DCHECK_NE(attributes_.red_size, 0);
   DCHECK_NE(attributes_.green_size, 0);
   DCHECK_NE(attributes_.blue_size, 0);
   return GL_RGB;
 }
 
 bool ContextProviderCommandBuffer::BindToCurrentThread() {
   // This is called on the thread the context will be used.
   DCHECK(context_thread_checker_.CalledOnValidThread());
 
   if (bind_failed_)
     return false;
   if (bind_succeeded_)
     return true;
 
   // Early outs should report failure.
   AutoSet set_bind_failed(&bind_failed_, true);
 
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner =
+      default_task_runner_;
+  if (!task_runner)
+    task_runner = base::ThreadTaskRunnerHandle::Get();
+
   // It's possible to be running BindToCurrentThread on two contexts
   // on different threads at the same time, but which will be in the same share
   // group. To ensure they end up in the same group, hold the lock on the
   // shared_providers_ (which they will share) after querying the group, until
   // this context has been added to the list.
   {
     ContextProviderCommandBuffer* shared_context_provider = nullptr;
     gpu::CommandBufferProxyImpl* shared_command_buffer = nullptr;
     scoped_refptr<gpu::gles2::ShareGroup> share_group;
 
     base::AutoLock hold(shared_providers_->lock);
 
     if (!shared_providers_->list.empty()) {
       shared_context_provider = shared_providers_->list.front();
       shared_command_buffer = shared_context_provider->command_buffer_.get();
       share_group = shared_context_provider->gles2_impl_->share_group();
       DCHECK_EQ(!!shared_command_buffer, !!share_group);
     }
 
     // This command buffer is a client-side proxy to the command buffer in the
     // GPU process.
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner =
-        default_task_runner_;
-    if (!task_runner)
-      task_runner = base::ThreadTaskRunnerHandle::Get();
     command_buffer_ = gpu::CommandBufferProxyImpl::Create(
         std::move(channel_), surface_handle_, shared_command_buffer, stream_id_,
         stream_priority_, attributes_, active_url_, task_runner);
     if (!command_buffer_) {
       DLOG(ERROR) << "GpuChannelHost failed to create command buffer.";
       command_buffer_metrics::UmaRecordContextInitFailed(context_type_);
       return false;
     }
 
     // The GLES2 helper writes the command buffer protocol.
@@ skipping 41 matching lines @@
     // share group and if a shared context is lost, our context will be informed
     // also, and the lost context callback will occur for the owner of the
     // context provider. If we check sooner, the shared context may be lost in
     // between these two states and our context here would be left in an orphan
     // share group.
     if (share_group && share_group->IsLost())
       return false;
 
     shared_providers_->list.push_back(this);
 
-    cache_controller_.reset(new cc::ContextCacheController(
-        gles2_impl_.get(), std::move(task_runner)));
+    cache_controller_.reset(
+        new cc::ContextCacheController(gles2_impl_.get(), task_runner));
   }
   set_bind_failed.Reset();
   bind_succeeded_ = true;
 
   gles2_impl_->SetLostContextCallback(
       base::Bind(&ContextProviderCommandBuffer::OnLostContext,
                  // |this| owns the GLES2Implementation which holds the
                  // callback.
                  base::Unretained(this)));
 
@@ skipping 13 matching lines @@
   ContextGL()->TraceBeginCHROMIUM("gpu_toplevel", unique_context_name.c_str());
   // If support_locking_ is true, the context may be used from multiple
   // threads, and any async callstacks will need to hold the same lock, so
   // give it to the command buffer and cache controller.
   // We don't hold a lock here since there's no need, so set the lock very last
   // to prevent asserts that we're not holding it.
   if (support_locking_) {
     command_buffer_->SetLock(&context_lock_);
     cache_controller_->SetLock(&context_lock_);
   }
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+      this, "ContextProviderCommandBuffer", std::move(task_runner));
   return true;
 }
 
 void ContextProviderCommandBuffer::DetachFromThread() {
   context_thread_checker_.DetachFromThread();
 }
 
 gpu::gles2::GLES2Interface* ContextProviderCommandBuffer::ContextGL() {
   DCHECK(bind_succeeded_);
   DCHECK(context_thread_checker_.CalledOnValidThread());
@@ skipping 70 matching lines @@
 }
 
 void ContextProviderCommandBuffer::SetLostContextCallback(
     const LostContextCallback& lost_context_callback) {
   DCHECK(context_thread_checker_.CalledOnValidThread());
   DCHECK(lost_context_callback_.is_null() ||
          lost_context_callback.is_null());
   lost_context_callback_ = lost_context_callback;
 }
 
+bool ContextProviderCommandBuffer::OnMemoryDump(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  if (!bind_succeeded_)

[ericrk, 2016/10/07 23:50:14]

per our discussion, this isn't needed (you only register if this succeeded).

[danakj, 2016/10/08 00:03:03]

Done.

+    return false;
+  if (!gr_context_)
+    return false;
+
+  base::Optional<base::AutoLock> hold;

[ericrk, 2016/10/07 23:50:14]

you may want to detach from thread here and at the end.

[danakj, 2016/10/08 00:03:03]

Done.

+  if (support_locking_)
+    hold.emplace(context_lock_);
+
+  SkiaGpuTraceMemoryDump trace_memory_dump(
+      pmd, gles2_impl_->ShareGroupTracingGUID());
+  gr_context_->get()->dumpMemoryStatistics(&trace_memory_dump);
+  return true;
+}
+
 }  // namespace content