Modify Chromoting logging to hook into base logging.

remoting/client/plugin/chromoting_instance.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_instance.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task.h"
 #include "base/threading/thread.h"
 // TODO(sergeyu): We should not depend on renderer here. Instead P2P
 // Pepper API should be used. Remove this dependency.
 // crbug.com/74951
 #include "content/renderer/p2p/ipc_network_manager.h"
 #include "content/renderer/p2p/ipc_socket_factory.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/rect.h"
 // TODO(wez): Remove this when crbug.com/86353 is complete.
 #include "ppapi/cpp/private/var_private.h"
+#include "remoting/base/util.h"
 #include "remoting/client/client_config.h"
 #include "remoting/client/chromoting_client.h"
 #include "remoting/client/rectangle_update_decoder.h"
 #include "remoting/client/plugin/chromoting_scriptable_object.h"
-#include "remoting/client/plugin/pepper_client_logger.h"
 #include "remoting/client/plugin/pepper_input_handler.h"
 #include "remoting/client/plugin/pepper_port_allocator_session.h"
 #include "remoting/client/plugin/pepper_view.h"
 #include "remoting/client/plugin/pepper_view_proxy.h"
 #include "remoting/client/plugin/pepper_util.h"
 #include "remoting/client/plugin/pepper_xmpp_proxy.h"
 #include "remoting/jingle_glue/jingle_thread.h"
 #include "remoting/proto/auth.pb.h"
 #include "remoting/protocol/connection_to_host.h"
 #include "remoting/protocol/host_stub.h"
 // TODO(sergeyu): This is a hack: plugin should not depend on webkit
 // glue. It is used here to get P2PPacketDispatcher corresponding to
 // the current RenderView. Use P2P Pepper API for connection and
 // remove these includes.
 // crbug.com/74951
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/resource_tracker.h"
 
 namespace remoting {
 
+// This flag blocks LOGs to the UI if we're already in the middle of logging
+// to the UI. This prevents a potential infinite loop if we encounter an error
+// while sending the log message to the UI.
+static bool logging_to_plugin_ = false;

[dmac, 2011/07/21 23:37:07]

should these be marked with a g in front of them? At the very least they aren't
member vars so they shouldn't have a _ on the end.

[garykac, 2011/08/02 00:15:37]

Done.

+static ChromotingInstance* logging_instance_ = NULL;
+static MessageLoop* logging_message_loop_ = NULL;
+static logging::LogMessageHandlerFunction logging_old_handler_ = NULL;
+
 const char* ChromotingInstance::kMimeType = "pepper-application/x-chromoting";
 
 ChromotingInstance::ChromotingInstance(PP_Instance pp_instance)
     : pp::InstancePrivate(pp_instance),
-      initialized_(false),
-      logger_(this) {
+      initialized_(false) {
   RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE);
   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_KEYBOARD);
+  logging_old_handler_ = logging::GetLogMessageHandler();
+  logging::SetLogMessageHandler(&LogToUI);
+  logging_instance_ = this;
+  logging_message_loop_ = MessageLoop::current();
 }
 
 ChromotingInstance::~ChromotingInstance() {
   DCHECK(CurrentlyOnPluginThread());
 
+  logging::SetLogMessageHandler(logging_old_handler_);
+  logging_old_handler_ = NULL;
+  logging_instance_ = NULL;
+  logging_message_loop_ = NULL;
+
   if (client_.get()) {
     base::WaitableEvent done_event(true, false);
     client_->Stop(base::Bind(&base::WaitableEvent::Signal,
                              base::Unretained(&done_event)));
     done_event.Wait();
   }
 
   // Stopping the context shutdown all chromoting threads. This is a requirement
   // before we can call Detach() on |view_proxy_|.
   context_.Stop();
 
   view_proxy_->Detach();
 }
 
 bool ChromotingInstance::Init(uint32_t argc,
                               const char* argn[],
                               const char* argv[]) {
   CHECK(!initialized_);
   initialized_ = true;
 
-  logger_.VLog(1, "Started ChromotingInstance::Init");
+  VLOG(1) << "Started ChromotingInstance::Init";
 
   // Start all the threads.
   context_.Start();
 
   webkit::ppapi::PluginInstance* plugin_instance =
       webkit::ppapi::ResourceTracker::Get()->GetInstance(pp_instance());
 
   P2PSocketDispatcher* socket_dispatcher =
       plugin_instance->delegate()->GetP2PSocketDispatcher();
   IpcNetworkManager* network_manager = NULL;
   IpcPacketSocketFactory* socket_factory = NULL;
   PortAllocatorSessionFactory* session_factory =
       CreatePepperPortAllocatorSessionFactory(this);
 
   // If we don't have socket dispatcher for IPC (e.g. P2P API is
   // disabled), then JingleSessionManager will try to use physical sockets.
   if (socket_dispatcher) {
-    logger_.VLog(1, "Creating IpcNetworkManager and IpcPacketSocketFactory.");
+    VLOG(1) << "Creating IpcNetworkManager and IpcPacketSocketFactory.";
     network_manager = new IpcNetworkManager(socket_dispatcher);
     socket_factory = new IpcPacketSocketFactory(socket_dispatcher);
   }
 
   // Create the chromoting objects.
   host_connection_.reset(new protocol::ConnectionToHost(
       context_.network_message_loop(), network_manager, socket_factory,
       session_factory));
   view_.reset(new PepperView(this, &context_));
   view_proxy_ = new PepperViewProxy(this, view_.get());
   rectangle_decoder_ = new RectangleUpdateDecoder(
       context_.decode_message_loop(), view_proxy_);
   input_handler_.reset(new PepperInputHandler(&context_,
                                               host_connection_.get(),
                                               view_proxy_));
 
   // Default to a medium grey.
   view_->SetSolidFill(0xFFCDCDCD);
 
   return true;
 }
 
 void ChromotingInstance::Connect(const ClientConfig& config) {
   DCHECK(CurrentlyOnPluginThread());
 
   client_.reset(new ChromotingClient(config, &context_, host_connection_.get(),
                                      view_proxy_, rectangle_decoder_.get(),
-                                     input_handler_.get(), &logger_, NULL));
+                                     input_handler_.get(), NULL));
 
