dbus: Fix a bug where we were emitting spurious error messages.

dbus/object_proxy.cc

 // 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.
 
 #include "dbus/bus.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 116 matching lines @@
 
 void ObjectProxy::Detach() {
   bus_->AssertOnDBusThread();
 
   if (filter_added_) {
     if (!bus_->RemoveFilterFunction(&ObjectProxy::HandleMessageThunk, this)) {
       LOG(ERROR) << "Failed to remove filter function";
     }
   }
 
-  for (size_t i = 0; i < match_rules_.size(); ++i) {
+  for (std::set<std::string>::iterator iter = match_rules_.begin();
+       iter != match_rules_.end(); ++iter) {
     ScopedDBusError error;
-    bus_->RemoveMatch(match_rules_[i], error.get());
+    bus_->RemoveMatch(*iter, error.get());
     if (error.is_set()) {
       // There is nothing we can do to recover, so just print the error.
-      LOG(ERROR) << "Failed to remove match rule: " << match_rules_[i];
+      LOG(ERROR) << "Failed to remove match rule: " << *iter;
     }
   }
+  match_rules_.clear();
 }
 
 // static
 ObjectProxy::ResponseCallback ObjectProxy::EmptyResponseCallback() {
   return base::Bind(&EmptyResponseCallbackBody);
 }
 
 ObjectProxy::OnPendingCallIsCompleteData::OnPendingCallIsCompleteData(
     ObjectProxy* in_object_proxy,
     ResponseCallback in_response_callback,
@@ skipping 142 matching lines @@
     }
     // Add a match rule so the signal goes through HandleMessage().
     //
     // We don't restrict the sender object path to be |object_path_| here,
     // to make it easy to test D-Bus signal handling with dbus-send, that
     // uses "/" as the sender object path. We can make the object path
     // restriction customizable when it becomes necessary.
     const std::string match_rule =
         base::StringPrintf("type='signal', interface='%s'",
                            interface_name.c_str());
-    ScopedDBusError error;
-    bus_->AddMatch(match_rule, error.get());;
-    if (error.is_set()) {
-      LOG(ERROR) << "Failed to add match rule: " << match_rule;
+
+    // Add the match rule if we don't have it.
+    if (match_rules_.find(match_rule) == match_rules_.end()) {
+      ScopedDBusError error;
+      bus_->AddMatch(match_rule, error.get());;
+      if (error.is_set()) {
+        LOG(ERROR) << "Failed to add match rule: " << match_rule;
+      } else {
+        // Store the match rule, so that we can remove this in Detach().
+        match_rules_.insert(match_rule);
+        // Add the signal callback to the method table.
+        method_table_[absolute_signal_name] = signal_callback;
+        success = true;
+      }
     } else {
-      // Store the match rule, so that we can remove this in Detach().
-      match_rules_.push_back(match_rule);
-      // Add the signal callback to the method table.
+      // We already have the match rule.
       method_table_[absolute_signal_name] = signal_callback;
       success = true;
     }
   }
 
   // Run on_connected_callback in the origin thread.
   bus_->PostTaskToOriginThread(
       FROM_HERE,
       base::Bind(&ObjectProxy::OnConnected,
                  this,
@@ skipping 75 matching lines @@
 
 DBusHandlerResult ObjectProxy::HandleMessageThunk(
     DBusConnection* connection,
     DBusMessage* raw_message,
     void* user_data) {
   ObjectProxy* self = reinterpret_cast<ObjectProxy*>(user_data);
   return self->HandleMessage(connection, raw_message);
 }
 
 }  // namespace dbus