Add a method to check if a D-Bus service has an owner. Use it for mtpd.

dbus/object_proxy.cc

 // 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.
 
 #include "dbus/bus.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_piece.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "dbus/dbus_statistics.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "dbus/scoped_dbus_error.h"
 
+namespace dbus {
+
 namespace {
 
 const char kErrorServiceUnknown[] = "org.freedesktop.DBus.Error.ServiceUnknown";
 
 // Used for success ratio histograms. 1 for success, 0 for failure.
 const int kSuccessRatioHistogramMaxValue = 2;
 
 // The path of D-Bus Object sending NameOwnerChanged signal.
 const char kDBusSystemObjectPath[] = "/org/freedesktop/DBus";
 
+// The D-Bus Object interface.
+const char kDBusSystemObjectInterface[] = "org.freedesktop.DBus";
+
+// The D-Bus Object address.
+const char kDBusSystemObjectAddress[] = "org.freedesktop.DBus";
+
+// The NameOwnerChanged member in |kDBusSystemObjectInterface|.
+const char kNameOwnerChangedMember[] = "NameOwnerChanged";
+
 // Gets the absolute signal name by concatenating the interface name and
 // the signal name. Used for building keys for method_table_ in
 // ObjectProxy.
 std::string GetAbsoluteSignalName(
     const std::string& interface_name,
     const std::string& signal_name) {
   return interface_name + "." + signal_name;
 }
 
 // An empty function used for ObjectProxy::EmptyResponseCallback().
-void EmptyResponseCallbackBody(dbus::Response* unused_response) {
+void EmptyResponseCallbackBody(Response* /*response*/) {
 }
 
 }  // namespace
 
-namespace dbus {
-
 ObjectProxy::ObjectProxy(Bus* bus,
                          const std::string& service_name,
                          const ObjectPath& object_path,
                          int options)
     : bus_(bus),
       service_name_(service_name),
       object_path_(object_path),
       filter_added_(false),
       ignore_service_unknown_errors_(
           options & IGNORE_SERVICE_UNKNOWN_ERRORS) {
@@ skipping 220 matching lines @@
                                       DBusMessage* response_message) {
   bus_->AssertOnOriginThread();
 
   bool method_call_successful = false;
   if (!response_message) {
     // The response is not received.
     error_callback.Run(NULL);
   } else if (dbus_message_get_type(response_message) ==
              DBUS_MESSAGE_TYPE_ERROR) {
     // This will take |response_message| and release (unref) it.
-    scoped_ptr<dbus::ErrorResponse> error_response(
-        dbus::ErrorResponse::FromRawMessage(response_message));
+    scoped_ptr<ErrorResponse> error_response(
+        ErrorResponse::FromRawMessage(response_message));
     error_callback.Run(error_response.get());
     // Delete the message  on the D-Bus thread. See below for why.
     bus_->PostTaskToDBusThread(
         FROM_HERE,
-        base::Bind(&base::DeletePointer<dbus::ErrorResponse>,
+        base::Bind(&base::DeletePointer<ErrorResponse>,
                    error_response.release()));
   } else {
     // This will take |response_message| and release (unref) it.
-    scoped_ptr<dbus::Response> response(
-        dbus::Response::FromRawMessage(response_message));
+    scoped_ptr<Response> response(Response::FromRawMessage(response_message));
     // The response is successfully received.
     response_callback.Run(response.get());
     // The message should be deleted on the D-Bus thread for a complicated
     // reason:
     //
     // libdbus keeps track of the number of bytes in the incoming message
     // queue to ensure that the data size in the queue is manageable. The
     // bookkeeping is partly done via dbus_message_unref(), and immediately
     // asks the client code (Chrome) to stop monitoring the underlying
     // socket, if the number of bytes exceeds a certian number, which is set
     // to 63MB, per dbus-transport.cc:
     //
     //   /* Try to default to something that won't totally hose the system,
     //    * but doesn't impose too much of a limitation.
     //    */
     //   transport->max_live_messages_size = _DBUS_ONE_MEGABYTE * 63;
     //
     // The monitoring of the socket is done on the D-Bus thread (see Watch
     // class in bus.cc), hence we should stop the monitoring from D-Bus
     // thread, not from the current thread here, which is likely UI thread.
     bus_->PostTaskToDBusThread(
         FROM_HERE,
-        base::Bind(&base::DeletePointer<dbus::Response>,
-                   response.release()));
+        base::Bind(&base::DeletePointer<Response>, response.release()));
 
     method_call_successful = true;
     // Record time spent for the method call. Don't include failures.
     UMA_HISTOGRAM_TIMES("DBus.AsyncMethodCallTime",
                         base::TimeTicks::Now() - start_time);
   }
   // Record if the method call is successful, or not. 1 if successful.
   UMA_HISTOGRAM_ENUMERATION("DBus.AsyncMethodCallSuccess",
                             method_call_successful,
                             kSuccessRatioHistogramMaxValue);
@@ skipping 98 matching lines @@
 
   // raw_message will be unrefed on exit of the function. Increment the
   // reference so we can use it in Signal.
   dbus_message_ref(raw_message);
   scoped_ptr<Signal> signal(
       Signal::FromRawMessage(raw_message));
 
   // Verify the signal comes from the object we're proxying for, this is
   // our last chance to return DBUS_HANDLER_RESULT_NOT_YET_HANDLED and
   // allow other object proxies to handle instead.
-  const dbus::ObjectPath path = signal->GetPath();
+  const ObjectPath path = signal->GetPath();
   if (path != object_path_) {
     if (path.value() == kDBusSystemObjectPath &&
-        signal->GetMember() == "NameOwnerChanged") {
+        signal->GetMember() == kNameOwnerChangedMember) {
       // Handle NameOwnerChanged separately
       return HandleNameOwnerChanged(signal.Pass());
     }
     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
   }
 
   const std::string interface = signal->GetInterface();
   const std::string member = signal->GetMember();
 
   statistics::AddReceivedSignal(service_name_, interface, member);
@@ skipping 44 matching lines @@
   bus_->AssertOnOriginThread();
 
   for (std::vector<SignalCallback>::iterator iter = signal_callbacks.begin();
        iter != signal_callbacks.end(); ++iter)
     iter->Run(signal);
 
   // Delete the message on the D-Bus thread. See comments in
   // RunResponseCallback().
   bus_->PostTaskToDBusThread(
       FROM_HERE,
-      base::Bind(&base::DeletePointer<dbus::Signal>, signal));
+      base::Bind(&base::DeletePointer<Signal>, signal));
 
   // Record time spent for handling the signal.
   UMA_HISTOGRAM_TIMES("DBus.SignalHandleTime",
                       base::TimeTicks::Now() - start_time);
 }
 
 DBusHandlerResult ObjectProxy::HandleMessageThunk(
     DBusConnection* connection,
     DBusMessage* raw_message,
     void* user_data) {
@@ skipping 13 matching lines @@
              << ": object_path= " << object_path_.value()
              << ": " << error_name << ": " << error_message;
 }
 
 void ObjectProxy::OnCallMethodError(const std::string& interface_name,
                                     const std::string& method_name,
                                     ResponseCallback response_callback,
                                     ErrorResponse* error_response) {
   if (error_response) {
     // Error message may contain the error message as string.
-    dbus::MessageReader reader(error_response);
+    MessageReader reader(error_response);
     std::string error_message;
     reader.PopString(&error_message);
     LogMethodCallFailure(interface_name,
                          method_name,
                          error_response->GetErrorName(),
                          error_message);
   }
   response_callback.Run(NULL);
 }
 
 bool ObjectProxy::AddMatchRuleWithCallback(
     const std::string& match_rule,
     const std::string& absolute_signal_name,
     SignalCallback signal_callback) {
   DCHECK(!match_rule.empty());
   DCHECK(!absolute_signal_name.empty());
   bus_->AssertOnDBusThread();
 
   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 << "\". Got " <<
-          error.name() << ": " << error.message();
+      LOG(ERROR) << "Failed to add match rule \"" << match_rule << "\". Got "
+                 << error.name() << ": " << error.message();
       return false;
     } 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].push_back(signal_callback);
       return true;
     }
   } else {
     // We already have the match rule.
     method_table_[absolute_signal_name].push_back(signal_callback);
     return true;
   }
 }
 
 bool ObjectProxy::AddMatchRuleWithoutCallback(
     const std::string& match_rule,
     const std::string& absolute_signal_name) {
   DCHECK(!match_rule.empty());
   DCHECK(!absolute_signal_name.empty());
   bus_->AssertOnDBusThread();
 
   if (match_rules_.find(match_rule) != match_rules_.end())
     return true;
 
   ScopedDBusError error;
   bus_->AddMatch(match_rule, error.get());
   if (error.is_set()) {
-    LOG(ERROR) << "Failed to add match rule \"" << match_rule << "\". Got " <<
-        error.name() << ": " << error.message();
+    LOG(ERROR) << "Failed to add match rule \"" << match_rule << "\". Got "
+               << error.name() << ": " << error.message();
     return false;
   }
   // Store the match rule, so that we can remove this in Detach().
   match_rules_.insert(match_rule);
   return true;
 }
 
 void ObjectProxy::UpdateNameOwnerAndBlock() {
   bus_->AssertOnDBusThread();
-
-  MethodCall get_name_owner_call("org.freedesktop.DBus", "GetNameOwner");
-  MessageWriter writer(&get_name_owner_call);
-  writer.AppendString(service_name_);
-  VLOG(1) << "Method call: " << get_name_owner_call.ToString();
-
-  const dbus::ObjectPath obj_path("/org/freedesktop/DBus");
-  ScopedDBusError error;
-  if (!get_name_owner_call.SetDestination("org.freedesktop.DBus") ||
-      !get_name_owner_call.SetPath(obj_path)) {
-    LOG(ERROR) << "Failed to get name owner.";
-    return;
-  }
-
-  DBusMessage* response_message = bus_->SendWithReplyAndBlock(
-      get_name_owner_call.raw_message(),
-      TIMEOUT_USE_DEFAULT,
-      error.get());
-  if (!response_message) {
-    LOG(ERROR) << "Failed to get name owner. Got " << error.name() << ": " <<
-        error.message();
-    return;
-  }
-  scoped_ptr<Response> response(Response::FromRawMessage(response_message));
-  MessageReader reader(response.get());
-
-  std::string new_service_name_owner;
-  if (reader.PopString(&new_service_name_owner))
-    service_name_owner_ = new_service_name_owner;
-  else
-    service_name_owner_.clear();
+  service_name_owner_ =
+      bus_->GetServiceOwnerAndBlock(service_name_, Bus::SUPPRESS_ERRORS);
 }
 
 DBusHandlerResult ObjectProxy::HandleNameOwnerChanged(
     scoped_ptr<Signal> signal) {
   DCHECK(signal);
   bus_->AssertOnDBusThread();
 
   // Confirm the validity of the NameOwnerChanged signal.
-  if (signal->GetMember() == "NameOwnerChanged" &&
-      signal->GetInterface() == "org.freedesktop.DBus" &&
-      signal->GetSender() == "org.freedesktop.DBus") {
+  if (signal->GetMember() == kNameOwnerChangedMember &&
+      signal->GetInterface() == kDBusSystemObjectInterface &&
+      signal->GetSender() == kDBusSystemObjectAddress) {
     MessageReader reader(signal.get());
     std::string name, old_owner, new_owner;
     if (reader.PopString(&name) &&
         reader.PopString(&old_owner) &&
         reader.PopString(&new_owner) &&
         name == service_name_) {
       service_name_owner_ = new_owner;
       if (!name_owner_changed_callback_.is_null()) {
         const base::TimeTicks start_time = base::TimeTicks::Now();
         Signal* released_signal = signal.release();
         std::vector<SignalCallback> callbacks;
         callbacks.push_back(name_owner_changed_callback_);
         bus_->PostTaskToOriginThread(FROM_HERE,
                                      base::Bind(&ObjectProxy::RunMethod,
                                                 this,
                                                 start_time,
                                                 callbacks,
                                                 released_signal));
       }
     }
   }
 
   // Always return unhandled to let other object proxies handle the same
   // signal.
   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 
 }  // namespace dbus