Modify Chromoting logging to hook into base logging.

remoting/client/plugin/chromoting_scriptable_object.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/plugin/chromoting_scriptable_object.h"
 
 #include "base/logging.h"
-#include "base/stringprintf.h"
 // TODO(wez): Remove this when crbug.com/86353 is complete.
 #include "ppapi/cpp/private/var_private.h"
 #include "remoting/base/auth_token_util.h"
 #include "remoting/client/client_config.h"
 #include "remoting/client/chromoting_stats.h"
 #include "remoting/client/plugin/chromoting_instance.h"
 #include "remoting/client/plugin/pepper_xmpp_proxy.h"
 
 using pp::Var;
 using pp::VarPrivate;
@@ skipping 203 matching lines @@
   }
 
   return (this->*(properties_[iter->second].method))(args, exception);
 }
 
 void ChromotingScriptableObject::SetConnectionInfo(ConnectionStatus status,
                                                    ConnectionQuality quality) {
   int status_index = property_names_[kStatusAttribute];
   int quality_index = property_names_[kQualityAttribute];
 
-  LogDebugInfo(
-      base::StringPrintf("Connection status is updated: %d.", status));
+  LOG(INFO) << "Connection status is updated: " << status;
 
   if (properties_[status_index].attribute.AsInt() != status ||
       properties_[quality_index].attribute.AsInt() != quality) {
     // Update the connection state properties..
     properties_[status_index].attribute = Var(status);
     properties_[quality_index].attribute = Var(quality);
 
     // Signal the Chromoting Tab UI to get the update connection state values.
     SignalConnectionInfoChange();
   }
@@ skipping 17 matching lines @@
   int width_index = property_names_[kDesktopWidth];
   int height_index = property_names_[kDesktopHeight];
 
   if (properties_[width_index].attribute.AsInt() != width ||
       properties_[height_index].attribute.AsInt() != height) {
     properties_[width_index].attribute = Var(width);
     properties_[height_index].attribute = Var(height);
     SignalDesktopSizeChange();
   }
 
-  LogDebugInfo(base::StringPrintf("Update desktop size to: %d x %d.",
-                                  width, height));
+  LOG(INFO) << "Update desktop size to: " << width << " x " << height;
 }
 
 void ChromotingScriptableObject::AddAttribute(const std::string& name,
                                               Var attribute) {
   property_names_[name] = properties_.size();
   properties_.push_back(PropertyDescriptor(name, attribute));
 }
 
 void ChromotingScriptableObject::AddMethod(const std::string& name,
                                            MethodHandler handler) {
   property_names_[name] = properties_.size();
   properties_.push_back(PropertyDescriptor(name, handler));
 }
 
 void ChromotingScriptableObject::SignalConnectionInfoChange() {
   Var exception;
   VarPrivate cb = GetProperty(Var(kConnectionInfoUpdate), &exception);
 
   // Var() means call the object directly as a function rather than calling
   // a method in the object.
   cb.Call(Var(), &exception);
 
   if (!exception.is_undefined())
-    LogDebugInfo(
-        "Exception when invoking connectionInfoUpdate JS callback.");
+    LOG(ERROR) << "Exception when invoking connectionInfoUpdate JS callback.";
 }
 
 void ChromotingScriptableObject::SignalDesktopSizeChange() {
   Var exception;
   VarPrivate cb = GetProperty(Var(kDesktopSizeUpdate), &exception);
 
   // Var() means call the object directly as a function rather than calling
   // a method in the object.
   cb.Call(Var(), &exception);
 
   if (!exception.is_undefined()) {
-    LOG(WARNING) << "Exception when invoking JS callback"
-                 << exception.DebugString();
+    LOG(ERROR) << "Exception when invoking JS callback"
+               << exception.DebugString();
   }
 }
 
 void ChromotingScriptableObject::SignalLoginChallenge() {
   Var exception;
   VarPrivate cb = GetProperty(Var(kLoginChallenge), &exception);
 
   // Var() means call the object directly as a function rather than calling
   // a method in the object.
   cb.Call(Var(), &exception);
 
   if (!exception.is_undefined())
-    LogDebugInfo("Exception when invoking loginChallenge JS callback.");
+    LOG(ERROR) << "Exception when invoking loginChallenge JS callback.";
 }
 
 void ChromotingScriptableObject::AttachXmppProxy(PepperXmppProxy* xmpp_proxy) {
   xmpp_proxy_ = xmpp_proxy;
 }
 
 void ChromotingScriptableObject::SendIq(const std::string& message_xml) {
   Var exception;
   VarPrivate cb = GetProperty(Var(kSendIq), &exception);
 
   // Var() means call the object directly as a function rather than calling
   // a method in the object.
   cb.Call(Var(), Var(message_xml), &exception);
 
   if (!exception.is_undefined())
-    LogDebugInfo("Exception when invoking sendiq JS callback.");
+    LOG(ERROR) << "Exception when invoking sendiq JS callback.";
 }
 
 Var ChromotingScriptableObject::DoConnect(const std::vector<Var>& args,
                                           Var* exception) {
   // Parameter order is:
   //   host_jid
   //   host_public_key
   //   client_jid
   //   access_code (optional)
   unsigned int arg = 0;
@@ skipping 22 matching lines @@
       return Var();
     }
     access_code = args[arg++].AsString();
   }
 
   if (args.size() != arg) {
     *exception = Var("Too many agruments passed to connect().");
     return Var();
   }
 
