Modify Chromoting logging to hook into base logging.

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/bind.h"
 #include "base/message_loop.h"
-#include "remoting/base/logger.h"
 #include "remoting/base/tracer.h"
 #include "remoting/client/chromoting_view.h"
 #include "remoting/client/client_context.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,
-                                   Logger* 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(scoped_refptr<XmppProxy> xmpp_proxy) {
@@ skipping 115 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) {
-  logger_->VLog(1, "ChromotingClient::OnConnectionOpened");
+  VLOG(1) << "ChromotingClient::OnConnectionOpened";
   Initialize();
   SetConnectionState(CONNECTED);
 }
 
 void ChromotingClient::OnConnectionClosed(protocol::ConnectionToHost* conn) {
-  logger_->VLog(1, "ChromotingClient::OnConnectionClosed");
+  VLOG(1) << "ChromotingClient::OnConnectionClosed";
   SetConnectionState(DISCONNECTED);
 }
 
 void ChromotingClient::OnConnectionFailed(protocol::ConnectionToHost* conn) {
-  logger_->VLog(1, "ChromotingClient::OnConnectionFailed");
+  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 63 matching lines @@
 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");
+  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