Conenct Chromoting plugin debug log to JS UI.

remoting/host/chromoting_host.cc

 // Copyright (c) 2011 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/chromoting_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/logging.h"
 #include "build/build_config.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/encoder.h"
 #include "remoting/base/encoder_row_based.h"
 #include "remoting/base/encoder_vp8.h"
+#include "remoting/base/logger.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/curtain.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/host_key_pair.h"
 #include "remoting/host/screen_recorder.h"
 #include "remoting/host/user_authenticator.h"
 #include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/proto/auth.pb.h"
 #include "remoting/protocol/connection_to_client.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/input_stub.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/session_config.h"
 
 using remoting::protocol::ConnectionToClient;
 using remoting::protocol::InputStub;
 
 namespace remoting {
 
 // static
 ChromotingHost* ChromotingHost::Create(ChromotingHostContext* context,
                                        MutableHostConfig* config,
-                                       AccessVerifier* access_verifier) {
+                                       AccessVerifier* access_verifier,
+                                       Logger* logger) {
   DesktopEnvironment* desktop_env = DesktopEnvironment::Create(context);
-  return Create(context, config, desktop_env, access_verifier);
+  return Create(context, config, desktop_env, access_verifier, logger);
 }
 
 // static
 ChromotingHost* ChromotingHost::Create(ChromotingHostContext* context,
                                        MutableHostConfig* config,
                                        DesktopEnvironment* environment,
-                                       AccessVerifier* access_verifier) {
-  return new ChromotingHost(context, config, environment, access_verifier);
+                                       AccessVerifier* access_verifier,
+                                       Logger* logger) {
+  return new ChromotingHost(context, config, environment, access_verifier,
+                            logger);
 }
 
 ChromotingHost::ChromotingHost(ChromotingHostContext* context,
                                MutableHostConfig* config,
                                DesktopEnvironment* environment,
-                               AccessVerifier* access_verifier)
+                               AccessVerifier* access_verifier,
+                               Logger* logger)
     : context_(context),
       config_(config),
       desktop_environment_(environment),
       access_verifier_(access_verifier),
+      logger_(logger),
       state_(kInitial),
       protocol_config_(protocol::CandidateSessionConfig::CreateDefault()),
       is_curtained_(false),
       is_it2me_(false) {
   DCHECK(desktop_environment_.get());
   desktop_environment_->set_host(this);
 }
 
 ChromotingHost::~ChromotingHost() {
 }
 
 void ChromotingHost::Start() {
   if (MessageLoop::current() != context_->network_message_loop()) {
     context_->network_message_loop()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHost::Start, this));
     return;
   }
 
+  logger_->Log(logging::LOG_INFO, "Starting host");
   DCHECK(!signal_strategy_.get());
   DCHECK(access_verifier_.get());
 
   // Make sure this object is not started.
   {
     base::AutoLock auto_lock(lock_);
     if (state_ != kInitial)
       return;
     state_ = kStarted;
   }
 
   std::string xmpp_login;
   std::string xmpp_auth_token;
   std::string xmpp_auth_service;
   if (!config_->GetString(kXmppLoginConfigPath, &xmpp_login) ||
       !config_->GetString(kXmppAuthTokenConfigPath, &xmpp_auth_token) ||
       !config_->GetString(kXmppAuthServiceConfigPath, &xmpp_auth_service)) {
-    LOG(ERROR) << "XMPP credentials are not defined in the config.";
+    logger_->Log(logging::LOG_ERROR,
+                 "XMPP credentials are not defined in the config.");
     return;
   }
 
   // Connect to the talk network with a JingleClient.
   signal_strategy_.reset(
       new XmppSignalStrategy(context_->jingle_thread(), xmpp_login,
                              xmpp_auth_token,
                              xmpp_auth_service));
   signal_strategy_->Init(this);
 }
