[Chromoting] Use ProcessStatsSender in DesktopSessionAgent (desktop process)

remoting/host/desktop_session_agent.cc

 // Copyright (c) 2012 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 <utility>
 
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/process/process_handle.h"
+#include "base/time/time.h"
 #include "build/build_config.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/input_injector.h"
+#include "remoting/host/process_stats_sender.h"
 #include "remoting/host/remote_input_filter.h"
 #include "remoting/host/screen_controls.h"
 #include "remoting/host/screen_resolution.h"
 #include "remoting/proto/audio.pb.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/errors.h"
 #include "remoting/protocol/input_event_tracker.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
@@ skipping 121 matching lines @@
 
 DesktopSessionAgent::DesktopSessionAgent(
     scoped_refptr<AutoThreadTaskRunner> audio_capture_task_runner,
     scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
     scoped_refptr<AutoThreadTaskRunner> input_task_runner,
     scoped_refptr<AutoThreadTaskRunner> io_task_runner)
     : audio_capture_task_runner_(audio_capture_task_runner),
       caller_task_runner_(caller_task_runner),
       input_task_runner_(input_task_runner),
       io_task_runner_(io_task_runner),
+      current_process_stats_("DesktopSessionAgent"),
       weak_factory_(this) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 }
 
 bool DesktopSessionAgent::OnMessageReceived(const IPC::Message& message) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   bool handled = true;
   if (started_) {
     IPC_BEGIN_MESSAGE_MAP(DesktopSessionAgent, message)
       IPC_MESSAGE_HANDLER(ChromotingNetworkDesktopMsg_CaptureFrame,
                           OnCaptureFrame)
       IPC_MESSAGE_HANDLER(ChromotingNetworkDesktopMsg_InjectClipboardEvent,
                           OnInjectClipboardEvent)
       IPC_MESSAGE_HANDLER(ChromotingNetworkDesktopMsg_InjectKeyEvent,
                           OnInjectKeyEvent)
       IPC_MESSAGE_HANDLER(ChromotingNetworkDesktopMsg_InjectTextEvent,
                           OnInjectTextEvent)
       IPC_MESSAGE_HANDLER(ChromotingNetworkDesktopMsg_InjectMouseEvent,
                           OnInjectMouseEvent)
       IPC_MESSAGE_HANDLER(ChromotingNetworkDesktopMsg_InjectTouchEvent,
                           OnInjectTouchEvent)
       IPC_MESSAGE_HANDLER(ChromotingNetworkDesktopMsg_SetScreenResolution,
                           SetScreenResolution)
+      IPC_MESSAGE_HANDLER(ChromotingNetworkMsg_StartProcessStatsReport,
+                          StartProcessStatsReport)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
   } else {
     IPC_BEGIN_MESSAGE_MAP(DesktopSessionAgent, message)
       IPC_MESSAGE_HANDLER(ChromotingNetworkDesktopMsg_StartSessionAgent,
                           OnStartSessionAgent)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
   }
 
@@ skipping 17 matching lines @@
   if (delegate_.get())
     delegate_->OnNetworkProcessDisconnected();
 }
 
 DesktopSessionAgent::~DesktopSessionAgent() {
   DCHECK(!audio_capturer_);
   DCHECK(!desktop_environment_);
   DCHECK(!network_channel_);
   DCHECK(!screen_controls_);
   DCHECK(!video_capturer_);
+  DCHECK(!stats_sender_);
 }
 
 const std::string& DesktopSessionAgent::client_jid() const {
   return client_jid_;
 }
 
 void DesktopSessionAgent::DisconnectSession(protocol::ErrorCode error) {
   SendToNetwork(
       base::MakeUnique<ChromotingDesktopNetworkMsg_DisconnectSession>(error));
 }
 
 void DesktopSessionAgent::OnLocalMouseMoved(
     const webrtc::DesktopVector& new_pos) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   remote_input_filter_->LocalMouseMoved(new_pos);
 }
 
 void DesktopSessionAgent::SetDisableInputs(bool disable_inputs) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Do not expect this method to be called because it is only used by It2Me.
   NOTREACHED();
 }
 
+void DesktopSessionAgent::OnProcessStats(
+    const protocol::AggregatedProcessResourceUsage& usage) {
+  SendToNetwork(
+      base::MakeUnique<ChromotingNetworkMsg_ReportProcessStats>(usage));
+}
+
 void DesktopSessionAgent::OnStartSessionAgent(
     const std::string& authenticated_jid,
     const ScreenResolution& resolution,
     const remoting::DesktopEnvironmentOptions& options) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   DCHECK(!started_);
   DCHECK(!audio_capturer_);
   DCHECK(!desktop_environment_);
   DCHECK(!input_injector_);
   DCHECK(!screen_controls_);
@@ skipping 112 matching lines @@
     return;
   }
 
   SendToNetwork(base::MakeUnique<ChromotingDesktopNetworkMsg_AudioPacket>(
       serialized_packet));
 }
 
 mojo::ScopedMessagePipeHandle DesktopSessionAgent::Start(
     const base::WeakPtr<Delegate>& delegate) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
-  DCHECK(delegate_.get() == nullptr);
+  DCHECK(delegate);
+  DCHECK(!delegate_);
 
   delegate_ = delegate;
 
   mojo::MessagePipe pipe;
   network_channel_ = IPC::ChannelProxy::Create(
       pipe.handle0.release(), IPC::Channel::MODE_SERVER, this, io_task_runner_);
   return std::move(pipe.handle1);
 }
 
 void DesktopSessionAgent::Stop() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   delegate_.reset();
 
+  stats_sender_.reset();
+
   // Make sure the channel is closed.
   network_channel_.reset();
 
   if (started_) {
     started_ = false;
 
     // Ignore any further callbacks.
     weak_factory_.InvalidateWeakPtrs();
     client_jid_.clear();
 
@@ skipping 143 matching lines @@
                                       this));
   }
 }
 
 void DesktopSessionAgent::StopAudioCapturer() {
   DCHECK(audio_capture_task_runner_->BelongsToCurrentThread());
 
   audio_capturer_.reset();
 }
 
+void DesktopSessionAgent::StartProcessStatsReport(int interval_ms) {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+

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

I think it is worth a DCHECK here if you do not intend to receive this message
multiple times (you would need to handle 'StopSending' messages as well but I
think that is a good idea anyway).

Since this is in an IPC handler, you will still want to protect against the
message being sent twice in release builds so the if(!stats_sender_) check is ok
to leave in with the DCHECK.

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

Done.

+  if (!stats_sender_) {
+    if (interval_ms <= 0) {
+      interval_ms = 2000;
+    }
+
+    stats_sender_.reset(new ProcessStatsSender(
+        this,
+        base::TimeDelta::FromMilliseconds(interval_ms),
+        { &current_process_stats_ }));
+  }
+}
+
 }  // namespace remoting