[Chromoting] Retrieve process resource usage (ProcessStats) and its tests

remoting/host/process_stats_sender.cc

Index: remoting/host/process_stats_sender.cc
diff --git a/remoting/host/process_stats_sender.cc b/remoting/host/process_stats_sender.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3db8b8e0fba055f813efba955ad00f1938312060
--- /dev/null
+++ b/remoting/host/process_stats_sender.cc
@@ -0,0 +1,54 @@
+// Copyright 2017 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 "remoting/host/process_stats_sender.h"
+
+#include <utility>
+
+#include "base/location.h"
+#include "base/logging.h"
+#include "remoting/host/process_stats_util.h"
+
+namespace remoting {
+
+ProcessStatsSender::ProcessStatsSender(
+    protocol::ProcessStatsStub* host_stats_stub,
+    base::TimeDelta interval)
+    : host_stats_stub_(host_stats_stub), interval_(interval) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(host_stats_stub_);
+  DCHECK(!interval_.is_zero());
+
+  timer_.Start(FROM_HERE, interval_, this, &ProcessStatsSender::ReportUsage);
+}
+
+ProcessStatsSender::~ProcessStatsSender() {
+  DCHECK(thread_checker_.CalledOnValidThread());

[joedow, 2017/04/24 17:16:08]

nit: You don't need this DCHECK as thread_checker_ will DCHECK on its own when
it is destroyed.

[Hzj_jie, 2017/04/25 00:17:53]

https://cs.chromium.org/chromium/src/base/threading/thread_checker_impl.cc?rc...
It looks like the destructor of ThreadCheckerImpl is an no-op.

[joedow, 2017/04/25 15:57:27]

The ThreadChecker class contains a 'SequenceToken' member which has a DCHECK in
its d'tor that will trigger if it is destroyed on a different thread than its
affinity.

[Hzj_jie, 2017/04/25 22:19:19]

SequenceToken has no destructor. Have I misunderstood something?
But the design you have described seems not correct, what if a class using
ThreadChecker is designed to be destructed in a different thread?

[Sergey Ulanov, 2017/04/26 05:42:44]

I think you are right. I thought myself that ThreadChecker had this check in the
destructor (because NonThreadSafe has it) and with some of my CL comments on
other CLs led Joe to believe it as well.

[joedow, 2017/04/26 16:07:57]

I was looking at ScopedSequenceToken :(  I did a quick test and no DCHECKs are
done when ThreadChecker is destroyed.  I am going to file a bug to fix up the
rest of the classes where we want this protection but don't have it.

Thanks for pointing this out Zijie!

[Hzj_jie, 2017/04/26 20:47:19]

:)

+  timer_.Stop();
+}
+
+void ProcessStatsSender::AddProcessStatsAgent(
+    std::unique_ptr<ProcessStatsAgent> agent) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  agents_.push_back(std::move(agent));
+}
+
+void ProcessStatsSender::ReportUsage() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (agents_.empty()) {
+    return;
+  }
+
+  std::vector<protocol::ProcessResourceUsage> usages;
+  for (const auto& agent : agents_) {
+    protocol::ProcessResourceUsage usage = agent->GetResourceUsage();
+    if (!IsEmptyProcessResourceUsage(usage)) {
+      usages.push_back(std::move(usage));
+    }
+  }
+
+  host_stats_stub_->OnProcessStats(AggregateProcessResourceUsage(usages));
+}
+
+}  // namespace remoting