[Chromoting.com] Make Android telemetry report host version/os/os version

remoting/client/client_telemetry_logger.h

 // Copyright 2016 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_CLIENT_CLIENT_TELEMETRY_LOGGER_H_
 #define REMOTING_CLIENT_CLIENT_TELEMETRY_LOGGER_H_
 
 #include <memory>
 #include <string>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "remoting/base/chromoting_event.h"
 #include "remoting/base/chromoting_event_log_writer.h"
 #include "remoting/base/url_request.h"
 #include "remoting/protocol/connection_to_host.h"
 #include "remoting/protocol/performance_tracker.h"
 
 namespace remoting {
 
 // ClientTelemetryLogger sends client log entries to the telemetry server.
 // The logger should be run entirely on one single thread.
 // TODO(yuweih): Implement new features that session_logger.js provides.
+// TODO(BUG 680752): Refactor this so that it's bound to only one session.
 class ClientTelemetryLogger {
  public:
   explicit ClientTelemetryLogger(ChromotingEvent::Mode mode);
   ~ClientTelemetryLogger();
 
+  // Sets the host info to be posted along with other log data. By default
+  // no host info will be logged.
+  void SetHostInfo(const std::string& host_version,
+                   ChromotingEvent::Os host_os,
+                   const std::string& host_os_version);
+
   // Start must be called before posting logs or setting auth token or closure.
   void Start(std::unique_ptr<UrlRequestFactory> request_factory,
              const std::string& telemetry_base_url);
 
   void LogSessionStateChange(ChromotingEvent::SessionState state,
                              ChromotingEvent::ConnectionError error);
 
   // TODO(yuweih): Investigate possibility of making PerformanceTracker const.
   void LogStatistics(protocol::PerformanceTracker* perf_tracker);
 
@@ skipping 18 matching lines @@
   // after calling this function.
   void StartForTest(std::unique_ptr<ChromotingEventLogWriter> writer);
 
   static ChromotingEvent::SessionState TranslateState(
       protocol::ConnectionToHost::State state);
 
   static ChromotingEvent::ConnectionError TranslateError(
       protocol::ErrorCode state);
 
  private:
+  struct HostInfo;
 
   void FillEventContext(ChromotingEvent* event) const;
 
   // Generates a new random session ID.
   void GenerateSessionId();
 
   // Expire the session ID if the maximum duration has been exceeded.
   // Sends SessionIdOld and SessionIdNew events describing the change of id.
   void ExpireSessionIdIfOutdated();
 
   ChromotingEvent MakeStatsEvent(protocol::PerformanceTracker* perf_tracker);
   ChromotingEvent MakeSessionStateChangeEvent(
       ChromotingEvent::SessionState state,
       ChromotingEvent::ConnectionError error);
   ChromotingEvent MakeSessionIdOldEvent();
   ChromotingEvent MakeSessionIdNewEvent();
 
   // A randomly generated session ID to be attached to log messages. This
   // is regenerated at the start of a new session.
   std::string session_id_;
 
   base::TimeTicks session_start_time_;
 
   base::TimeTicks session_id_generation_time_;
 
   ChromotingEvent::Mode mode_;
 
+  std::unique_ptr<HostInfo> host_info_;
+
   // The log writer that actually sends log to the server.
   std::unique_ptr<ChromotingEventLogWriter> log_writer_;
 
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientTelemetryLogger);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_CLIENT_CLIENT_TELEMETRY_LOGGER_H_