Fix a bug in dbus::Bus::AddFilterFunction().

dbus/bus.h

 // Copyright (c) 2011 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 DBUS_BUS_H_
 #define DBUS_BUS_H_
 #pragma once
 
 #include <map>
 #include <set>
 #include <string>
+#include <utility>
 #include <dbus/dbus.h>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/tracked_objects.h"
 
 class MessageLoop;
 
@@ skipping 255 matching lines @@
                              DBusPendingCall** pending_call,
                              int timeout_ms);
 
   // Requests to send a message to the bus. The message serial number will
   // be stored in |serial|.
   //
   // BLOCKING CALL.
   virtual void Send(DBusMessage* request, uint32* serial);
 
   // Adds the message filter function. |filter_function| will be called
-  // when incoming messages are received.
+  // when incoming messages are received. Returns true on success.
   //
   // When a new incoming message arrives, filter functions are called in
   // the order that they were added until the the incoming message is
   // handled by a filter function.
   //
-  // The same filter function must not be added more than once.
+  // The same filter function associated with the same user data cannot be
+  // added more than once. Returns false for this case.
   //
   // BLOCKING CALL.
-  virtual void AddFilterFunction(DBusHandleMessageFunction filter_function,
+  virtual bool AddFilterFunction(DBusHandleMessageFunction filter_function,
                                  void* user_data);
 
   // Removes the message filter previously added by AddFilterFunction().
+  // Returns true on success.
   //
   // BLOCKING CALL.
-  virtual void RemoveFilterFunction(DBusHandleMessageFunction filter_function,
+  virtual bool RemoveFilterFunction(DBusHandleMessageFunction filter_function,
                                     void* user_data);
 
   // Adds the match rule. Messages that match the rule will be processed
   // by the filter functions added by AddFilterFunction().
   //
   // You cannot specify which filter function to use for a match rule.
   // Instead, you should check if an incoming message is what you are
   // interested in, in the filter functions.
   //
   // The same match rule must not be added more than once.
@@ skipping 124 matching lines @@
   DBusConnection* connection_;
 
   scoped_refptr<base::MessageLoopProxy> origin_message_loop_proxy_;
   base::PlatformThreadId origin_thread_id_;
 
   std::set<std::string> owned_service_names_;
   // The following sets are used to check if rules/object_paths/filters
   // are properly cleaned up before destruction of the bus object.
   std::set<std::string> match_rules_added_;
   std::set<std::string> registered_object_paths_;
-  std::set<DBusHandleMessageFunction> filter_functions_added_;
+  std::set<std::pair<DBusHandleMessageFunction, void*> >
+      filter_functions_added_;
 
   // ObjectProxyTable is used to hold the object proxies created by the
   // bus object. Key is a concatenated string of service name + object path,
   // like "org.chromium.TestService/org/chromium/TestObject".
   typedef std::map<std::string,
                    scoped_refptr<dbus::ObjectProxy> > ObjectProxyTable;
   ObjectProxyTable object_proxy_table_;
 
   // ExportedObjectTable is used to hold the exported objects created by
   // the bus object. Key is a concatenated string of service name +
   // object path, like "org.chromium.TestService/org/chromium/TestObject".
   typedef std::map<std::string,
                    scoped_refptr<dbus::ExportedObject> > ExportedObjectTable;
   ExportedObjectTable exported_object_table_;
 
   bool async_operations_set_up_;
   bool shutdown_completed_;
 
   // Counters to make sure that OnAddWatch()/OnRemoveWatch() and
   // OnAddTimeout()/OnRemoveTimeou() are balanced.
   int num_pending_watches_;
   int num_pending_timeouts_;
 
   DISALLOW_COPY_AND_ASSIGN(Bus);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_BUS_H_