@@ skipping 42 matching lines @@
 
 void ChromotingHost::AddStatusObserver(HostStatusObserver* observer) {
   DCHECK_EQ(state_, kInitial);
   status_observers_.push_back(observer);
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // protocol::ConnectionToClient::EventHandler implementations
 void ChromotingHost::OnConnectionOpened(ConnectionToClient* connection) {
   DCHECK_EQ(context_->network_message_loop(), MessageLoop::current());
-  VLOG(1) << "Connection to client established.";
+  logger_->VLog(1, "Connection to client established.");
   // TODO(wez): ChromotingHost shouldn't need to know about Me2Mom.
   if (is_it2me_) {
     context_->main_message_loop()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHost::ProcessPreAuthentication, this,
                               make_scoped_refptr(connection)));
   }
 }
 
 void ChromotingHost::OnConnectionClosed(ConnectionToClient* connection) {
   DCHECK_EQ(context_->network_message_loop(), MessageLoop::current());
 
-  VLOG(1) << "Connection to client closed.";
+  logger_->VLog(1, "Connection to client closed.");
   context_->main_message_loop()->PostTask(
       FROM_HERE, base::Bind(&ChromotingHost::OnClientDisconnected, this,
                             make_scoped_refptr(connection)));
 }
 
 void ChromotingHost::OnConnectionFailed(ConnectionToClient* connection) {
   DCHECK_EQ(context_->network_message_loop(), MessageLoop::current());
 
-  LOG(ERROR) << "Connection failed unexpectedly.";
+  logger_->Log(logging::LOG_ERROR, "Connection failed unexpectedly.");
   context_->main_message_loop()->PostTask(
       FROM_HERE, base::Bind(&ChromotingHost::OnClientDisconnected, this,
                             make_scoped_refptr(connection)));
 }
 
 void ChromotingHost::OnSequenceNumberUpdated(ConnectionToClient* connection,
                                              int64 sequence_number) {
   // Update the sequence number in ScreenRecorder.
   if (MessageLoop::current() != context_->main_message_loop()) {
     context_->main_message_loop()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHost::OnSequenceNumberUpdated, this,
                               make_scoped_refptr(connection), sequence_number));
     return;
   }
 
   if (recorder_.get())
     recorder_->UpdateSequenceNumber(sequence_number);
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // JingleClient::Callback implementations
 void ChromotingHost::OnStateChange(
     SignalStrategy::StatusObserver::State state) {
   DCHECK_EQ(MessageLoop::current(), context_->network_message_loop());
 
   if (state == SignalStrategy::StatusObserver::CONNECTED) {
-    VLOG(1) << "Host connected as " << local_jid_;
+    logger_->Log(logging::LOG_INFO, "Host connected as %s", local_jid_.c_str());
 
     // Create and start session manager.
     protocol::JingleSessionManager* server =
         protocol::JingleSessionManager::CreateNotSandboxed();
     // TODO(ajwong): Make this a command switch when we're more stable.
     server->set_allow_local_ips(true);
 
     // Assign key and certificate to server.
     HostKeyPair key_pair;
     CHECK(key_pair.Load(config_))
         << "Failed to load server authentication data";
 
     server->Init(local_jid_, signal_strategy_.get(),
                  NewCallback(this, &ChromotingHost::OnNewClientSession),
                  key_pair.CopyPrivateKey(), key_pair.GenerateCertificate());
 
     session_manager_.reset(server);
 
     for (StatusObserverList::iterator it = status_observers_.begin();
          it != status_observers_.end(); ++it) {
       (*it)->OnSignallingConnected(signal_strategy_.get(), local_jid_);
     }
   } else if (state == SignalStrategy::StatusObserver::CLOSED) {
-    VLOG(1) << "Host disconnected from talk network.";
+    logger_->Log(logging::LOG_INFO, "Host disconnected from talk network.");
     for (StatusObserverList::iterator it = status_observers_.begin();
          it != status_observers_.end(); ++it) {
       (*it)->OnSignallingDisconnected();
     }
     // TODO(sergeyu): Don't shutdown the host and let the upper level
     // decide what needs to be done when signalling channel is
     // disconnected.
     Shutdown(NULL);
   }
 }
@@ skipping 34 matching lines @@
 
   // TODO(simonmorris): The resolution is set in the video stream now,
   // so it doesn't need to be set here.
   *protocol_config_->mutable_initial_resolution() =
       protocol::ScreenResolution(2048, 2048);
   // TODO(sergeyu): Respect resolution requested by the client if supported.
   protocol::SessionConfig* config = protocol_config_->Select(
       session->candidate_config(), true /* force_host_resolution */);
 
   if (!config) {
-    LOG(WARNING) << "Rejecting connection from " << session->jid()
-                 << " because no compatible configuration has been found.";
+    logger_->Log(logging::LOG_WARNING,
+                 "Rejecting connection from %s because no compatible"
+                 " configuration has been found.", session->jid().c_str());
     *response = protocol::SessionManager::INCOMPATIBLE;
     return;
   }
 
   session->set_config(config);
   session->set_receiver_token(
       GenerateHostAuthToken(session->initiator_token()));
 
   *response = protocol::SessionManager::ACCEPT;
 
-  VLOG(1) << "Client connected: " << session->jid();
+  logger_->Log(logging::LOG_INFO, "Client connected: %s",
+               session->jid().c_str());
 
   // We accept the connection, so create a connection object.
   ConnectionToClient* connection = new ConnectionToClient(
       context_->network_message_loop(), this);
 
   // Create a client object.
   ClientSession* client = new ClientSession(
       this,
       UserAuthenticator::Create(),
       connection,
@@ skipping 286 matching lines @@
 
   for (std::vector<Task*>::iterator it = shutdown_tasks_.begin();
        it != shutdown_tasks_.end(); ++it) {
     (*it)->Run();
     delete *it;
   }
   shutdown_tasks_.clear();
 }
 
 }  // namespace remoting