Add a base class for objects that want to filter messages on the UI thread. ...

ipc/ipc_sync_channel.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 "ipc/ipc_sync_channel.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/thread_local.h"
 #include "base/message_loop.h"
@@ skipping 182 matching lines @@
   // a local global stack of send done watchers to ensure that nested sync
   // message loops complete correctly.
   base::WaitableEventWatcher* top_send_done_watcher_;
 };
 
 base::LazyInstance<base::ThreadLocalPointer<SyncChannel::ReceivedSyncMsgQueue> >
     SyncChannel::ReceivedSyncMsgQueue::lazy_tls_ptr_(base::LINKER_INITIALIZED);
 
 SyncChannel::SyncContext::SyncContext(
     Channel::Listener* listener,
-    MessageFilter* filter,
     MessageLoop* ipc_thread,
     WaitableEvent* shutdown_event)
-    : ChannelProxy::Context(listener, filter, ipc_thread),
+    : ChannelProxy::Context(listener, ipc_thread),
       received_sync_msgs_(ReceivedSyncMsgQueue::AddContext()),
       shutdown_event_(shutdown_event) {
 }
 
 SyncChannel::SyncContext::~SyncContext() {
   while (!deserializers_.empty())
     Pop();
 }
 
 // Adds information about an outgoing sync message to the context so that
@@ skipping 132 matching lines @@
     CancelPendingSends();
   } else {
     // We got the reply, timed out or the process shutdown.
     DCHECK(event == GetSendDoneEvent());
     MessageLoop::current()->QuitNow();
   }
 }
 
 
 SyncChannel::SyncChannel(
-    const std::string& channel_id, Channel::Mode mode,
-    Channel::Listener* listener, MessageFilter* filter,
-    MessageLoop* ipc_message_loop, bool create_pipe_now,
+    const std::string& channel_id,
+    Channel::Mode mode,
+    Channel::Listener* listener,
+    MessageLoop* ipc_message_loop,
+    bool create_pipe_now,
     WaitableEvent* shutdown_event)
     : ChannelProxy(
           channel_id, mode, ipc_message_loop,
-          new SyncContext(listener, filter, ipc_message_loop, shutdown_event),
+          new SyncContext(listener, ipc_message_loop, shutdown_event),
           create_pipe_now),
       sync_messages_with_no_timeout_allowed_(true) {
   // Ideally we only want to watch this object when running a nested message
   // loop.  However, we don't know when it exits if there's another nested
   // message loop running under it or not, so we wouldn't know whether to
   // stop or keep watching.  So we always watch it, and create the event as
   // manual reset since the object watcher might otherwise reset the event
   // when we're doing a WaitMany.
   dispatch_watcher_.StartWatching(sync_context()->GetDispatchEvent(), this);
 }
@@ skipping 108 matching lines @@
 void SyncChannel::OnWaitableEventSignaled(WaitableEvent* event) {
   DCHECK(event == sync_context()->GetDispatchEvent());
   // The call to DispatchMessages might delete this object, so reregister
   // the object watcher first.
   event->Reset();
   dispatch_watcher_.StartWatching(event, this);
   sync_context()->DispatchMessages();
 }
 
 }  // namespace IPC