D-Bus: notify properties changed from fakes

chromeos/dbus/fake_bluetooth_device_client.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 "chromeos/dbus/fake_bluetooth_device_client.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <utility>
@@ skipping 115 matching lines @@
   VLOG(1) << "GetAll";
 }
 
 void FakeBluetoothDeviceClient::Properties::Set(
     dbus::PropertyBase *property,
     dbus::PropertySet::SetCallback callback) {
   VLOG(1) << "Set " << property->name();
   if (property->name() == trusted.name()) {
     callback.Run(true);
     property->ReplaceValueWithSetValue();
-    NotifyPropertyChanged(property->name());
   } else {
     callback.Run(false);
   }
 }
 
 
 FakeBluetoothDeviceClient::FakeBluetoothDeviceClient()
     : simulation_interval_ms_(kSimulationIntervalMs),
       discovery_simulation_step_(0),
       pairing_cancelled_(false) {
@@ skipping 70 matching lines @@
   } else if (properties->paired.value() == true &&
              object_path == dbus::ObjectPath(kMicrosoftMousePath)) {
     // Must not be paired
     error_callback.Run(bluetooth_adapter::kErrorFailed,
                        "Connection fails while paired");
     return;
   }
 
   // The device can be connected.
   properties->connected.ReplaceValue(true);
+  callback.Run();
 
   AddInputDeviceIfNeeded(object_path, properties);
-
-  callback.Run();
-  properties->NotifyPropertyChanged(properties->connected.name());
 }
 
 void FakeBluetoothDeviceClient::Disconnect(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << "Disconnect: " << object_path.value();
   Properties* properties = GetProperties(object_path);
 
   if (properties->connected.value() == true) {
+    callback.Run();
     properties->connected.ReplaceValue(false);
-
-    callback.Run();
-    properties->NotifyPropertyChanged(properties->connected.name());
   } else {
     error_callback.Run("org.bluez.Error.NotConnected", "Not Connected");
   }
 }
 
 void FakeBluetoothDeviceClient::ConnectProfile(
     const dbus::ObjectPath& object_path,
     const std::string& uuid,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
@@ skipping 197 matching lines @@
           &FakeBluetoothDeviceClient::OnPropertyChanged,
           base::Unretained(this),
           dbus::ObjectPath(kAppleMousePath)));
       properties->address.ReplaceValue(kAppleMouseAddress);
       properties->bluetooth_class.ReplaceValue(kAppleMouseClass);
       properties->name.ReplaceValue("Fake Apple Magic Mouse");
       properties->alias.ReplaceValue(kAppleMouseName);
       properties->adapter.ReplaceValue(
           dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath));
 
+      std::vector<std::string> uuids;
+      uuids.push_back("00001124-0000-1000-8000-00805f9b34fb");
+      properties->uuids.ReplaceValue(uuids);
+
       properties_map_[dbus::ObjectPath(kAppleMousePath)] = properties;
       device_list_.push_back(dbus::ObjectPath(kAppleMousePath));
       FOR_EACH_OBSERVER(ExperimentalBluetoothDeviceClient::Observer, observers_,
                         DeviceAdded(dbus::ObjectPath(kAppleMousePath)));
     }
 
   } else if (discovery_simulation_step_ == 4) {
     if (std::find(device_list_.begin(), device_list_.end(),
                   dbus::ObjectPath(kAppleKeyboardPath)) == device_list_.end()) {
       Properties *properties = new Properties(base::Bind(
           &FakeBluetoothDeviceClient::OnPropertyChanged,
           base::Unretained(this),
           dbus::ObjectPath(kAppleKeyboardPath)));
       properties->address.ReplaceValue(kAppleKeyboardAddress);
       properties->bluetooth_class.ReplaceValue(kAppleKeyboardClass);
       properties->name.ReplaceValue("Fake Apple Wireless Keyboard");
       properties->alias.ReplaceValue(kAppleKeyboardName);
       properties->adapter.ReplaceValue(
           dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath));
 
+      std::vector<std::string> uuids;
+      uuids.push_back("00001124-0000-1000-8000-00805f9b34fb");
+      properties->uuids.ReplaceValue(uuids);
+
       properties_map_[dbus::ObjectPath(kAppleKeyboardPath)] = properties;
       device_list_.push_back(dbus::ObjectPath(kAppleKeyboardPath));
       FOR_EACH_OBSERVER(ExperimentalBluetoothDeviceClient::Observer, observers_,
                         DeviceAdded(dbus::ObjectPath(kAppleKeyboardPath)));
     }
 
     if (std::find(device_list_.begin(), device_list_.end(),
                   dbus::ObjectPath(kVanishingDevicePath)) ==
         device_list_.end()) {
       Properties* properties = new Properties(base::Bind(
@@ skipping 21 matching lines @@
           &FakeBluetoothDeviceClient::OnPropertyChanged,
           base::Unretained(this),
           dbus::ObjectPath(kMicrosoftMousePath)));
       properties->address.ReplaceValue(kMicrosoftMouseAddress);
       properties->bluetooth_class.ReplaceValue(kMicrosoftMouseClass);
       properties->name.ReplaceValue("Fake Microsoft Mouse");
       properties->alias.ReplaceValue(kMicrosoftMouseName);
       properties->adapter.ReplaceValue(
           dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath));
 
