Convert Chromoting plugin logging to appear in client UI

remoting/client/chromoting_client.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/client/chromoting_client.h"
 
 #include "base/message_loop.h"
 #include "remoting/base/tracer.h"
 #include "remoting/client/chromoting_view.h"
 #include "remoting/client/client_context.h"
+#include "remoting/client/client_logger.h"
 #include "remoting/client/input_handler.h"
 #include "remoting/client/rectangle_update_decoder.h"
 #include "remoting/protocol/connection_to_host.h"
 #include "remoting/protocol/session_config.h"
 
 namespace remoting {
 
 ChromotingClient::ChromotingClient(const ClientConfig& config,
                                    ClientContext* context,
                                    protocol::ConnectionToHost* connection,
                                    ChromotingView* view,
                                    RectangleUpdateDecoder* rectangle_decoder,
                                    InputHandler* input_handler,
+                                   ClientLogger* logger,
                                    Task* client_done)
     : config_(config),
       context_(context),
       connection_(connection),
       view_(view),
       rectangle_decoder_(rectangle_decoder),
       input_handler_(input_handler),
+      logger_(logger),
       client_done_(client_done),
       state_(CREATED),
       packet_being_processed_(false),
       last_sequence_number_(0) {
 }
 
 ChromotingClient::~ChromotingClient() {
 }
 
 void ChromotingClient::Start() {
@@ skipping 134 matching lines @@
   base::Time decode_start;
   if (last_packet)
     decode_start = base::Time::Now();
 
   rectangle_decoder_->DecodePacket(
       packet, NewTracedMethod(this, &ChromotingClient::OnPacketDone,
                               last_packet, decode_start));
 }
 
 void ChromotingClient::OnConnectionOpened(protocol::ConnectionToHost* conn) {
-  VLOG(1) << "ChromotingClient::OnConnectionOpened";
+  logger_->VLog(1, "ChromotingClient::OnConnectionOpened");
   Initialize();
   SetConnectionState(CONNECTED);
 }
 
 void ChromotingClient::OnConnectionClosed(protocol::ConnectionToHost* conn) {
-  VLOG(1) << "ChromotingClient::OnConnectionClosed";
+  logger_->VLog(1, "ChromotingClient::OnConnectionClosed");
   SetConnectionState(DISCONNECTED);
 }
 
 void ChromotingClient::OnConnectionFailed(protocol::ConnectionToHost* conn) {
-  VLOG(1) << "ChromotingClient::OnConnectionFailed";
+  logger_->VLog(1, "ChromotingClient::OnConnectionFailed");
   SetConnectionState(FAILED);
 }
 
 MessageLoop* ChromotingClient::message_loop() {
   return context_->jingle_thread()->message_loop();
 }
 
 void ChromotingClient::SetConnectionState(ConnectionState s) {
   // TODO(ajwong): We actually may want state to be a shared variable. Think
   // through later.
@@ skipping 47 matching lines @@
     return;
   }
 
   TraceContext::tracer()->PrintString("Initializing client.");
 
   const protocol::SessionConfig* config = connection_->config();
 
   // Resize the window.
   int width = config->initial_resolution().width;
   int height = config->initial_resolution().height;
-  VLOG(1) << "Initial screen geometry: " << width << "x" << height;
+  logger_->VLog(1, "Initial screen geometry: %dx%d", width, height);
 
   // TODO(ajwong): What to do here?  Does the decoder actually need to request
   // the right frame size?  This is mainly an optimization right?
   // rectangle_decoder_->SetOutputFrameSize(width, height);
   view_->SetViewport(0, 0, width, height);
 
   // Initialize the decoder.
   rectangle_decoder_->Initialize(config);
 
   // Schedule the input handler to process the event queue.
   input_handler_->Initialize();
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // ClientStub control channel interface.
 void ChromotingClient::NotifyResolution(
     const protocol::NotifyResolutionRequest* msg, Task* done) {
+  logger_->Log(logging::LOG_INFO, "NotifyResolution change");
   NOTIMPLEMENTED();
   done->Run();
   delete done;
 }
 
 void ChromotingClient::BeginSessionResponse(
     const protocol::LocalLoginStatus* msg, Task* done) {
   if (message_loop() != MessageLoop::current()) {
     message_loop()->PostTask(
         FROM_HERE,
         NewRunnableMethod(this, &ChromotingClient::BeginSessionResponse,
                           msg, done));
     return;
   }
 
+  logger_->Log(logging::LOG_INFO, "BeginSessionResponse received");
+
   // Inform the connection that the client has been authenticated. This will
   // enable the communication channels.
   if (msg->success()) {
     connection_->OnClientAuthenticated();
   }
 
   view_->UpdateLoginStatus(msg->success(), msg->error_info());
   done->Run();
   delete done;
 }
 
 }  // namespace remoting