Add sender verification of D-Bus signals.

dbus/object_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 DBUS_OBJECT_PROXY_H_
 #define DBUS_OBJECT_PROXY_H_
 
 #include <dbus/dbus.h>
 
 #include <map>
@@ skipping 196 matching lines @@
   void OnConnected(OnConnectedCallback on_connected_callback,
                    const std::string& interface_name,
                    const std::string& signal_name,
                    bool success);
 
   // Handles the incoming request messages and dispatches to the signal
   // callbacks.
   DBusHandlerResult HandleMessage(DBusConnection* connection,
                                   DBusMessage* raw_message);
 
+  // Verifies the sender, checks if we know about the signal, and invokes the
+  // callback if any.

[satorux1, 2012/10/25 08:56:23]

callback if any -> callback associated with the signal.

[Haruki Sato, 2012/10/26 05:03:24]

Removed method.

+  DBusHandlerResult VerifySenderAndDispatch(scoped_ptr<dbus::Signal> signal);
+
   // Runs the method. Helper function for HandleMessage().
   void RunMethod(base::TimeTicks start_time,
                  SignalCallback signal_callback,
                  Signal* signal);
 
   // Redirects the function call to HandleMessage().
   static DBusHandlerResult HandleMessageThunk(DBusConnection* connection,
                                               DBusMessage* raw_message,
                                               void* user_data);
 
   // Helper method for logging response errors appropriately.
   void LogMethodCallFailure(const base::StringPiece& interface_name,
                             const base::StringPiece& method_name,
                             const base::StringPiece& error_name,
                             const base::StringPiece& error_message) const;
 
   // Used as ErrorCallback by CallMethod().
   void OnCallMethodError(const std::string& interface_name,
                          const std::string& method_name,
                          ResponseCallback response_callback,
                          ErrorResponse* error_response);
 
+  // Adds the match rule to the bus and associate the callback with the signal.
+  bool AddMatchRuleWithCallback(const std::string& match_rule,
+                                const std::string& absolute_signal_name,
+                                SignalCallback signal_callback);
+
+  // Adds the match rule to the bus so that HandleMessage can see the signal.
+  bool AddMatchRuleWithoutCallback(const std::string& match_rule,
+                                   const std::string& absolute_signal_name);
+
+  // Calls D-Bus's GetNameOwner method asynchronously to update the owner of
+  // |service_name_|. |pending_signal| will be processed after receiving the
+  // response for GetNameOwner. If |pending_signal| is NULL, it just update
+  // the owner information.
+  DBusHandlerResult UpdateNameOwnerAsync(scoped_ptr<Signal> pending_signal);
+
+  // Handles NameOwnerChanged signal from D-Bus's special message bus.
+  DBusHandlerResult HandleNameOwnerChanged(dbus::Signal* signal);
+
+  // Helper Processes the response of GetNameOwner method call.
+  void OnGetNameOwner(Signal* signal, Response* callback);
+
+  // Helper function for OnGetNameOwner.
+  void OnGetNameOwnerOnDbusThread(Signal* signal, Response* callback);
+
+  // Processes the error response of GetNameOwner method call.
+  void OnGetNameOwnerError(Signal* signal, ErrorResponse* callback);
+
+  // Helper function for OnGetNameOwnerError.
+  void OnGetNameOwnerErrorOnDbusThread(Signal* signal, ErrorResponse* callback);
+
   scoped_refptr<Bus> bus_;
   std::string service_name_;
   ObjectPath object_path_;
 
   // True if the message filter was added.
   bool filter_added_;
 
   // The method table where keys are absolute signal names (i.e. interface
   // name + signal name), and values are the corresponding callbacks.
   typedef std::map<std::string, SignalCallback> MethodTable;
   MethodTable method_table_;
 
   std::set<std::string> match_rules_;
 
   const bool ignore_service_unknown_errors_;
 
+  // Known name owner of the well-known bus name represnted by |service_name_|.
+  std::string service_name_owner_;
+
   DISALLOW_COPY_AND_ASSIGN(ObjectProxy);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_OBJECT_PROXY_H_