Make it easier to create new IPC channel types (i.e. renderer/plugin). Inste...

chrome/common/ipc_logging.cc

 // Copyright (c) 2006-2008 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/common/ipc_logging.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
@@ skipping 23 matching lines @@
 const int kLogSendDelayMs = 100;
 
 Logging::Logging()
     : logging_event_on_(NULL),
       logging_event_off_(NULL),
       enabled_(false),
       sender_(NULL),
       consumer_(NULL),
       queue_invoke_later_pending_(false),
       main_thread_(MessageLoop::current()) {
+  memset(log_function_mapping_, sizeof(log_function_mapping_), 0);
+
   // Create an event for this browser instance that's set when logging is
   // enabled, so child processes can know when logging is enabled.
   int browser_pid;
 
   const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
   std::wstring process_type =
     parsed_command_line.GetSwitchValue(switches::kProcessType);
   if (process_type.empty()) {
     browser_pid = GetCurrentProcessId();
   } else {
@@ skipping 27 matching lines @@
   watcher_.StopWatching();
   watcher_.StartWatching(
       enabled ? logging_event_on_ : logging_event_off_, this);
 }
 
 void Logging::OnObjectSignaled(HANDLE object) {
   enabled_ = object == logging_event_on_;
   RegisterWaitForEvent(!enabled_);
 }
 
+void Logging::RegisterMessageLogger(int msg_start, LogFunction* func) {
+  int msg_class = msg_start >> 12;
+  if (msg_class > arraysize(log_function_mapping_)) {
+    NOTREACHED();
+    return;
+  }
+
+  log_function_mapping_[msg_class] = func;
+}
+
 std::wstring Logging::GetEventName(bool enabled) {
-  return Logging::current()->GetEventName(GetCurrentProcessId(), enabled);
+  return current()->GetEventName(GetCurrentProcessId(), enabled);
 }
 
 std::wstring Logging::GetEventName(int browser_pid, bool enabled) {
   std::wstring result = StringPrintf(kLoggingEventName, browser_pid);
   result += enabled ? L"on" : L"off";
   return result;
 }
 
 void Logging::SetConsumer(Consumer* consumer) {
   consumer_ = consumer;
@@ skipping 78 matching lines @@
   GenerateLogData(channel_id, message, &data);
 
   if (MessageLoop::current() == main_thread_) {
     Log(data);
   } else {
     main_thread_->PostTask(FROM_HERE, NewRunnableMethod(
         this, &Logging::Log, data));
   }
 }
 
-// static
-LogFunction* g_log_function_mapping[16];
-void RegisterMessageLogger(int msg_start, LogFunction* func) {
-  int msg_class = msg_start >> 12;
-  if (msg_class > arraysize(g_log_function_mapping)) {
-    NOTREACHED();
-    return;
-  }
-
-  g_log_function_mapping[msg_class] = func;
-}
-
 void Logging::GetMessageText(uint16 type, std::wstring* name,
                              const Message* message,
                              std::wstring* params) {
   int message_class = type >> 12;
-  if (g_log_function_mapping[message_class] != NULL) {
-    g_log_function_mapping[message_class](type, name, message, params);
+  if (current()->log_function_mapping_[message_class] != NULL) {
+    current()->log_function_mapping_[message_class](type, name, message, params);
   } else {
     DLOG(INFO) << "No logger function associated with message class " <<
         message_class;
   }
 }
 
 void Logging::Log(const LogData& data) {
   if (consumer_) {
     // We're in the browser process.
     consumer_->Log(data);
@@ skipping 43 matching lines @@
     data->sent = message.sent_time();
     data->receive = message.received_time();
     data->dispatch = Time::Now().ToInternalValue();
     data->params = params;
   }
 }
 
 }
 
 #endif  // IPC_MESSAGE_LOG_ENABLED