-  LogDebugInfo("Connecting to host.");
+  LOG(INFO) << "Connecting to host.";
   VLOG(1) << "client_jid: " << client_jid << ", host_jid: " << host_jid
           << ", access_code: " << access_code;
   ClientConfig config;
   config.local_jid = client_jid;
   config.host_jid = host_jid;
   config.host_public_key = host_public_key;
   config.access_code = access_code;
   instance_->Connect(config);
 
   return Var();
 }
 
 Var ChromotingScriptableObject::DoDisconnect(const std::vector<Var>& args,
                                              Var* exception) {
-  LogDebugInfo("Disconnecting from host.");
+  LOG(INFO) << "Disconnecting from host.";
 
   instance_->Disconnect();
   return Var();
 }
 
 Var ChromotingScriptableObject::DoSubmitLogin(const std::vector<Var>& args,
                                               Var* exception) {
   if (args.size() != 2) {
     *exception = Var("Usage: login(username, password)");
     return Var();
   }
 
   if (!args[0].is_string()) {
     *exception = Var("Username must be a string.");
     return Var();
   }
   std::string username = args[0].AsString();
 
   if (!args[1].is_string()) {
     *exception = Var("Password must be a string.");
     return Var();
   }
   std::string password = args[1].AsString();
 
-  LogDebugInfo("Submitting login info to host.");
+  LOG(INFO) << "Submitting login info to host.";
   instance_->SubmitLoginInfo(username, password);
   return Var();
 }
 
 Var ChromotingScriptableObject::DoSetScaleToFit(const std::vector<Var>& args,
                                                 Var* exception) {
   if (args.size() != 1) {
     *exception = Var("Usage: setScaleToFit(scale_to_fit)");
     return Var();
   }
 
   if (!args[0].is_bool()) {
     *exception = Var("scale_to_fit must be a boolean.");
     return Var();
   }
 
-  LogDebugInfo("Setting scale-to-fit.");
+  LOG(INFO) << "Setting scale-to-fit.";
   instance_->SetScaleToFit(args[0].AsBool());
   return Var();
 }
 
 Var ChromotingScriptableObject::DoOnIq(const std::vector<Var>& args,
                                        Var* exception) {
   if (args.size() != 1) {
     *exception = Var("Usage: onIq(response_xml)");
     return Var();
   }
@@ skipping 12 matching lines @@
     const std::vector<pp::Var>& args, pp::Var* exception) {
   if (args.size() != 0) {
     *exception = Var("Usage: DoReleaseAllKeys()");
     return Var();
   }
   instance_->ReleaseAllKeys();
   return Var();
 }
 
 }  // namespace remoting