[Chromoting] Use ProcessStatsSender in host process

remoting/host/client_session.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/client_session.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
+#include "base/optional.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "remoting/base/capabilities.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/logging.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/host_extension_session.h"
 #include "remoting/host/input_injector.h"
 #include "remoting/host/mouse_shape_pump.h"
+#include "remoting/host/process_stats_sender.h"
 #include "remoting/host/screen_controls.h"
 #include "remoting/host/screen_resolution.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/audio_stream.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/clipboard_thread_proxy.h"
 #include "remoting/protocol/pairing_registry.h"
 #include "remoting/protocol/session.h"
 #include "remoting/protocol/session_config.h"
@@ skipping 27 matching lines @@
       mouse_clamping_filter_(&remote_input_filter_),
       disable_input_filter_(&mouse_clamping_filter_),
       disable_clipboard_filter_(clipboard_echo_filter_.host_filter()),
       client_clipboard_factory_(clipboard_echo_filter_.client_filter()),
       max_duration_(max_duration),
       pairing_registry_(pairing_registry),
       // Note that |lossless_video_color_| defaults to true, but actually only
       // controls VP9 video stream color quality.
       lossless_video_color_(!base::CommandLine::ForCurrentProcess()->HasSwitch(
           kDisableI444SwitchName)),
+      current_process_stats_agent_("Network Process"),
       weak_factory_(this) {
   connection_->session()->AddPlugin(&host_experiment_session_plugin_);
   connection_->SetEventHandler(this);
 
   // Create a manager for the configured extensions, if any.
   extension_manager_.reset(new HostExtensionSessionManager(extensions, this));
 
 #if defined(OS_WIN)
   // LocalInputMonitorWin filters out an echo of the injected input before it
   // reaches |remote_input_filter_|.
@@ skipping 156 matching lines @@
     max_duration_timer_.Start(
         FROM_HERE, max_duration_,
         base::Bind(&ClientSession::DisconnectSession, base::Unretained(this),
                    protocol::MAX_SESSION_LENGTH));
   }
 
   // Notify EventHandler.
   event_handler_->OnSessionAuthenticated(this);
 
   DesktopEnvironmentOptions options = desktop_environment_options_;
-  options.ApplyHostSessionOptions(HostSessionOptions(
-      host_experiment_session_plugin_.configuration()));
+  const HostSessionOptions session_options(
+      host_experiment_session_plugin_.configuration());
+  options.ApplyHostSessionOptions(session_options);
   // Create the desktop environment. Drop the connection if it could not be
   // created for any reason (for instance the curtain could not initialize).
   desktop_environment_ =
       desktop_environment_factory_->Create(weak_factory_.GetWeakPtr(), options);
   if (!desktop_environment_) {
     DisconnectSession(protocol::HOST_CONFIGURATION_ERROR);
     return;
   }
 
   // Connect host stub.
   connection_->set_host_stub(this);
 
+  if (connection_->stats_stub()) {
+    base::Optional<int> track_process_stats_interval =
+        session_options.GetInt("Track-Process-Stats-Interval");
+    // Track-Process-Stats-Interval-Ms is for testing only, usually we should
+    // not set the interval as small as one second or less.
+    base::Optional<int> track_process_stats_interval_ms =
+        session_options.GetInt("Track-Process-Stats-Interval-Ms");
+    base::TimeDelta interval;
+    if (track_process_stats_interval && *track_process_stats_interval > 0) {
+      interval = base::TimeDelta::FromSeconds(*track_process_stats_interval);
+    } else if (track_process_stats_interval_ms &&
+               *track_process_stats_interval_ms > 0) {
+      interval = base::TimeDelta::FromMilliseconds(
+          *track_process_stats_interval_ms);
+    }
+    if (interval > base::TimeDelta()) {
+      // TODO(zijiehe): Add ForwardProcessStatsAgent from DesktopEnvironment.
+      stats_sender_.reset(new ProcessStatsSender(
+          connection_->stats_stub(),
+          interval,
+          { &current_process_stats_agent_ }));
+    }
+  }
+
   // Collate the set of capabilities to offer the client, if it supports them.
   host_capabilities_ = desktop_environment_->GetCapabilities();
   if (!host_capabilities_.empty())
     host_capabilities_.append(" ");
   host_capabilities_.append(extension_manager_->GetCapabilities());
 
   // Create the object that controls the screen resolution.
   screen_controls_ = desktop_environment_->CreateScreenControls();
 
   // Create the event executor.
@@ skipping 83 matching lines @@
 
   // Stop components access the client, audio or video stubs, which are no
   // longer valid once ConnectionToClient calls OnConnectionClosed().
   audio_stream_.reset();
   video_stream_.reset();
   mouse_shape_pump_.reset();
   client_clipboard_factory_.InvalidateWeakPtrs();
   input_injector_.reset();
   screen_controls_.reset();
   desktop_environment_.reset();
+  stats_sender_.reset();
 
   // Notify the ChromotingHost that this client is disconnected.
   event_handler_->OnSessionClosed(this);
 }
 
 void ClientSession::OnRouteChange(
     const std::string& channel_name,
     const protocol::TransportRoute& route) {
   DCHECK(CalledOnValidThread());
   event_handler_->OnSessionRouteChange(this, channel_name, route);
@@ skipping 93 matching lines @@
         connection_->client_stub()->SetVideoLayout(layout);
       } else {
         pending_video_layout_message_.reset(new protocol::VideoLayout(layout));
       }
       break;
     }
   }
 }
 
 }  // namespace remoting