Mojo interface/service for Leak Detector on remote process

chrome/renderer/leak_detector_remote_client.cc

Index: chrome/renderer/leak_detector_remote_client.cc
diff --git a/chrome/renderer/leak_detector_remote_client.cc b/chrome/renderer/leak_detector_remote_client.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b74c89601bc15883c2b99fce6fb38fed7991d9d6
--- /dev/null
+++ b/chrome/renderer/leak_detector_remote_client.cc
@@ -0,0 +1,71 @@
+// 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 "chrome/renderer/leak_detector_remote_client.h"
+
+#include "base/bind.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "components/metrics/proto/memory_leak_report.pb.h"
+#include "content/public/common/service_registry.h"
+#include "content/public/renderer/render_thread.h"
+#include "mojo/public/cpp/bindings/interface_request.h"
+
+LeakDetectorRemoteClient::LeakDetectorRemoteClient() {
+  // Connect to Mojo service.
+  content::RenderThread::Get()->GetServiceRegistry()->ConnectToRemoteService(
+      mojo::GetProxy(&remote_service_));
+
+  // It is safe to use "base::Unretained(this)" because |this| owns
+  // |remote_service_|. See example at:
+  // https://www.chromium.org/developers/design-documents/mojo/validation
+  remote_service_->GetParams(
+      base::Bind(&LeakDetectorRemoteClient::OnParamsReceived,
+                 base::Unretained(this)));
+}
+
+LeakDetectorRemoteClient::~LeakDetectorRemoteClient() {
+  metrics::LeakDetector::GetInstance()->RemoveObserver(this);
+}
+
+void LeakDetectorRemoteClient::OnParamsReceived(
+    mojo::StructPtr<metrics::mojom::LeakDetectorParams> result) {
+  metrics::MemoryLeakReportProto::Params params;
+  params.set_sampling_rate(result->sampling_rate);
+  params.set_max_stack_depth(result->max_stack_depth);
+  params.set_analysis_interval_bytes(result->analysis_interval_bytes);
+  params.set_size_suspicion_threshold(result->size_suspicion_threshold);
+  params.set_call_stack_suspicion_threshold(
+      result->call_stack_suspicion_threshold);
+
+  metrics::LeakDetector* detector = metrics::LeakDetector::GetInstance();
+  detector->AddObserver(this);
+  detector->Init(params, base::ThreadTaskRunnerHandle::Get());
+}
+
+void LeakDetectorRemoteClient::OnLeaksFound(
+    const std::vector<metrics::MemoryLeakReportProto>& reports) {
+  mojo::Array<mojo::StructPtr<metrics::mojom::MemoryLeakReport>> result;
+
+  for (const metrics::MemoryLeakReportProto& report : reports) {
+    metrics::mojom::MemoryLeakReportPtr mojo_report =
+        metrics::mojom::MemoryLeakReport::New();
+    mojo_report->size_bytes = report.size_bytes();
+    for (auto call_stack_value : report.call_stack()) {
+      mojo_report->call_stack.push_back(call_stack_value);
+    }
+    for (const auto& history_entry : report.alloc_breakdown_history()) {
+      metrics::mojom::AllocationBreakdownPtr mojo_entry =
+          metrics::mojom::AllocationBreakdown::New();
+      for (auto count : history_entry.counts_by_size()) {
+        mojo_entry->counts_by_size.push_back(count);
+      }
+      mojo_entry->count_for_call_stack = history_entry.count_for_call_stack();
+
+      mojo_report->alloc_breakdown_history.push_back(std::move(mojo_entry));
+    }
+    result.push_back(std::move(mojo_report));
+  }
+
+  remote_service_->SendLeakReports(std::move(result));
+}