Allow MessageFilters to restrict listening to specific message classes

ipc/ipc_channel_proxy.h

 // 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.
 
 #ifndef IPC_IPC_CHANNEL_PROXY_H_
 #define IPC_IPC_CHANNEL_PROXY_H_
 
 #include <vector>
 
 #include "base/memory/ref_counted.h"
@@ skipping 70 matching lines @@
     virtual void OnChannelError();
 
     // Called to inform the filter that the IPC channel will be destroyed.
     // OnFilterRemoved is called immediately after this.
     virtual void OnChannelClosing();
 
     // Return true to indicate that the message was handled, or false to let
     // the message be handled in the default way.
     virtual bool OnMessageReceived(const Message& message);
 
+    // Called to query the Message classes supported by the filter.  Return
+    // false to indicate that all message types should reach the filter, or true
+    // if the resulting contents of |supported_message_classes| may be used to
+    // selectively offer messages of a particular class to the filter.
+    virtual bool GetSupportedMessageClasses(
+        std::vector<uint32>* supported_message_classes) const;
+
    protected:
     virtual ~MessageFilter();
 
    private:
     friend class base::RefCountedThreadSafe<MessageFilter>;
   };
 
   // Initializes a channel proxy.  The channel_handle and mode parameters are
   // passed directly to the underlying IPC::Channel.  The listener is called on
   // the thread that creates the ChannelProxy.  The filter's OnMessageReceived
@@ skipping 116 matching lines @@
 
     // Methods called on the listener thread.
     void AddFilter(MessageFilter* filter);
     void OnDispatchConnected();
     void OnDispatchError();
 
     scoped_refptr<base::SingleThreadTaskRunner> listener_task_runner_;
     Listener* listener_;
 
     // List of filters.  This is only accessed on the IPC thread.
-    std::vector<scoped_refptr<MessageFilter> > filters_;
+    std::vector<scoped_refptr<MessageFilter> > all_filters_;

[piman, 2014/02/11 21:48:46]

Do we need this? Can't we just iterate over message_global_filters_ and
message_class_filters_ each time?

[jdduke (slow), 2014/02/11 23:01:48]

Well, there are a few operations where we iterate over each filter once and call
a particular function, e.g., |OnChannelError()|, |OnChannelClosed()|.  If we
don't store the list of all filters, we'd need to dynamically generate a unique
list of filters from those in  |message_class_filters_|.

     scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner_;
     scoped_ptr<Channel> channel_;
     std::string channel_id_;
     bool channel_connected_called_;
 
+    // List of global and selective filters; a given filter from |all_filters_|
+    // will exists in either |message_global_filters_| OR
+    // |message_class_filters_|, but not both.
+    std::vector<MessageFilter*> message_global_filters_;
+    // TODO(jdduke): Determine if base::SmallMap is a sensible choice here,
+    // or simply an array of length (LastIPCMsgStart + 1).

[epennerAtGoogle, 2014/02/10 23:55:47]

+1 to just a resized-vector, or something equivalent.

[piman, 2014/02/11 21:48:46]

An array sg.
Generally, hash_maps are preferred to maps if the order doesn't matter (usually
cheaper both in run-time and memory), but in this case, because the size is
static and the key space is compact, an array is even better.

[jdduke (slow), 2014/02/11 23:01:48]

Done.

[epennerAtGoogle, 2014/02/12 02:34:09]

Just FYI, I mentioned vector since it typically has bounds checking in debug
builds (at least IIRC - I haven't actually checked). If our other tools are good
enough to catch out-of-bounds these days, no worries (it's also pretty simple
code).

+    typedef std::map<uint32, std::vector<MessageFilter*> >
+        MessageClassFilterMap;
+    MessageClassFilterMap message_class_filters_;
+
     // Holds filters between the AddFilter call on the listerner thread and the
     // IPC thread when they're added to filters_.
     std::vector<scoped_refptr<MessageFilter> > pending_filters_;
     // Lock for pending_filters_.
     base::Lock pending_filters_lock_;
 
     // Cached copy of the peer process ID. Set on IPC but read on both IPC and
     // listener threads.
     base::ProcessId peer_pid_;
   };
 
   Context* context() { return context_.get(); }
 
  private:
   friend class SendCallbackHelper;
 
   // By maintaining this indirection (ref-counted) to our internal state, we
   // can safely be destroyed while the background thread continues to do stuff
   // that involves this data.
   scoped_refptr<Context> context_;
 
   // Whether the channel has been initialized.
   bool did_init_;
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_PROXY_H_