Remove IPC channel IDs.

ipc/ipc_channel_proxy.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_channel_proxy.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 55 matching lines @@
 
 void ChannelProxy::Context::ClearIPCTaskRunner() {
   ipc_task_runner_ = NULL;
 }
 
 void ChannelProxy::Context::CreateChannel(
     std::unique_ptr<ChannelFactory> factory) {
   base::AutoLock l(channel_lifetime_lock_);
   DCHECK(!channel_);
   DCHECK_EQ(factory->GetIPCTaskRunner(), ipc_task_runner_);
-  channel_id_ = factory->GetName();
   channel_ = factory->BuildChannel(this);
 
   Channel::AssociatedInterfaceSupport* support =
       channel_->GetAssociatedInterfaceSupport();
   if (support) {
     associated_group_ = *support->GetAssociatedGroup();
 
     base::AutoLock l(pending_filters_lock_);
     for (auto& entry : pending_interfaces_)
       support->AddGenericAssociatedInterface(entry.first, entry.second);
     pending_interfaces_.clear();
   }
 }
 
 bool ChannelProxy::Context::TryFilters(const Message& message) {
   DCHECK(message_filter_router_);
 #ifdef IPC_MESSAGE_LOG_ENABLED
   Logging* logger = Logging::GetInstance();
   if (logger->Enabled())
     logger->OnPreDispatchMessage(message);
 #endif
 
   if (message_filter_router_->TryFilters(message)) {
     if (message.dispatch_error()) {
       listener_task_runner_->PostTask(
           FROM_HERE, base::Bind(&Context::OnDispatchBadMessage, this, message));
     }
 #ifdef IPC_MESSAGE_LOG_ENABLED
     if (logger->Enabled())
-      logger->OnPostDispatchMessage(message, channel_id_);
+      logger->OnPostDispatchMessage(message);
 #endif
     return true;
   }
   return false;
 }
 
 // Called on the IPC::Channel thread
 void ChannelProxy::Context::PauseChannel() {
   DCHECK(channel_);
   channel_->Pause();
@@ skipping 225 matching lines @@
   if (logger->Enabled())
     logger->OnPreDispatchMessage(message);
 #endif
 
   listener_->OnMessageReceived(message);
   if (message.dispatch_error())
     listener_->OnBadMessageReceived(message);
 
 #ifdef IPC_MESSAGE_LOG_ENABLED
   if (logger->Enabled())
-    logger->OnPostDispatchMessage(message, channel_id_);
+    logger->OnPostDispatchMessage(message);
 #endif
 }
 
 // Called on the listener's thread
 void ChannelProxy::Context::OnDispatchConnected() {
   if (channel_connected_called_)
     return;
 
   base::ProcessId peer_pid;
   {
@@ skipping 200 matching lines @@
 
 #ifdef ENABLE_IPC_FUZZER
   // In IPC fuzzing builds, it is possible to define a filter to apply to
   // outgoing messages. It will either rewrite the message and return a new
   // one, freeing the original, or return the message unchanged.
   if (outgoing_message_filter())
     message = outgoing_message_filter()->Rewrite(message);
 #endif
 
 #ifdef IPC_MESSAGE_LOG_ENABLED
-  Logging::GetInstance()->OnSendMessage(message, context_->channel_id());
+  Logging::GetInstance()->OnSendMessage(message);
 #endif
 
   context_->Send(message);
   return true;
 }
 
 void ChannelProxy::AddFilter(MessageFilter* filter) {
   DCHECK(CalledOnValidThread());
 
   context_->AddFilter(filter);
@@ skipping 37 matching lines @@
 
   context()->ClearIPCTaskRunner();
 }
 
 void ChannelProxy::OnChannelInit() {
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace IPC