Change Chromoting logger to be setup in plugin's NP_Initialize.

remoting/host/plugin/host_plugin.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 <stdio.h>
 #include <string.h>
 
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/stringize_macros.h"
 #include "remoting/base/plugin_message_loop_proxy.h"
+#include "remoting/host/plugin/host_log_handler.h"
 #include "remoting/host/plugin/host_plugin_utils.h"
 #include "remoting/host/plugin/host_script_object.h"
 #include "third_party/npapi/bindings/npapi.h"
 #include "third_party/npapi/bindings/npfunctions.h"
 #include "third_party/npapi/bindings/npruntime.h"
 
 // Symbol export is handled with a separate def file on Windows.
 #if defined (__GNUC__) && __GNUC__ >= 4
 #define EXPORT __attribute__((visibility("default")))
 #else
@@ skipping 10 matching lines @@
   return a / b;
 }
 uint64_t __cdecl __udivdi3(uint64_t a, uint64_t b) {
   return a / b;
 }
 
 }
 #endif
 
 using remoting::g_npnetscape_funcs;
+using remoting::HostLogHandler;
 using remoting::HostNPScriptObject;
 using remoting::StringFromNPIdentifier;
 
 namespace {
 
 base::AtExitManager* g_at_exit_manager = NULL;
 
 // The name and description are returned by GetValue, but are also
 // combined with the MIME type to satisfy GetMIMEDescription, so we
 // use macros here to allow that to happen at compile-time.
@@ skipping 289 matching lines @@
 }
 
 NPError CreatePlugin(NPMIMEType pluginType,
                      NPP instance,
                      uint16 mode,
                      int16 argc,
                      char** argn,
                      char** argv,
                      NPSavedData* saved) {
   VLOG(2) << "CreatePlugin";
+
+  // Register a global log handler.
+  // The LogMessage registration code is not thread-safe, so we need to perform
+  // this while we're running in a single thread.
+  HostLogHandler::RegisterLogMessageHandler();
+
   HostNPPlugin* plugin = new HostNPPlugin(instance, mode);
   instance->pdata = plugin;
   if (!plugin->Init(argc, argn, argv, saved)) {
     delete plugin;
     instance->pdata = NULL;
     return NPERR_INVALID_PLUGIN_ERROR;
   } else {
     return NPERR_NO_ERROR;
   }
 }
 
 NPError DestroyPlugin(NPP instance,
                       NPSavedData** save) {
   VLOG(2) << "DestroyPlugin";
+
+  // Normally, we would unregister the global log handler that we registered
+  // in CreatePlugin. However, the LogHandler registration code is not thread-
+  // safe so we could crash if we update (register or unregister) the
+  // LogHandler while it's being read on another thread.
+  // At this point, all our threads should be shutdown, but it's safer to leave
+  // the handler registered until we're completely destroyed.
+
   HostNPPlugin* plugin = PluginFromInstance(instance);
   if (plugin) {
     plugin->Save(save);
     delete plugin;
     instance->pdata = NULL;
     return NPERR_NO_ERROR;
   } else {
     return NPERR_INVALID_PLUGIN_ERROR;
   }
 }
@@ skipping 113 matching lines @@
 }
 
 EXPORT NPError API_CALL NP_GetValue(void* npp,
                                     NPPVariable variable,
                                     void* value) {
   return GetValue((NPP)npp, variable, value);
 }
 #endif
 
 }  // extern "C"