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

chrome/browser/sync/notifier/communicator/xmpp_connection_generator.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.
 //
 // XmppConnectionGenerator does the following algorithm:
 //   proxy = ResolveProxyInformation(connection_options)
 //   for server in server_list
 //     get dns_addresses for server
 //     connection_list = (dns_addresses X connection methods X proxy).shuffle()
 //     for connection in connection_list
 //       yield connection
 
 #include "chrome/browser/sync/notifier/communicator/xmpp_connection_generator.h"
 
 #include <vector>
 
+#include "base/logging.h"
 #include "chrome/browser/sync/notifier/base/async_dns_lookup.h"
 #include "chrome/browser/sync/notifier/base/signal_thread_task.h"
 #include "chrome/browser/sync/notifier/communicator/connection_options.h"
 #include "chrome/browser/sync/notifier/communicator/connection_settings.h"
 #include "chrome/browser/sync/notifier/communicator/product_info.h"
 #include "talk/base/autodetectproxy.h"
 #include "talk/base/httpcommon.h"
-#include "talk/base/logging.h"
 #include "talk/base/task.h"
 #include "talk/base/thread.h"
 #include "talk/xmpp/prexmppauth.h"
 #include "talk/xmpp/xmppclientsettings.h"
 #include "talk/xmpp/xmppengine.h"
 
 namespace notifier {
 
 XmppConnectionGenerator::XmppConnectionGenerator(
     talk_base::Task* parent,
@@ skipping 13 matching lines @@
       parent_(parent) {
   assert(parent);
   assert(options);
   assert(server_count_ > 0);
   for (int i = 0; i < server_count_; ++i) {
     server_list_[i] = server_list[i];
   }
 }
 
 XmppConnectionGenerator::~XmppConnectionGenerator() {
-  LOG(LS_VERBOSE) << "XmppConnectionGenerator::~XmppConnectionGenerator";
+  LOG(INFO) << "XmppConnectionGenerator::~XmppConnectionGenerator";
 }
 
 const talk_base::ProxyInfo& XmppConnectionGenerator::proxy() const {
   assert(settings_list_.get());
   if (settings_index_ >= settings_list_->GetCount()) {
     return settings_list_->proxy();
   }
 
   ConnectionSettings* settings = settings_list_->GetSettings(settings_index_);
   return settings->proxy();
 }
 
 // Starts resolving proxy information.
 void XmppConnectionGenerator::StartGenerating() {
-  LOG(LS_VERBOSE) << "XmppConnectionGenerator::StartGenerating";
+  LOG(INFO) << "XmppConnectionGenerator::StartGenerating";
 
   talk_base::AutoDetectProxy* proxy_detect =
       new talk_base::AutoDetectProxy(GetUserAgentString());
 
   if (options_->autodetect_proxy()) {
     // Pretend the xmpp server is https, when detecting whether a proxy is
     // required to connect.
     talk_base::Url<char> host_url("/",
                                   server_list_[0].server.IPAsString().c_str(),
                                   server_list_[0].server.port());
@@ skipping 11 matching lines @@
   SignalThreadTask<talk_base::AutoDetectProxy>* wrapper_task =
       new SignalThreadTask<talk_base::AutoDetectProxy>(parent_, &proxy_detect);
   wrapper_task->SignalWorkDone.connect(
       this,
       &XmppConnectionGenerator::OnProxyDetect);
   wrapper_task->Start();
 }
 
 void XmppConnectionGenerator::OnProxyDetect(
     talk_base::AutoDetectProxy* proxy_detect) {
-  LOG(LS_VERBOSE) << "XmppConnectionGenerator::OnProxyDetect";
+  LOG(INFO) << "XmppConnectionGenerator::OnProxyDetect";
 
   ASSERT(settings_list_.get());
   ASSERT(proxy_detect);
   settings_list_->SetProxy(proxy_detect->proxy());
 
   // Start iterating through the connections (which are generated on demand).
   UseNextConnection();
 }
 
 void XmppConnectionGenerator::UseNextConnection() {
@@ skipping 21 matching lines @@
     wrapper_task->Start();
     return;
   }
 
   // All out of possibilities.
   HandleExhaustedConnections();
 }
 
 void XmppConnectionGenerator::OnServerDNSResolved(
     AsyncDNSLookup* dns_lookup) {
-  LOG(LS_VERBOSE) << "XmppConnectionGenerator::OnServerDNSResolved";
+  LOG(INFO) << "XmppConnectionGenerator::OnServerDNSResolved";
 
   // Print logging info.
-  LOG(LS_VERBOSE) << "  server: " <<
+  LOG(INFO) << "  server: " <<
       server_list_[server_index_].server.ToString() <<
       "  error: " << dns_lookup->error();
   if (first_dns_error_ == 0 && dns_lookup->error() != 0) {
     first_dns_error_ = dns_lookup->error();
   }
 
   if (!successfully_resolved_dns_ && dns_lookup->ip_list().size() > 0) {
     successfully_resolved_dns_ = true;
   }
 
   for (int i = 0; i < static_cast<int>(dns_lookup->ip_list().size()); ++i) {
-    LOG(LS_VERBOSE)
+    LOG(INFO)
         << "  ip " << i << " : "
         << talk_base::SocketAddress::IPToString(dns_lookup->ip_list()[i]);
   }
 
   // Build the ip list.
   assert(settings_list_.get());
   settings_index_ = -1;
   settings_list_->ClearPermutations();
   settings_list_->AddPermutations(
       server_list_[server_index_].server.IPAsString(),
       dns_lookup->ip_list(),
       server_list_[server_index_].server.port(),
       server_list_[server_index_].special_port_magic,
       proxy_only_);
 
   UseNextConnection();
 }
 
 static const char* const PROTO_NAMES[cricket::PROTO_LAST + 1] = {
   "udp", "tcp", "ssltcp"
 };
 
 static const char* ProtocolToString(cricket::ProtocolType proto) {
   return PROTO_NAMES[proto];
 }
 
 void XmppConnectionGenerator::UseCurrentConnection() {
-  LOG(LS_VERBOSE) << "XmppConnectionGenerator::UseCurrentConnection";
+  LOG(INFO) << "XmppConnectionGenerator::UseCurrentConnection";
 
   ConnectionSettings* settings = settings_list_->GetSettings(settings_index_);
-  LOG(LS_INFO) << "*** Attempting "
-               << ProtocolToString(settings->protocol()) << " connection to "
-               << settings->server().IPAsString() << ":"
-               << settings->server().port()
-               << " (via " << ProxyToString(settings->proxy().type)
-               << " proxy @ " << settings->proxy().address.IPAsString() << ":"
-               << settings->proxy().address.port() << ")";
+  LOG(INFO) << "*** Attempting "
+            << ProtocolToString(settings->protocol()) << " connection to "
+            << settings->server().IPAsString() << ":"
+            << settings->server().port()
+            << " (via " << ProxyToString(settings->proxy().type)
+            << " proxy @ " << settings->proxy().address.IPAsString() << ":"
+            << settings->proxy().address.port() << ")";
 
   SignalNewSettings(*settings);
 }
 
 void XmppConnectionGenerator::HandleExhaustedConnections() {
-  LOG_F(LS_VERBOSE) << "(" << buzz::XmppEngine::ERROR_SOCKET
-                    << ", " << first_dns_error_ << ")";
+  LOG(INFO) << "(" << buzz::XmppEngine::ERROR_SOCKET
+            << ", " << first_dns_error_ << ")";
   SignalExhaustedSettings(successfully_resolved_dns_, first_dns_error_);
 }
 
 }  // namespace notifier