dbus: add support for synchronous PropertySet::Get

dbus/property.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_PROPERTY_H_
 #define DBUS_PROPERTY_H_
 
 #include <map>
 #include <string>
 #include <utility>
@@ skipping 241 matching lines @@
 
   // Requests an updated value from the remote object for |property|
   // incurring a round-trip. |callback| will be called when the new
   // value is available. This may not be implemented by some interfaces,
   // and may be overriden by sub-classes if interfaces use different
   // method calls.
   virtual void Get(PropertyBase* property, GetCallback callback);
   virtual void OnGet(PropertyBase* property, GetCallback callback,
                      Response* response);
 
+  // The synchronous version of Get().

[stevenjb, 2015/09/28 20:24:54]

I assume this is for use outside of Chrome?

I would appreciate a warning that this should never be used on an interactive
thread, e.g. the chrome UI thread. (I realize that should be pretty obvious,
but... once upon a time blocking dbus calls were a huge source of jank on Chrome
OS).

[nywang, 2015/09/28 20:45:33]

Thanks.

Yes this is used outside Chrome. It is for ChromeOS network manager (shill). We
need synchronous get/set to ensure events happen in an expected order.

I will add the warning here.

+  virtual bool GetAndBlock(PropertyBase* property);
+
   // Queries the remote object for values of all properties and updates
   // initial values. Sub-classes may override to use a different D-Bus
   // method, or if the remote object does not support retrieving all
   // properties, either ignore or obtain each property value individually.
   virtual void GetAll();
   virtual void OnGetAll(Response* response);
 
   // Callback for Set() method, |success| indicates whether or not the
   // new property value was accepted by the remote object.
   typedef base::Callback<void(bool success)> SetCallback;
 
   // Requests that the remote object for |property| change the property to
   // its new value. |callback| will be called to indicate the success or
   // failure of the request, however the new value may not be available
   // depending on the remote object. This method may be overridden by
   // sub-classes if interfaces use different method calls.
   virtual void Set(PropertyBase* property, SetCallback callback);
-  // The sychronous version of Set().
-  virtual bool SetAndBlock(PropertyBase* property);
   virtual void OnSet(PropertyBase* property, SetCallback callback,
                      Response* response);
 
+  // The synchronous version of Set().

[stevenjb, 2015/09/28 20:24:54]

We should add a warning here too.

+  virtual bool SetAndBlock(PropertyBase* property);
+
   // Update properties by reading an array of dictionary entries, each
   // containing a string with the name and a variant with the value, from
   // |message_reader|. Returns false if message is in incorrect format.
   bool UpdatePropertiesFromReader(MessageReader* reader);
 
   // Updates a single property by reading a string with the name and a
   // variant with the value from |message_reader|. Returns false if message
   // is in incorrect format, or property type doesn't match.
   bool UpdatePropertyFromReader(MessageReader* reader);
 
@@ skipping 81 matching lines @@
   // Retrieves the cached value.
   const T& value() const { return value_; }
 
   // Requests an updated value from the remote object incurring a
   // round-trip. |callback| will be called when the new value is available.
   // This may not be implemented by some interfaces.
   virtual void Get(dbus::PropertySet::GetCallback callback) {
     property_set()->Get(this, callback);
   }
 
+  // The synchronous version of Get().
+  virtual bool GetAndBlock() {
+    return property_set()->GetAndBlock(this);
+  }
+
   // Requests that the remote object change the property value to |value|,
   // |callback| will be called to indicate the success or failure of the
   // request, however the new value may not be available depending on the
   // remote object.
   virtual void Set(const T& value, dbus::PropertySet::SetCallback callback) {
     set_value_ = value;
     property_set()->Set(this, callback);
   }
 
-  // The sychronous version of Set().
+  // The synchronous version of Set().
   virtual bool SetAndBlock(const T& value) {
     set_value_ = value;
     return property_set()->SetAndBlock(this);
   }
 
   // Method used by PropertySet to retrieve the value from a MessageReader,
   // no knowledge of the contained type is required, this method returns
   // true if its expected type was found, false if not.
   bool PopValueFromReader(MessageReader* reader) override;
 
@@ skipping 188 matching lines @@
 Property<std::vector<std::pair<std::vector<uint8_t>, uint16_t>>>::
     AppendSetValueToWriter(MessageWriter* writer);
 extern template class CHROME_DBUS_EXPORT
     Property<std::vector<std::pair<std::vector<uint8_t>, uint16_t>>>;
 
 #pragma GCC diagnostic pop
 
 }  // namespace dbus
 
 #endif  // DBUS_PROPERTY_H_