dbus: Make Bus::GetManagedObjects skip unavailable services.

dbus/object_manager.cc

 // Copyright (c) 2013 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/object_manager.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 19 matching lines @@
 }
 
 ObjectManager::ObjectManager(Bus* bus,
                              const std::string& service_name,
                              const ObjectPath& object_path)
     : bus_(bus),
       service_name_(service_name),
       object_path_(object_path),
       setup_success_(false),
       cleanup_called_(false),
+      service_initially_available_(false),
+      signals_are_connected_(false),
       weak_ptr_factory_(this) {
   DVLOG(1) << "Creating ObjectManager for " << service_name_
            << " " << object_path_.value();
   DCHECK(bus_);
   bus_->AssertOnOriginThread();
   object_proxy_ = bus_->GetObjectProxy(service_name_, object_path_);
+  object_proxy_->WaitForServiceToBeAvailable(
+      base::Bind(&ObjectManager::OnServiceInitiallyAvailable,
+                 weak_ptr_factory_.GetWeakPtr()));
   object_proxy_->SetNameOwnerChangedCallback(
       base::Bind(&ObjectManager::NameOwnerChanged,
                  weak_ptr_factory_.GetWeakPtr()));
 
   // Set up a match rule and a filter function to handle PropertiesChanged
   // signals from the service. This is important to avoid any race conditions
   // that might cause us to miss PropertiesChanged signals once all objects are
   // initialized via GetManagedObjects.
   base::PostTaskAndReplyWithResult(
       bus_->GetDBusTaskRunner(),
@@ skipping 104 matching lines @@
   bus_->RemoveFilterFunction(&ObjectManager::HandleMessageThunk, this);
 
   ScopedDBusError error;
   bus_->RemoveMatch(match_rule_, error.get());
   if (error.is_set())
     LOG(ERROR) << "Failed to remove match rule: " << match_rule_;
 
   match_rule_.clear();
 }
 
+void ObjectManager::OnServiceInitiallyAvailable(bool service_is_available) {
+  if (!service_is_available) {
+    LOG(WARNING) << service_name_ << " " << object_path_.value()
+                 << ": Failed to wait for service to become available";
+    return;
+  }
+
+  service_initially_available_ = true;
+  if (signals_are_connected_)
+    GetManagedObjects();
+}
+
 void ObjectManager::InitializeObjects() {
   DCHECK(bus_);
   DCHECK(object_proxy_);
   DCHECK(setup_success_);
 
   // |object_proxy_| is no longer valid if the Bus was shut down before this
   // call. Don't initiate any other action from the origin thread.
   if (cleanup_called_)
     return;
 
   object_proxy_->ConnectToSignal(
       kObjectManagerInterface,
       kObjectManagerInterfacesAdded,
       base::Bind(&ObjectManager::InterfacesAddedReceived,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&ObjectManager::InterfacesAddedConnected,
                  weak_ptr_factory_.GetWeakPtr()));
 
   object_proxy_->ConnectToSignal(
       kObjectManagerInterface,
       kObjectManagerInterfacesRemoved,
       base::Bind(&ObjectManager::InterfacesRemovedReceived,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&ObjectManager::InterfacesRemovedConnected,
                  weak_ptr_factory_.GetWeakPtr()));
 
-  GetManagedObjects();
+  signals_are_connected_ = true;
+  if (service_initially_available_)
+    GetManagedObjects();

[hashimoto, 2016/09/01 03:26:07]

How about calling WaitForServiceToBeAvailable() here instead of in the ctor so
that we don't need to manage signals_are_connected_ and
service_initially_available_?
Are SetupMatchRuleAndFilter() and WaitForServiceToBeAvailable() too slow to
perform them sequentially?

[Daniel Erat, 2016/09/01 04:15:55]

thanks, that seems like a good suggestion! and no, i'd expect that the delay
wouldn't cause any issues. i'll ping you when i've uploaded a new version.

 }
 
 bool ObjectManager::SetupMatchRuleAndFilter() {
   DCHECK(bus_);
   DCHECK(!setup_success_);
   bus_->AssertOnDBusThread();
 
   if (cleanup_called_)
     return false;
 
@@ skipping 319 matching lines @@
         RemoveInterface(object_path, *iiter);
     }
 
   }
 
   if (!new_owner.empty())
     GetManagedObjects();
 }
 
 }  // namespace dbus