-  logger_.Log(logging::LOG_INFO, "Connecting.");
+  LOG(INFO) << "Connecting.";
 
   // Setup the XMPP Proxy.
   ChromotingScriptableObject* scriptable_object = GetScriptableObject();
   scoped_refptr<PepperXmppProxy> xmpp_proxy =
       new PepperXmppProxy(scriptable_object->AsWeakPtr(),
                           context_.jingle_thread()->message_loop());
   scriptable_object->AttachXmppProxy(xmpp_proxy);
 
   // Kick off the connection.
   client_->Start(xmpp_proxy);
 
-  logger_.Log(logging::LOG_INFO, "Connection status: Initializing");
+  LOG(INFO) << "Connection status: Initializing";
   GetScriptableObject()->SetConnectionInfo(STATUS_INITIALIZING,
                                            QUALITY_UNKNOWN);
 }
 
 void ChromotingInstance::Disconnect() {
   DCHECK(CurrentlyOnPluginThread());
 
-  logger_.Log(logging::LOG_INFO, "Disconnecting from host.");
+  LOG(INFO) << "Disconnecting from host.";
   if (client_.get()) {
     // TODO(sergeyu): Should we disconnect asynchronously?
     base::WaitableEvent done_event(true, false);
     client_->Stop(base::Bind(&base::WaitableEvent::Signal,
                              base::Unretained(&done_event)));
     done_event.Wait();
   }
 
   GetScriptableObject()->SetConnectionInfo(STATUS_CLOSED, QUALITY_UNKNOWN);
 }