+      std::vector<std::string> uuids;
+      uuids.push_back("00001124-0000-1000-8000-00805f9b34fb");
+      properties->uuids.ReplaceValue(uuids);
+
       properties_map_[dbus::ObjectPath(kMicrosoftMousePath)] = properties;
       device_list_.push_back(dbus::ObjectPath(kMicrosoftMousePath));
       FOR_EACH_OBSERVER(ExperimentalBluetoothDeviceClient::Observer, observers_,
                         DeviceAdded(dbus::ObjectPath(kMicrosoftMousePath)));
     }
 
   } else if (discovery_simulation_step_ == 8) {
     if (std::find(device_list_.begin(), device_list_.end(),
                   dbus::ObjectPath(kMotorolaKeyboardPath)) ==
         device_list_.end()) {
       Properties* properties = new Properties(base::Bind(
           &FakeBluetoothDeviceClient::OnPropertyChanged,
           base::Unretained(this),
           dbus::ObjectPath(kMotorolaKeyboardPath)));
       properties->address.ReplaceValue(kMotorolaKeyboardAddress);
       properties->bluetooth_class.ReplaceValue(kMotorolaKeyboardClass);
       properties->name.ReplaceValue("Fake Motorola Keyboard");
       properties->alias.ReplaceValue(kMotorolaKeyboardName);
       properties->adapter.ReplaceValue(
           dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath));
 
+      std::vector<std::string> uuids;
+      uuids.push_back("00001124-0000-1000-8000-00805f9b34fb");
+      properties->uuids.ReplaceValue(uuids);
+
       properties_map_[dbus::ObjectPath(kMotorolaKeyboardPath)] = properties;
       device_list_.push_back(dbus::ObjectPath(kMotorolaKeyboardPath));
       FOR_EACH_OBSERVER(ExperimentalBluetoothDeviceClient::Observer, observers_,
                         DeviceAdded(dbus::ObjectPath(kMotorolaKeyboardPath)));
     }
 
     if (std::find(device_list_.begin(), device_list_.end(),
                   dbus::ObjectPath(kSonyHeadphonesPath)) ==
         device_list_.end()) {
       Properties* properties = new Properties(base::Bind(
@@ skipping 77 matching lines @@
   VLOG(1) << "CompleteSimulatedPairing: " << object_path.value();
   if (pairing_cancelled_) {
     pairing_cancelled_ = false;
 
     error_callback.Run(bluetooth_adapter::kErrorAuthenticationCanceled,
                        "Cancaled");
   } else {
     Properties* properties = GetProperties(object_path);
 
     properties->paired.ReplaceValue(true);
+    callback.Run();
 
     AddInputDeviceIfNeeded(object_path, properties);
-
-    callback.Run();
-    properties->NotifyPropertyChanged(properties->paired.name());
   }
 }
 
 void FakeBluetoothDeviceClient::TimeoutSimulatedPairing(
     const dbus::ObjectPath& object_path,
     const ErrorCallback& error_callback) {
   VLOG(1) << "TimeoutSimulatedPairing: " << object_path.value();
 
   error_callback.Run(bluetooth_adapter::kErrorAuthenticationTimeout,
                      "Timed out");
@@ skipping 19 matching lines @@
 
 void FakeBluetoothDeviceClient::AddInputDeviceIfNeeded(
     const dbus::ObjectPath& object_path,
     Properties* properties) {
   // If the paired device is a HID device based on it's bluetooth class,
   // simulate the Input interface.
   FakeBluetoothInputClient* fake_bluetooth_input_client =
       static_cast<FakeBluetoothInputClient*>(
           DBusThreadManager::Get()->GetExperimentalBluetoothInputClient());
 
-  if ((properties->bluetooth_class.value() & 0x001f03) == 0x000500) {
-    std::vector<std::string> uuids = properties->uuids.value();
-    if (std::find(uuids.begin(), uuids.end(),
-        "00001124-0000-1000-8000-00805f9b34fb") == uuids.end()) {
-      uuids.push_back("00001124-0000-1000-8000-00805f9b34fb");
-      properties->uuids.ReplaceValue(uuids);
-      fake_bluetooth_input_client->AddInputDevice(object_path);
-    }
-  }
+  if ((properties->bluetooth_class.value() & 0x001f03) == 0x000500)
+    fake_bluetooth_input_client->AddInputDevice(object_path);
 }
 
 void FakeBluetoothDeviceClient::PinCodeCallback(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback,
     ExperimentalBluetoothAgentServiceProvider::Delegate::Status status,
     const std::string& pincode) {
   VLOG(1) << "PinCodeCallback: " << object_path.value();
 
@@ skipping 127 matching lines @@
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
                    base::Unretained(this),
                    object_path, callback, error_callback),
         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 
   }
 }
 
 }  // namespace chromeos