[Chromoting] Use ProcessStatsSender in DesktopSessionAgent (desktop process)

remoting/host/desktop_session_agent.h

 // 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.
 
 #ifndef REMOTING_HOST_DESKTOP_SESSION_AGENT_H_
 #define REMOTING_HOST_DESKTOP_SESSION_AGENT_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
+#include "base/time/time.h"
 #include "ipc/ipc_listener.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 #include "remoting/host/client_session_control.h"
+#include "remoting/host/current_process_stats_agent.h"
 #include "remoting/host/desktop_environment_options.h"
 #include "remoting/protocol/clipboard_stub.h"
+#include "remoting/protocol/process_stats_stub.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor_monitor.h"
 
 namespace IPC {
 class ChannelProxy;
 class Message;
 }  // namespace IPC
 
 namespace remoting {
 
 class AudioCapturer;
 class AudioPacket;
 class AutoThreadTaskRunner;
 class DesktopEnvironment;
 class DesktopEnvironmentFactory;
 class InputInjector;
+class ProcessStatsSender;
 class RemoteInputFilter;
 class ScreenControls;
 class ScreenResolution;
 
 namespace protocol {
 class InputEventTracker;
 }  // namespace protocol
 
 // Provides screen/audio capturing and input injection services for
 // the network process.
 class DesktopSessionAgent
     : public base::RefCountedThreadSafe<DesktopSessionAgent>,
       public IPC::Listener,
       public webrtc::DesktopCapturer::Callback,
       public webrtc::MouseCursorMonitor::Callback,
-      public ClientSessionControl {
+      public ClientSessionControl,
+      public protocol::ProcessStatsStub {
  public:
   class Delegate {
    public:
     virtual ~Delegate();
 
     // Returns an instance of desktop environment factory used.
     virtual DesktopEnvironmentFactory& desktop_environment_factory() = 0;
 
     // Notifies the delegate that the network-to-desktop channel has been
     // disconnected.
@@ skipping 38 matching lines @@
   friend class base::RefCountedThreadSafe<DesktopSessionAgent>;
 
   ~DesktopSessionAgent() override;
 
   // ClientSessionControl interface.
   const std::string& client_jid() const override;
   void DisconnectSession(protocol::ErrorCode error) override;
   void OnLocalMouseMoved(const webrtc::DesktopVector& position) override;
   void SetDisableInputs(bool disable_inputs) override;
 
+  // ProcessStatsStub interface.
+  void OnProcessStats(
+      const protocol::AggregatedProcessResourceUsage& usage) override;
+
   // Handles StartSessionAgent request from the client.
   void OnStartSessionAgent(const std::string& authenticated_jid,
                            const ScreenResolution& resolution,
                            const DesktopEnvironmentOptions& options);
 
   // Handles CaptureFrame requests from the client.
   void OnCaptureFrame();
 
   // Handles event executor requests from the client.
   void OnInjectClipboardEvent(const std::string& serialized_event);
   void OnInjectKeyEvent(const std::string& serialized_event);
   void OnInjectTextEvent(const std::string& serialized_event);
   void OnInjectMouseEvent(const std::string& serialized_event);
   void OnInjectTouchEvent(const std::string& serialized_event);
 
   // Handles ChromotingNetworkDesktopMsg_SetScreenResolution request from
   // the client.
   void SetScreenResolution(const ScreenResolution& resolution);
 
   // Sends a message to the network process.
   void SendToNetwork(std::unique_ptr<IPC::Message> message);
 
   // Posted to |audio_capture_task_runner_| to start the audio capturer.
   void StartAudioCapturer();
 
   // Posted to |audio_capture_task_runner_| to stop the audio capturer.
   void StopAudioCapturer();
 
+  // Starts to report process statistic data to network process. If
+  // |interval| is less than or equal to 0, a default non-zero value will be
+  // used.
+  void StartProcessStatsReport(base::TimeDelta interval);
+
+  // Stops sending process statistic data to network process.
+  void StopProcessStatsReport();
+
  private:
   // Task runner dedicated to running methods of |audio_capturer_|.
   scoped_refptr<AutoThreadTaskRunner> audio_capture_task_runner_;
 
   // Task runner on which public methods of this class should be called.
   scoped_refptr<AutoThreadTaskRunner> caller_task_runner_;
 
   // Task runner on which keyboard/mouse input is injected.
   scoped_refptr<AutoThreadTaskRunner> input_task_runner_;
 
@@ skipping 31 matching lines @@
   // Captures the screen.
   std::unique_ptr<webrtc::DesktopCapturer> video_capturer_;
 
   // Captures mouse shapes.
   std::unique_ptr<webrtc::MouseCursorMonitor> mouse_cursor_monitor_;
 
   // Keep reference to the last frame sent to make sure shared buffer is alive
   // before it's received.
   std::unique_ptr<webrtc::DesktopFrame> last_frame_;
 
+  // Reports process statistic data to network process.
+  std::unique_ptr<ProcessStatsSender> stats_sender_;
+
+  CurrentProcessStatsAgent current_process_stats_;
+
   // Used to disable callbacks to |this|.
   base::WeakPtrFactory<DesktopSessionAgent> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DesktopSessionAgent);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_DESKTOP_SESSION_AGENT_H_