@@ skipping 32 matching lines @@
     }
 
     case PP_INPUTEVENT_TYPE_CONTEXTMENU: {
       // We need to return true here or else we'll get a local (plugin) context
       // menu instead of the mouseup event for the right click.
       return true;
     }
 
     case PP_INPUTEVENT_TYPE_KEYDOWN: {
       pp::KeyboardInputEvent key = pp::KeyboardInputEvent(event);
-      logger_.VLog(3, "PP_INPUTEVENT_TYPE_KEYDOWN key=%d", key.GetKeyCode());
+      VLOG(3) << "PP_INPUTEVENT_TYPE_KEYDOWN" << " key=" << key.GetKeyCode();
       pih->HandleKeyEvent(true, key);
       return true;
     }
 
     case PP_INPUTEVENT_TYPE_KEYUP: {
       pp::KeyboardInputEvent key = pp::KeyboardInputEvent(event);
-      logger_.VLog(3, "PP_INPUTEVENT_TYPE_KEYUP key=%d", key.GetKeyCode());
+      VLOG(3) << "PP_INPUTEVENT_TYPE_KEYUP" << " key=" << key.GetKeyCode();
       pih->HandleKeyEvent(false, key);
       return true;
     }
 
     case PP_INPUTEVENT_TYPE_CHAR: {
       pih->HandleCharacterEvent(pp::KeyboardInputEvent(event));
       return true;
     }
 
     default: {
       LOG(INFO) << "Unhandled input event: " << event.GetType();
       break;
     }
   }
 
   return false;
 }
 
 ChromotingScriptableObject* ChromotingInstance::GetScriptableObject() {
   pp::VarPrivate object = GetInstanceObject();
   if (!object.is_undefined()) {
     pp::deprecated::ScriptableObject* so = object.AsScriptableObject();
     DCHECK(so != NULL);
     return static_cast<ChromotingScriptableObject*>(so);
   }
-  logger_.Log(logging::LOG_ERROR,
-               "Unable to get ScriptableObject for Chromoting plugin.");
+  LOG(ERROR) << "Unable to get ScriptableObject for Chromoting plugin.";
   return NULL;
 }
 
 void ChromotingInstance::SubmitLoginInfo(const std::string& username,
                                          const std::string& password) {
   if (host_connection_->state() !=
       protocol::ConnectionToHost::STATE_CONNECTED) {
-    logger_.Log(logging::LOG_INFO,
-                 "Client not connected or already authenticated.");
+    LOG(INFO) << "Client not connected or already authenticated.";
     return;
   }
 
   protocol::LocalLoginCredentials* credentials =
       new protocol::LocalLoginCredentials();
   credentials->set_type(protocol::PASSWORD);
   credentials->set_username(username);
   credentials->set_credential(password.data(), password.length());
 
   host_connection_->host_stub()->BeginSessionRequest(
       credentials,
       new DeleteTask<protocol::LocalLoginCredentials>(credentials));
 }
 
 void ChromotingInstance::SetScaleToFit(bool scale_to_fit) {
   view_proxy_->SetScaleToFit(scale_to_fit);
 }
 
-void ChromotingInstance::Log(int severity, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  logger_.va_Log(severity, format, ap);
-  va_end(ap);
+// static
+bool ChromotingInstance::LogToUI(int severity, const char* file, int line,
+                                 size_t message_start,
+                                 const std::string& str) {
+  if (logging_instance_ && !logging_to_plugin_) {
+    logging_to_plugin_ = true;

[dmac, 2011/07/21 23:37:07]

logging_to_plugin_ race conditions about the global var on different threads?

[garykac, 2011/08/02 00:15:37]

True. I pushed the check down into the "CorrectThread" code below.

+    std::string message = remoting::GetTimestampString();
+    message += (str.c_str() + message_start);
+    logging_instance_->LogToUI_CorrectThread(message);
+    logging_to_plugin_ = false;
+  }
+
+  if (logging_old_handler_)
+    return (logging_old_handler_)(severity, file, line, message_start, str);
+  return false;
 }
 
-void ChromotingInstance::VLog(int verboselevel, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  logger_.va_VLog(verboselevel, format, ap);
-  va_end(ap);
+void ChromotingInstance::LogToUI_CorrectThread(const std::string& message) {
+  if (!logging_message_loop_)
+    return;
+
+  if (logging_message_loop_ != MessageLoop::current()) {
+    logging_message_loop_->PostTask(
+        FROM_HERE,
+        NewRunnableMethod(this,
+                          &ChromotingInstance::LogToUI_CorrectThread, message));
+    return;
+  }
+
+  ChromotingScriptableObject* cso = GetScriptableObject();
+  if (cso) {
+    cso->LogDebugInfo(message);
+  }
 }
 
 pp::Var ChromotingInstance::GetInstanceObject() {
   if (instance_object_.is_undefined()) {
     ChromotingScriptableObject* object = new ChromotingScriptableObject(this);
     object->Init();
 
     // The pp::Var takes ownership of object here.
     instance_object_ = pp::VarPrivate(this, object);
   }
 
   return instance_object_;
 }
 
 ChromotingStats* ChromotingInstance::GetStats() {
   if (!client_.get())
     return NULL;
   return client_->GetStats();
 }
 
 void ChromotingInstance::ReleaseAllKeys() {
   input_handler_->ReleaseAllKeys();
 }
 
 }  // namespace remoting