[Chromoting] Use ProcessStatsSender in DesktopSessionAgent (desktop process)

remoting/host/desktop_session_agent_unittest.cc

Index: remoting/host/desktop_session_agent_unittest.cc
diff --git a/remoting/host/desktop_session_agent_unittest.cc b/remoting/host/desktop_session_agent_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5f2277a89d9c4d3df013ec1e7fe0644afc207e91
--- /dev/null
+++ b/remoting/host/desktop_session_agent_unittest.cc
@@ -0,0 +1,127 @@
+// 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/desktop_session_agent.h"
+
+#include <memory>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
+#include "ipc/ipc_channel_proxy.h"
+#include "ipc/ipc_listener.h"
+#include "remoting/base/auto_thread_task_runner.h"
+#include "remoting/host/chromoting_messages.h"
+#include "remoting/host/desktop_environment_options.h"
+#include "remoting/host/fake_desktop_environment.h"
+#include "remoting/host/screen_resolution.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace remoting {
+
+namespace {
+
+class MockDelegate : public DesktopSessionAgent::Delegate {
+ public:
+  MockDelegate(scoped_refptr<base::SingleThreadTaskRunner> runner);
+  ~MockDelegate() override = default;
+
+  DesktopEnvironmentFactory& desktop_environment_factory() override {
+    return factory_;
+  }
+
+  void OnNetworkProcessDisconnected() override {}
+
+  base::WeakPtr<Delegate> GetWeakPtr() { return weak_ptr_.GetWeakPtr(); }
+
+ private:
+  FakeDesktopEnvironmentFactory factory_;
+
+  base::WeakPtrFactory<MockDelegate> weak_ptr_;
+};
+
+MockDelegate::MockDelegate(scoped_refptr<base::SingleThreadTaskRunner> runner)
+    : factory_(runner),
+      weak_ptr_(this) {}
+
+class ProcessStatsListener : public IPC::Listener {
+ public:
+  ProcessStatsListener(base::Closure action_after_received)
+      : action_after_received_(action_after_received) {}
+
+  ~ProcessStatsListener() override = default;
+
+ private:
+  // IPC::Listener implementation.
+  bool OnMessageReceived(const IPC::Message& message) override;
+
+  void OnProcessResourceUsage(
+      const remoting::protocol::AggregatedProcessResourceUsage& usage);
+
+  const base::Closure action_after_received_;
+};
+
+bool ProcessStatsListener::OnMessageReceived(const IPC::Message& message) {
+  bool handled = false;
+  IPC_BEGIN_MESSAGE_MAP(ProcessStatsListener, message)
+    IPC_MESSAGE_HANDLER(ChromotingNetworkMsg_ReportProcessStats,
+                        OnProcessResourceUsage);
+    IPC_MESSAGE_UNHANDLED(handled = false);
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void ProcessStatsListener::OnProcessResourceUsage(
+    const remoting::protocol::AggregatedProcessResourceUsage& usage) {
+  action_after_received_.Run();
+}
+
+}  // namespace
+
+TEST(DesktopSessionAgentTest, StartProcessStatsReport) {

[joedow, 2017/06/13 20:12:12]

I think this test is doing too much.  Can you move the non-test related logic
into a setup method.

Whitespace and comments would make this a lot more readable as well.

[Hzj_jie, 2017/06/14 23:12:23]

Done.

+  base::MessageLoop message_loop;
+  base::RunLoop run_loop;
+  scoped_refptr<AutoThreadTaskRunner> task_runner =
+      new AutoThreadTaskRunner(
+          message_loop.task_runner(), run_loop.QuitClosure());
+  std::unique_ptr<MockDelegate> delegate(new MockDelegate(task_runner));
+  scoped_refptr<DesktopSessionAgent> agent(new DesktopSessionAgent(
+      task_runner, task_runner, task_runner, task_runner));
+  std::unique_ptr<IPC::ChannelProxy> proxy;
+  ProcessStatsListener listener(base::Bind([](
+          scoped_refptr<AutoThreadTaskRunner>* task_runner,
+          std::unique_ptr<MockDelegate>* delegate,
+          scoped_refptr<DesktopSessionAgent>* agent,
+          std::unique_ptr<IPC::ChannelProxy>* proxy) {
+        task_runner->operator=(nullptr);
+        delegate->reset();
+        (*agent)->Stop();
+        agent->operator=(nullptr);
+        proxy->reset();
+        ASSERT_FALSE(static_cast<bool>(*task_runner));
+        ASSERT_FALSE(static_cast<bool>(*delegate));
+        ASSERT_FALSE(static_cast<bool>(*agent));
+        ASSERT_FALSE(static_cast<bool>(*proxy));
+      },
+      base::Unretained(&task_runner),
+      base::Unretained(&delegate),
+      base::Unretained(&agent),
+      base::Unretained(&proxy)));
+  proxy = IPC::ChannelProxy::Create(
+      agent->Start(delegate->GetWeakPtr()).release(),
+      IPC::Channel::MODE_CLIENT,
+      &listener,
+      task_runner);
+  ASSERT_TRUE(proxy->Send(new ChromotingNetworkDesktopMsg_StartSessionAgent(
+      "jid", ScreenResolution(), DesktopEnvironmentOptions())));
+  ASSERT_TRUE(proxy->Send(new ChromotingNetworkMsg_StartProcessStatsReport(1)));
+  task_runner = nullptr;
+  run_loop.Run();
+}
+
+}  // namespace remoting