Use base/logging from chrome/browser/sync. Add a macro to libjingle's

chrome/browser/sync/notifier/communicator/xmpp_socket_adapter.cc

 // Copyright (c) 2009 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 "chrome/browser/sync/notifier/communicator/xmpp_socket_adapter.h"
 
 #include <iomanip>
 #include <string>
 
+#include "base/logging.h"
 #include "chrome/browser/sync/notifier/communicator/product_info.h"
 #include "talk/base/byteorder.h"
 #include "talk/base/common.h"
 #include "talk/base/firewallsocketserver.h"
 #include "talk/base/logging.h"
 #include "talk/base/socketadapters.h"
 #include "talk/base/ssladapter.h"
 #include "talk/xmpp/xmppengine.h"
 
 namespace notifier {
@@ skipping 47 matching lines @@
   }
   return true;
 }
 
 bool XmppSocketAdapter::Connect(const talk_base::SocketAddress& addr) {
   if (state_ != STATE_CLOSED) {
     SetError(ERROR_WRONGSTATE);
     return false;
   }
 
-  LOG(LS_INFO) << "XmppSocketAdapter::Connect(" << addr.ToString() << ")";
+  LOG(INFO) << "XmppSocketAdapter::Connect(" << addr.ToString() << ")";
 
   // Clean up any previous socket - cannot delete socket on close because close
   // happens during the child socket's stack callback.
   if (socket_) {
     delete socket_;
     socket_ = NULL;
   }
 
   talk_base::AsyncSocket* socket =
       talk_base::Thread::Current()->socketserver()->CreateAsyncSocket(
@@ skipping 153 matching lines @@
   if (socket_) {
     state_ = STATE_CLOSING;
     socket_->Close();
   }
 
   // If we didn't get the callback, then we better make sure we signal
   // closed.
   if (state_ != STATE_CLOSED) {
     // The socket was closed manually, not directly due to error.
     if (error_ != ERROR_NONE) {
-      LOG(LS_INFO) << "XmppSocketAdapter::Close - previous Error: " << error_
-                   << " WSAError: " << wsa_error_;
+      LOG(INFO) << "XmppSocketAdapter::Close - previous Error: " << error_
+                << " WSAError: " << wsa_error_;
       error_ = ERROR_NONE;
       wsa_error_ = 0;
     }
     NotifyClose();
   }
   return true;
 }
 
 void XmppSocketAdapter::NotifyClose() {
   if (state_ == STATE_CLOSED) {
     SetError(ERROR_WRONGSTATE);
   } else {
-    LOG(LS_INFO) << "XmppSocketAdapter::NotifyClose - Error: " << error_
-                 << " WSAError: " << wsa_error_;
+    LOG(INFO) << "XmppSocketAdapter::NotifyClose - Error: " << error_
+              << " WSAError: " << wsa_error_;
     state_ = STATE_CLOSED;
     SignalClosed();
     FreeState();
   }
 }
 
 void XmppSocketAdapter::OnConnectEvent(talk_base::AsyncSocket *socket) {
   if (state_ == STATE_CONNECTING) {
     state_ = STATE_OPEN;
-    LOG(LS_INFO) << "XmppSocketAdapter::OnConnectEvent - STATE_OPEN";
+    LOG(INFO) << "XmppSocketAdapter::OnConnectEvent - STATE_OPEN";
     SignalConnected();
 #if defined(FEATURE_ENABLE_SSL)
   } else if (state_ == STATE_TLS_CONNECTING) {
     state_ = STATE_TLS_OPEN;
-    LOG(LS_INFO) << "XmppSocketAdapter::OnConnectEvent - STATE_TLS_OPEN";
+    LOG(INFO) << "XmppSocketAdapter::OnConnectEvent - STATE_TLS_OPEN";
     SignalSSLConnected();
     if (write_buffer_length_ > 0) {
       HandleWritable();
     }
 #endif  // defined(FEATURE_ENABLE_SSL)
   } else {
-    LOG(LS_INFO) << "XmppSocketAdapter::OnConnectEvent - state is " << state_;
+    LOG(INFO) << "XmppSocketAdapter::OnConnectEvent - state is " << state_;
     ASSERT(false);
   }
 }
 
 void XmppSocketAdapter::OnReadEvent(talk_base::AsyncSocket *socket) {
   HandleReadable();
 }
 
 void XmppSocketAdapter::OnWriteEvent(talk_base::AsyncSocket *socket) {
   HandleWritable();
 }
 
 void XmppSocketAdapter::OnCloseEvent(talk_base::AsyncSocket *socket,
                                      int error) {
-  LOG(LS_INFO) << "XmppSocketAdapter::OnCloseEvent(" << error << ")";
+  LOG(INFO) << "XmppSocketAdapter::OnCloseEvent(" << error << ")";
   SetWSAError(error);
   if (error == SOCKET_EACCES) {
     SignalAuthenticationError();  // Proxy needs authentication.
   }
   NotifyClose();
 }
 
 #if defined(FEATURE_ENABLE_SSL)
 bool XmppSocketAdapter::StartTls(const std::string& verify_host_name) {
   if (state_ != STATE_OPEN) {
@@ skipping 102 matching lines @@
   int wsa_error = 0;
   FlushWriteQueue(&error, &wsa_error);
   if (error != ERROR_NONE) {
     Close();
     return false;
   }
   return true;
 }
 
 }  // namespace notifier