[Remoting Android] Refactor ClientTelemetryLogger

remoting/client/jni/chromoting_jni_instance.h

 // Copyright 2013 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_JNI_CHROMOTING_JNI_INSTANCE_H_
 #define REMOTING_CLIENT_JNI_CHROMOTING_JNI_INSTANCE_H_
 
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "remoting/client/chromoting_client.h"
 #include "remoting/client/client_context.h"
+#include "remoting/client/client_telemetry_logger.h"
 #include "remoting/client/client_user_interface.h"
+#include "remoting/client/jni/connect_to_host_info.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/cursor_shape_stub.h"
 #include "remoting/signaling/xmpp_signal_strategy.h"
 
 namespace remoting {
 
 namespace protocol {
 class ClipboardEvent;
@@ skipping 15 matching lines @@
     public protocol::ClipboardStub {
  public:
   // Initiates a connection with the specified host. Call from the UI thread.
   // The instance does not take ownership of |jni_runtime|. To connect with an
   // unpaired host, pass in |pairing_id| and |pairing_secret| as empty strings.
   ChromotingJniInstance(ChromotingJniRuntime* jni_runtime,
                         base::WeakPtr<JniClient> jni_client,
                         base::WeakPtr<JniPairingSecretFetcher> secret_fetcher,
                         std::unique_ptr<protocol::CursorShapeStub> cursor_stub,
                         std::unique_ptr<protocol::VideoRenderer> video_renderer,
-                        const std::string& username,
-                        const std::string& auth_token,
-                        const std::string& host_jid,
-                        const std::string& host_id,
-                        const std::string& host_pubkey,
-                        const std::string& pairing_id,
-                        const std::string& pairing_secret,
-                        const std::string& capabilities,
-                        const std::string& flags,
-                        const std::string& host_version,
-                        const std::string& host_os,
-                        const std::string& host_os_version);
+                        const ConnectToHostInfo& info);
 
   ~ChromotingJniInstance() override;
 
   // Starts the connection. Can be called on any thread.
   void Connect();
 
   // Terminates the current connection (if it hasn't already failed) and cleans
   // up. The instance will no longer be valid after calling this function.
   // Must be called before destruction.
   void Disconnect();
@@ skipping 76 matching lines @@
   // Releases the resource in the right order.
   void ReleaseResources();
 
   // Used to obtain task runner references and make calls to Java methods.
   ChromotingJniRuntime* jni_runtime_;
 
   base::WeakPtr<JniClient> jni_client_;
 
   base::WeakPtr<JniPairingSecretFetcher> secret_fetcher_;
 
-  // ID of the host we are connecting to.
-  std::string host_jid_;
+  ConnectToHostInfo connection_info_;
 
   protocol::ClientAuthenticationConfig client_auth_config_;
 
-  std::string flags_;
-
   // This group of variables is to be used on the network thread.
   std::unique_ptr<ClientContext> client_context_;
   std::unique_ptr<protocol::PerformanceTracker> perf_tracker_;
   std::unique_ptr<protocol::CursorShapeStub> cursor_shape_stub_;
   std::unique_ptr<protocol::VideoRenderer> video_renderer_;
   std::unique_ptr<ChromotingClient> client_;
   XmppSignalStrategy::XmppServerConfig xmpp_config_;
   std::unique_ptr<XmppSignalStrategy> signaling_;  // Must outlive client_
   protocol::ThirdPartyTokenFetchedCallback third_party_token_fetched_callback_;
 
@@ skipping 15 matching lines @@
 
   // The set of capabilities supported by the client. Accessed on the network
   // thread. Once SetCapabilities() is called, this will contain the negotiated
   // set of capabilities for this remoting session.
   std::string capabilities_;
 
   // Indicates whether the client is connected to the host. Used on network
   // thread.
   bool connected_ = false;
 
-  // TODO(BUG 680752): Remove these.
-  std::string host_version_;
-  std::string host_os_;
-  std::string host_os_version_;
+  std::unique_ptr<ClientTelemetryLogger> logger_;
 
   base::WeakPtr<ChromotingJniInstance> weak_ptr_;
   base::WeakPtrFactory<ChromotingJniInstance> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromotingJniInstance);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_CLIENT_JNI_CHROMOTING_JNI_INSTANCE_H_