Simplify the magic required to create IPC message headers a bit.

ipc/ipc_logging.cc

 // Copyright (c) 2010 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 "ipc/ipc_logging.h"
 
 #ifdef IPC_MESSAGE_LOG_ENABLED
-// This will cause render_messages.h etc to define ViewMsgLog and friends.
 #define IPC_MESSAGE_MACROS_LOG_ENABLED
 #endif
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
+#include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "base/time.h"
 #include "ipc/ipc_switches.h"
 #include "ipc/ipc_sync_message.h"
 #include "ipc/ipc_message_utils.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
 #endif
 
 #ifdef IPC_MESSAGE_LOG_ENABLED
 
 using base::Time;
 
 // IPC::Logging is allocated as a singleton, so we don't need any kind of
 // special retention program.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(IPC::Logging);
 
 namespace IPC {
 
 const int kLogSendDelayMs = 100;
 
 // We use a pointer to the function table to avoid any linker dependencies on
 // all the traits used as IPC message parameters.
-Logging::LogFunction *Logging::log_function_mapping_;
+LogFunctionMap* Logging::log_function_map_;
 
 Logging::Logging()
     : enabled_(false),
       enabled_on_stderr_(false),
       queue_invoke_later_pending_(false),
       sender_(NULL),
       main_thread_(MessageLoop::current()),
       consumer_(NULL) {
 #if defined(OS_WIN)
   // getenv triggers an unsafe warning. Simply check how big of a buffer
@@ skipping 11 matching lines @@
   }
 }
 
 Logging::~Logging() {
 }
 
 Logging* Logging::current() {
   return Singleton<Logging>::get();
 }
 
-void Logging::SetLoggerFunctions(LogFunction *functions) {
-  log_function_mapping_ = functions;
-}
-
 void Logging::SetConsumer(Consumer* consumer) {
   consumer_ = consumer;
 }
 
 void Logging::Enable() {
   enabled_ = true;
 }
 
 void Logging::Disable() {
   enabled_ = false;
@@ skipping 70 matching lines @@
     Log(data);
   } else {
     main_thread_->PostTask(FROM_HERE, NewRunnableMethod(
         this, &Logging::Log, data));
   }
 }
 
 void Logging::GetMessageText(uint32 type, std::string* name,
                              const Message* message,
                              std::string* params) {
-  if (!log_function_mapping_)
+  if (!log_function_map_)
     return;
 
-  int message_class = type >> 16;
-  if (log_function_mapping_[message_class] != NULL) {
-    log_function_mapping_[message_class](type, name, message, params);
-  } else {
-    DVLOG(1) << "No logger function associated with message class "
-             << message_class;
+  LogFunctionMap::iterator it = log_function_map_->find(type);
+  if (it == log_function_map_->end()) {
+    if (name) {
+      *name = "[UNKNOWN MSG ";
+      *name += base::IntToString(type);
+      *name += " ]";
+    }
+    return;
   }
+
+  (*it->second)(name, message, params);
 }
 
 void Logging::Log(const LogData& data) {
   if (consumer_) {
     // We're in the browser process.
     consumer_->Log(data);
   } else {
     // We're in the renderer or plugin processes.
     if (sender_) {
       queued_logs_.push_back(data);
@@ skipping 55 matching lines @@
     data->receive = message.received_time();
     data->dispatch = Time::Now().ToInternalValue();
     data->params = params;
     data->message_name = message_name;
   }
 }
 
 }
 
 #endif  // IPC_MESSAGE_LOG_ENABLED