Refactoring and rewriting the chromoting jni instance to be chromoting session.

remoting/client/ios/bridge/client_instance.cc

 // 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.
 
 #include "remoting/client/ios/bridge/client_instance.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/socket/client_socket_factory.h"
 #include "remoting/base/chromium_url_request.h"
 #include "remoting/base/url_request_context_getter.h"
 #include "remoting/client/audio_player.h"
-#include "remoting/client/client_status_logger.h"
+//#include "remoting/client/client_status_logger.h"
 #include "remoting/client/ios/bridge/client_proxy.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/chromium_port_allocator_factory.h"
 #include "remoting/protocol/client_authentication_config.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/negotiating_client_authenticator.h"
 #include "remoting/protocol/transport_context.h"
 #include "remoting/signaling/delegating_signal_strategy.h"
 
 
 //#include "remoting/client/ios/audio_player_buffer.h"  // TODO(nicholss): need
 // to also pull in the player and attach to buffer.
 
 // TODO(nicholss): There is another client instance used by android. Need to
 // merge the two.
 
 namespace {
 const char* const kXmppServer = "talk.google.com";
-const char kDirectoryBotJid[] = "remoting@bot.talk.google.com";
+// const char kDirectoryBotJid[] = "remoting@bot.talk.google.com";
 }  // namespace
 
 namespace remoting {
 
 ClientInstance::ClientInstance(const base::WeakPtr<ClientProxy>& proxy,
                                const std::string& username,
                                const std::string& auth_token,
                                const std::string& host_jid,
                                const std::string& host_id,
                                const std::string& host_pubkey)
@@ skipping 137 matching lines @@
   protocol::KeyEvent action;
   action.set_usb_keycode(key_code);
   action.set_pressed(key_down);
   client_->input_stub()->InjectKeyEvent(action);
 }
 
 void ClientInstance::OnConnectionState(protocol::ConnectionToHost::State state,
                                        protocol::ErrorCode error) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
-  client_status_logger_->LogSessionStateChange(state, error);
+  //  client_status_logger_->LogSessionStateChange(state, error);
 
   ui_task_runner_->PostTask(
       FROM_HERE, base::Bind(&ClientInstance::HandleConnectionStateOnUIThread,
                             this, state, error));
 }
 
 void ClientInstance::OnConnectionReady(bool ready) {
   // We ignore this message, since OnConnectionState tells us the same thing.
 }
 
@@ skipping 75 matching lines @@
 
   client_.reset(new ChromotingClient(
       client_context_.get(), this, video_renderer_.get(),
       nullptr  // TODO(nicholss): GetAudioConsumer().get()
       ));
 
   signaling_.reset(
       new XmppSignalStrategy(net::ClientSocketFactory::GetDefaultFactory(),
                              url_requester_, xmpp_config_));
 
-  client_status_logger_.reset(new ClientStatusLogger(
-      ServerLogEntry::ME2ME, signaling_.get(), kDirectoryBotJid));
+  // client_status_logger_.reset(new ClientStatusLogger(
+  //     ServerLogEntry::ME2ME, signaling_.get(), kDirectoryBotJid));
 
   protocol::NetworkSettings network_settings(
       protocol::NetworkSettings::NAT_TRAVERSAL_FULL);
 
   // Use Chrome's network stack to allocate ports for peer-to-peer channels.
 
   scoped_refptr<protocol::TransportContext> transport_context =
       new protocol::TransportContext(
           signaling_.get(),
           base::WrapUnique(new protocol::ChromiumPortAllocatorFactory()),
@@ skipping 15 matching lines @@
 //   }
 //
 //   return audio_player_->GetAudioConsumer();
 // }
 
 void ClientInstance::DisconnectFromHostOnNetworkThread() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   // |client_| must be torn down before |signaling_|.
   client_.reset();
-  client_status_logger_.reset();
+  //  client_status_logger_.reset();
   signaling_.reset();
   perf_tracker_.reset();
   //  audio_consumer_->reset(); // TODO(nicholss): Or should this be a call to
   //  Stop?
   //  audio_player_->reset();   // TODO(nicholss): Or should this be a call to
   //  Stop?
   video_renderer_.reset();
   client_context_->Stop();
 }
 
@@ skipping 16 matching lines @@
     return;
   }
 
   VLOG(1) << "Attempting to pair with host";
   protocol::PairingRequest request;
   request.set_client_name(device_id_);
   client_->host_stub()->RequestPairing(request);
 }
 
 }  // namespace remoting