Remove IPC channel IDs.

ipc/ipc_logging.cc

 // Copyright (c) 2012 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
 #define IPC_MESSAGE_MACROS_LOG_ENABLED
 #endif
 
@@ skipping 104 matching lines @@
   std::vector<LogData> data;
   base::PickleIterator iter(message);
   if (!ReadParam(&message, &iter, &data))
     return;
 
   for (size_t i = 0; i < data.size(); ++i) {
     Log(data[i]);
   }
 }
 
-void Logging::OnSendMessage(Message* message, const std::string& channel_id) {
+void Logging::OnSendMessage(Message* message) {
   if (!Enabled())
     return;
 
   if (message->is_reply()) {
     LogData* data = message->sync_log_data();
     if (!data)
       return;
 
     // This is actually the delayed reply to a sync message.  Create a string
     // of the output parameters, add it to the LogData that was earlier stashed
     // with the reply, and log the result.
-    GenerateLogData("", *message, data, true);
-    data->channel = channel_id;
+    GenerateLogData(*message, data, true);
     Log(*data);
     delete data;
     message->set_sync_log_data(NULL);
   } else {
     // If the time has already been set (i.e. by ChannelProxy), keep that time
     // instead as it's more accurate.
     if (!message->sent_time())
       message->set_sent_time(Time::Now().ToInternalValue());
   }
 }
 
 void Logging::OnPreDispatchMessage(const Message& message) {
   message.set_received_time(Time::Now().ToInternalValue());
 }
 
-void Logging::OnPostDispatchMessage(const Message& message,
-                                    const std::string& channel_id) {
+void Logging::OnPostDispatchMessage(const Message& message) {
   if (!Enabled() ||
       !message.sent_time() ||
       !message.received_time() ||
       message.dont_log())
     return;
 
   LogData data;
-  GenerateLogData(channel_id, message, &data, true);
+  GenerateLogData(message, &data, true);
 
   if (main_thread_->BelongsToCurrentThread()) {
     Log(data);
   } else {
     main_thread_->PostTask(
         FROM_HERE, base::Bind(&Logging::Log, base::Unretained(this), data));
   }
 }
 
 void Logging::GetMessageText(uint32_t type, std::string* name,
@@ skipping 74 matching lines @@
     } else {
       message_name = data.message_name;
     }
     double receive_delay =
         (Time::FromInternalValue(data.receive) -
          Time::FromInternalValue(data.sent)).InSecondsF();
     double dispatch_delay =
         (Time::FromInternalValue(data.dispatch) -
          Time::FromInternalValue(data.sent)).InSecondsF();
     fprintf(stderr,
-            "ipc %s %d %s %s%s %s%s\n  %18.5f %s%18.5f %s%18.5f%s\n",
-            data.channel.c_str(),
+            "ipc %d %s %s%s %s%s\n  %18.5f %s%18.5f %s%18.5f%s\n",
             data.routing_id,
             data.flags.c_str(),
             ANSIEscape(sender_ ? ANSI_COLOR_BLUE : ANSI_COLOR_CYAN),
             message_name.c_str(),
             ANSIEscape(ANSI_COLOR_RESET),
             data.params.c_str(),
             Time::FromInternalValue(data.sent).ToDoubleT(),
             ANSIEscape(DelayColor(receive_delay)),
             Time::FromInternalValue(data.receive).ToDoubleT(),
             ANSIEscape(DelayColor(dispatch_delay)),
             Time::FromInternalValue(data.dispatch).ToDoubleT(),
             ANSIEscape(ANSI_COLOR_RESET)
             );
   }
 }
 
-void GenerateLogData(const std::string& channel, const Message& message,
-                     LogData* data, bool get_params) {
+void GenerateLogData(const Message& message, LogData* data, bool get_params) {
   if (message.is_reply()) {
     // "data" should already be filled in.
     std::string params;
     Logging::GetMessageText(data->type, NULL, &message, &params);
 
     if (!data->params.empty() && !params.empty())
       data->params += ", ";
 
     data->flags += " DR";
 
     data->params += params;
   } else {
     std::string flags;
     if (message.is_sync())
       flags = "S";
 
     if (message.is_reply())
       flags += "R";
 
     if (message.is_reply_error())
       flags += "E";
 
     std::string params, message_name;
     Logging::GetMessageText(message.type(), &message_name, &message,
                             get_params ? &params : NULL);
 
-    data->channel = channel;
     data->routing_id = message.routing_id();
     data->type = message.type();
     data->flags = flags;
     data->sent = message.sent_time();
     data->receive = message.received_time();
     data->dispatch = Time::Now().ToInternalValue();
     data->params = params;
     data->message_name = message_name;
   }
 }
 
 }
 
 #endif  // IPC_MESSAGE_LOG_ENABLED