Implement device::BatteryStatus support for UPower daemon 0.99.x

device/battery/battery_status_manager_linux_unittest.cc

Index: device/battery/battery_status_manager_linux_unittest.cc
diff --git a/device/battery/battery_status_manager_linux_unittest.cc b/device/battery/battery_status_manager_linux_unittest.cc
index d1b882e03c1130c5f68710c81740d02c4f2cbd2f..71e4360f0d99ad583edc4a56373d78996bb45f47 100644
--- a/device/battery/battery_status_manager_linux_unittest.cc
+++ b/device/battery/battery_status_manager_linux_unittest.cc
@@ -4,17 +4,555 @@
 
 #include "device/battery/battery_status_manager_linux.h"
 
-#include "base/values.h"
+#include <limits>
+#include <list>
+#include <string>
+
+#include "base/bind.h"
+#include "base/single_thread_task_runner.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/threading/thread.h"
+#include "dbus/mock_bus.h"
+#include "dbus/mock_object_proxy.h"
+#include "dbus/object_path.h"
+#include "dbus/property.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using testing::_;
+using testing::Invoke;
+using testing::NiceMock;
+using testing::Return;
+using testing::Unused;
+
 namespace device {
 
 namespace {
+const char kUPowerInterfaceName[] = "org.freedesktop.UPower";

[timvolodine, 2016/06/16 16:12:24]

A number of constants here duplicate similar constants in the
battery_status_manager_linux.cc file. Any way we could avoid these duplicates?

[markuso, 2016/06/17 08:45:19]

I could move them to the battery_status_manager_linux.h file.

[markuso, 2016/06/17 10:01:17]

Done.

+const char kUPowerMethodEnumerateDevices[] = "EnumerateDevices";
+const char kUPowerMethodGetDisplayDevice[] = "GetDisplayDevice";
+const char kUPowerPath[] = "/org/freedesktop/UPower";
+const char kUPowerPropertyDaemonVersion[] = "DaemonVersion";
+const char kUPowerServiceName[] = "org.freedesktop.UPower";
+const char kUPowerSignalDeviceAdded[] = "DeviceAdded";
+const char kUPowerSignalDeviceRemoved[] = "DeviceRemoved";
+
+const char kUPowerDeviceInterfaceName[] = "org.freedesktop.UPower.Device";
+const char kUPowerDevicePropertyIsPresent[] = "IsPresent";
+const char kUPowerDevicePropertyPercentage[] = "Percentage";
+const char kUPowerDevicePropertyState[] = "State";
+const char kUPowerDevicePropertyTimeToEmpty[] = "TimeToEmpty";
+const char kUPowerDevicePropertyTimeToFull[] = "TimeToFull";
+const char kUPowerDevicePropertyType[] = "Type";
+const char kUPowerDeviceSignalChanged[] = "Changed";
+const char kUPowerDeviceACLinePath[] =
+    "/org/freedesktop/UPower/devices/line_power_AC";
+const char kUPowerDeviceBattery0Path[] =
+    "/org/freedesktop/UPower/devices/battery_BAT0";
+const char kUPowerDeviceBattery1Path[] =
+    "/org/freedesktop/UPower/devices/battery_BAT1";
+const char kUPowerDisplayDevicePath[] =
+    "/org/freedesktop/UPower/devices/DisplayDevice";
+
+class MockUPowerObject {
+ public:
+  MockUPowerObject() {}
+  void ConnectToSignal(
+      const std::string& interface_name,
+      const std::string& signal_name,
+      dbus::ObjectProxy::SignalCallback signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback);
+  dbus::Response* CreateCallMethodResponse(dbus::MethodCall* method_call,
+                                           Unused);
+  void SignalDeviceAdded(const std::string& added_device_path);
+  void SignalDeviceRemoved(const std::string& removed_device_path);
+
+  scoped_refptr<dbus::MockObjectProxy> proxy;
+  dbus::ObjectProxy::SignalCallback signal_callback_device_added;
+  dbus::ObjectProxy::SignalCallback signal_callback_device_removed;
+  std::string daemon_version;
+  std::list<std::string> devices;
+  std::string display_device;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockUPowerObject);
+};
+
+void MockUPowerObject::ConnectToSignal(
+    const std::string& interface_name,
+    const std::string& signal_name,
+    dbus::ObjectProxy::SignalCallback signal_callback,
+    dbus::ObjectProxy::OnConnectedCallback on_connected_callback) {
+  bool on_connected_success = true;
+  if (interface_name == kUPowerInterfaceName) {
+    if (signal_name == kUPowerSignalDeviceAdded)
+      signal_callback_device_added = signal_callback;
+    else if (signal_name == kUPowerSignalDeviceRemoved)
+      signal_callback_device_removed = signal_callback;
+    else
+      on_connected_success = false;
+  } else {
+    on_connected_success = false;
+  }
+
+  if (!on_connected_success) {
+    LOG(WARNING) << "MockUPowerObject::" << __FUNCTION__
+                 << " Unexpected interface=" << interface_name
+                 << ", signal=" << signal_name;
+  }
+  on_connected_callback.Run(interface_name, signal_name, on_connected_success);
+}
+
+dbus::Response* MockUPowerObject::CreateCallMethodResponse(
+    dbus::MethodCall* method_call,
+    Unused) {
+  if (method_call->GetInterface() == kUPowerInterfaceName) {
+    if (method_call->GetMember() == kUPowerMethodEnumerateDevices) {
+      std::unique_ptr<dbus::Response> response = dbus::Response::CreateEmpty();
+      dbus::MessageWriter writer(response.get());
+      dbus::MessageWriter array_writer(nullptr);
+      writer.OpenArray("o", &array_writer);
+      for (const auto& device : devices)
+        array_writer.AppendObjectPath(dbus::ObjectPath(device));
+      writer.CloseContainer(&array_writer);
+      return response.release();
+    } else if (method_call->GetMember() == kUPowerMethodGetDisplayDevice) {
+      std::unique_ptr<dbus::Response> response = dbus::Response::CreateEmpty();
+      if (!display_device.empty()) {
+        dbus::MessageWriter writer(response.get());
+        writer.AppendObjectPath(dbus::ObjectPath(display_device));
+      }
+      return response.release();
+    }
+  } else if (method_call->GetInterface() == dbus::kPropertiesInterface) {
+    std::unique_ptr<dbus::Response> response = dbus::Response::CreateEmpty();
+    dbus::MessageWriter writer(response.get());
+    if (method_call->GetMember() == dbus::kPropertiesGet) {
+      dbus::MessageReader reader(method_call);
+      std::string interface_name;
+      std::string property_name;
+      if (reader.PopString(&interface_name) &&
+          reader.PopString(&property_name) &&
+          property_name == kUPowerPropertyDaemonVersion) {
+        writer.AppendVariantOfString(daemon_version);
+        return response.release();
+      }
+    } else if (method_call->GetMember() == dbus::kPropertiesGetAll) {
+      dbus::MessageWriter array_writer(nullptr);
+      dbus::MessageWriter dict_entry_writer(nullptr);
+      writer.OpenArray("{sv}", &array_writer);
+      array_writer.OpenDictEntry(&dict_entry_writer);
+      dict_entry_writer.AppendString(kUPowerPropertyDaemonVersion);
+      dict_entry_writer.AppendVariantOfString(daemon_version);
+      array_writer.CloseContainer(&dict_entry_writer);
+      writer.CloseContainer(&array_writer);
+      return response.release();
+    }
+  }
+
+  LOG(ERROR) << "Unexpected method call: " << method_call->ToString();

[timvolodine, 2016/06/16 16:12:24]

should this be a FAIL() <<.. ?

[markuso, 2016/06/17 08:45:19]

I followed the guide of the Google Mock CookBook
(https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md)
which suggest to use NiceMock and not fail if you encounter an unknown method
call. So here I only print a warning that something unexpected happens.

+  return nullptr;
+}
+
+void MockUPowerObject::SignalDeviceAdded(const std::string& added_device_path) {
+  dbus::Signal signal(kUPowerInterfaceName, kUPowerSignalDeviceAdded);
+  signal.SetPath(proxy->object_path());
+  dbus::MessageWriter writer(&signal);
+  writer.AppendObjectPath(dbus::ObjectPath(added_device_path));
+  signal_callback_device_added.Run(&signal);
+}
+
+void MockUPowerObject::SignalDeviceRemoved(
+    const std::string& removed_device_path) {
+  dbus::Signal signal(kUPowerInterfaceName, kUPowerSignalDeviceRemoved);
+  signal.SetPath(proxy->object_path());
+  dbus::MessageWriter writer(&signal);
+  writer.AppendObjectPath(dbus::ObjectPath(removed_device_path));
+  signal_callback_device_removed.Run(&signal);
+}
+
+struct MockBatteryProperties {
+  bool is_present = true;
+  double percentage = 100;
+  uint32_t state = UPowerDeviceState::UPOWER_DEVICE_STATE_UNKNOWN;
+  int64_t time_to_empty = 0;
+  int64_t time_to_full = 0;
+  uint32_t type = UPowerDeviceType::UPOWER_DEVICE_TYPE_BATTERY;
+};
+
+class MockBatteryObject {
+ public:
+  MockBatteryObject(dbus::Bus* bus,
+                    const std::string& object_path,
+                    MockBatteryProperties* properties);
+  void ConnectToSignal(
+      const std::string& interface_name,
+      const std::string& signal_name,
+      dbus::ObjectProxy::SignalCallback signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback);
+  dbus::Response* CreateCallMethodResponse(dbus::MethodCall* method_call,
+                                           Unused);
+  MockBatteryObject& ExpectConnectToSignalChanged();
+  MockBatteryObject& ExpectConnectToSignalPropertyChanged();
+  void SignalChanged();
+  void SignalPropertyChanged(const std::string& property_name);
+
+  scoped_refptr<dbus::MockObjectProxy> proxy;
+  MockBatteryProperties* properties;
+  dbus::ObjectProxy::SignalCallback signal_callback_changed;
+  dbus::ObjectProxy::SignalCallback signal_callback_properties_changed;
+
+ private:
+  void AppendPropertyToWriter(dbus::MessageWriter* writer,
+                              const std::string& property_name);
+  void AppendAllPropertiesToWriter(dbus::MessageWriter* writer);
+
+  DISALLOW_COPY_AND_ASSIGN(MockBatteryObject);
+};
+
+MockBatteryObject::MockBatteryObject(dbus::Bus* bus,
+                                     const std::string& object_path,
+                                     MockBatteryProperties* properties)
+    : proxy(new NiceMock<dbus::MockObjectProxy>(bus,
+                                                kUPowerServiceName,
+                                                dbus::ObjectPath(object_path))),
+      properties(properties) {}
+
+void MockBatteryObject::ConnectToSignal(
+    const std::string& interface_name,
+    const std::string& signal_name,
+    dbus::ObjectProxy::SignalCallback signal_callback,
+    dbus::ObjectProxy::OnConnectedCallback on_connected_callback) {
+  bool on_connected_success = true;
+  if (interface_name == kUPowerDeviceInterfaceName &&
+      signal_name == kUPowerDeviceSignalChanged)
+    signal_callback_changed = signal_callback;
+  else if (interface_name == dbus::kPropertiesInterface &&
+           signal_name == dbus::kPropertiesChanged)
+    signal_callback_properties_changed = signal_callback;
+  else
+    on_connected_success = false;
+
+  if (!on_connected_success) {
+    LOG(WARNING) << "MockBatteryObject::" << __FUNCTION__
+                 << " Unexpected interface=" << interface_name
+                 << ", signal=" << signal_name;
+  }
+  on_connected_callback.Run(interface_name, signal_name, on_connected_success);
+}
+
+dbus::Response* MockBatteryObject::CreateCallMethodResponse(
+    dbus::MethodCall* method_call,
+    Unused) {
+  if (method_call->GetInterface() == dbus::kPropertiesInterface) {
+    if (method_call->GetMember() == dbus::kPropertiesGet) {
+      if (!properties)
+        return nullptr;
+
+      dbus::MessageReader reader(method_call);
+      std::string interface_name;
+      std::string property_name;
+      if (reader.PopString(&interface_name) &&
+          reader.PopString(&property_name)) {
+        std::unique_ptr<dbus::Response> response =
+            dbus::Response::CreateEmpty();
+        dbus::MessageWriter writer(response.get());
+        AppendPropertyToWriter(&writer, property_name);
+        return response.release();
+      }
+    } else if (method_call->GetMember() == dbus::kPropertiesGetAll) {
+      if (!properties)
+        return nullptr;
+
+      std::unique_ptr<dbus::Response> response = dbus::Response::CreateEmpty();
+      dbus::MessageWriter writer(response.get());
+      AppendAllPropertiesToWriter(&writer);
+      return response.release();
+    }
+  }
+  LOG(ERROR) << "Unexpected method call: " << method_call->ToString();

[timvolodine, 2016/06/16 16:12:24]

same question here

[markuso, 2016/06/17 08:45:19]

Same answer

+  return nullptr;
+}
+
+MockBatteryObject& MockBatteryObject::ExpectConnectToSignalChanged() {
+  EXPECT_CALL(*proxy.get(), ConnectToSignal(kUPowerDeviceInterfaceName,
+                                            kUPowerDeviceSignalChanged, _, _))
+      .WillOnce(Invoke(this, &MockBatteryObject::ConnectToSignal));
+  return *this;
+}
+
+MockBatteryObject& MockBatteryObject::ExpectConnectToSignalPropertyChanged() {
+  EXPECT_CALL(*proxy.get(), ConnectToSignal(dbus::kPropertiesInterface,
+                                            dbus::kPropertiesChanged, _, _))
+      .WillOnce(Invoke(this, &MockBatteryObject::ConnectToSignal));
+  return *this;
+}
+
+void MockBatteryObject::SignalChanged() {
+  dbus::Signal signal(kUPowerInterfaceName, kUPowerDeviceSignalChanged);
+  signal.SetPath(proxy->object_path());
+  dbus::MessageWriter writer(&signal);
+  writer.AppendString(kUPowerDeviceInterfaceName);
+  signal_callback_changed.Run(&signal);
+}
+
+void MockBatteryObject::SignalPropertyChanged(
+    const std::string& property_name) {
+  dbus::Signal signal(dbus::kPropertiesInterface, dbus::kPropertiesChanged);
+  signal.SetPath(proxy->object_path());
+  dbus::MessageWriter writer(&signal);
+  writer.AppendString(kUPowerDeviceInterfaceName);
+
+  // Dictionary {sv} of property-name => new value:
+  dbus::MessageWriter array_writer(nullptr);
+  writer.OpenArray("{sv}", &array_writer);
+  writer.CloseContainer(&array_writer);
+
+  // Array of invalidated properties:
+  writer.OpenArray("s", &array_writer);
+  array_writer.AppendString(property_name);
+  writer.CloseContainer(&array_writer);
+
+  signal_callback_properties_changed.Run(&signal);
+}
+
+void MockBatteryObject::AppendPropertyToWriter(
+    dbus::MessageWriter* writer,
+    const std::string& property_name) {
+  if (property_name == kUPowerDevicePropertyIsPresent)
+    writer->AppendVariantOfBool(properties->is_present);
+  else if (property_name == kUPowerDevicePropertyPercentage)
+    writer->AppendVariantOfDouble(properties->percentage);
+  else if (property_name == kUPowerDevicePropertyState)
+    writer->AppendVariantOfUint32(properties->state);
+  else if (property_name == kUPowerDevicePropertyTimeToEmpty)
+    writer->AppendVariantOfInt64(properties->time_to_empty);
+  else if (property_name == kUPowerDevicePropertyTimeToFull)
+    writer->AppendVariantOfInt64(properties->time_to_full);
+  else if (property_name == kUPowerDevicePropertyType)
+    writer->AppendVariantOfUint32(properties->type);
+  else
+    LOG(WARNING) << __FUNCTION__ << " unknown property: " << property_name;
+}
+
+void MockBatteryObject::AppendAllPropertiesToWriter(
+    dbus::MessageWriter* writer) {
+  dbus::MessageWriter array_writer(nullptr);
+  dbus::MessageWriter dict_entry_writer(nullptr);
+  writer->OpenArray("{sv}", &array_writer);
+  for (auto property_name :
+       {kUPowerDevicePropertyIsPresent, kUPowerDevicePropertyState,
+        kUPowerDevicePropertyTimeToEmpty, kUPowerDevicePropertyTimeToFull,
+        kUPowerDevicePropertyType}) {
+    array_writer.OpenDictEntry(&dict_entry_writer);
+    dict_entry_writer.AppendString(property_name);
+    AppendPropertyToWriter(&dict_entry_writer, property_name);
+    array_writer.CloseContainer(&dict_entry_writer);
+  }
+  writer->CloseContainer(&array_writer);
+}
+
+}  // namespace
+
+class BatteryStatusManagerLinuxTest : public testing::Test {
+ public:
+  BatteryStatusManagerLinuxTest() {}
+  void SetUp() override;
+
+  MockBatteryObject& SetUpDisplayDeviceProxy(MockBatteryProperties* properties);
+  void AddDevicePath(const std::string& object_path);
+  void PushFrontDevicePath(const std::string& object_path);
+  MockBatteryObject& AddDeviceProxy(const std::string& object_path,
+                                    MockBatteryProperties* properties);
+  MockBatteryObject& PushFrontDeviceProxy(const std::string& object_path,
+                                          MockBatteryProperties* properties);
+  void ExpectGetObjectProxy(const std::string& object_path,
+                            MockBatteryObject* mock_object);
+  void ExpectGetObjectProxy(const std::string& object_path,
+                            dbus::ObjectProxy* object_proxy);
+
+  void DeviceSignalChanged(MockBatteryObject* device);
+  void DeviceSignalPropertyChanged(MockBatteryObject* device,
+                                   const std::string& property_name);
+
+  void UPowerSignalDeviceAdded(const std::string& device_path);
+  void UPowerSignalDeviceRemoved(const std::string& device_path);
+
+  void StartBatteryStatusManagerLinux();
+
+  int count_battery_updates() const { return count_battery_updates_; }
+  const BatteryStatus& last_battery_status() const { return last_status_; }
+
+ protected:
+  scoped_refptr<dbus::MockBus> mock_bus_;
+  MockUPowerObject mock_upower_;
+  std::unique_ptr<MockBatteryObject> mock_display_device_;
+  std::list<std::unique_ptr<MockBatteryObject>> mock_battery_devices_;
+
+ private:
+  std::unique_ptr<MockBatteryObject> CreateMockBatteryObject(
+      const std::string& object_path,
+      MockBatteryProperties* properties);
+  void BatteryUpdateCallback(const BatteryStatus& status);
+  void SyncWithNotifierThread();
+
+  std::unique_ptr<BatteryStatusManagerLinux> manager_;
+  int count_battery_updates_ = 0;
+  BatteryStatus last_status_;
+
+  DISALLOW_COPY_AND_ASSIGN(BatteryStatusManagerLinuxTest);
+};
+
+void BatteryStatusManagerLinuxTest::SetUp() {
+  dbus::Bus::Options options;
+  options.bus_type = dbus::Bus::SYSTEM;
+  options.connection_type = dbus::Bus::PRIVATE;
+  mock_bus_ = new NiceMock<dbus::MockBus>(options);
+
+  mock_upower_.proxy = new NiceMock<dbus::MockObjectProxy>(
+      mock_bus_.get(), kUPowerServiceName, dbus::ObjectPath(kUPowerPath));
+  ExpectGetObjectProxy(kUPowerPath, mock_upower_.proxy.get());
+  EXPECT_CALL(*mock_upower_.proxy.get(), MockCallMethodAndBlock(_, _))
+      .WillRepeatedly(
+          Invoke(&mock_upower_, &MockUPowerObject::CreateCallMethodResponse));
+  EXPECT_CALL(
+      *mock_upower_.proxy.get(),
+      ConnectToSignal(kUPowerInterfaceName, kUPowerSignalDeviceAdded, _, _))
+      .WillOnce(Invoke(&mock_upower_, &MockUPowerObject::ConnectToSignal));
+  EXPECT_CALL(
+      *mock_upower_.proxy.get(),
+      ConnectToSignal(kUPowerInterfaceName, kUPowerSignalDeviceRemoved, _, _))
+      .WillOnce(Invoke(&mock_upower_, &MockUPowerObject::ConnectToSignal));
+}
+
+MockBatteryObject& BatteryStatusManagerLinuxTest::SetUpDisplayDeviceProxy(
+    MockBatteryProperties* properties) {
+  mock_upower_.display_device = kUPowerDisplayDevicePath;
+  mock_display_device_ =
+      CreateMockBatteryObject(mock_upower_.display_device, properties);
+  return *mock_display_device_.get();
+}
+
+void BatteryStatusManagerLinuxTest::AddDevicePath(
+    const std::string& object_path) {
+  mock_upower_.devices.push_back(object_path);
+}
+
+void BatteryStatusManagerLinuxTest::PushFrontDevicePath(
+    const std::string& object_path) {
+  mock_upower_.devices.push_front(object_path);
+}
+
+MockBatteryObject& BatteryStatusManagerLinuxTest::AddDeviceProxy(
+    const std::string& object_path,
+    MockBatteryProperties* properties) {
+  AddDevicePath(object_path);
+  mock_battery_devices_.push_back(
+      CreateMockBatteryObject(object_path, properties));
+  return *mock_battery_devices_.back().get();
+}
+
+MockBatteryObject& BatteryStatusManagerLinuxTest::PushFrontDeviceProxy(
+    const std::string& object_path,
+    MockBatteryProperties* properties) {
+  PushFrontDevicePath(object_path);
+  mock_battery_devices_.push_front(
+      CreateMockBatteryObject(object_path, properties));
+  return *mock_battery_devices_.front().get();
+}
+
+void BatteryStatusManagerLinuxTest::ExpectGetObjectProxy(
+    const std::string& object_path,
+    MockBatteryObject* mock_object) {
+  ExpectGetObjectProxy(object_path, mock_object->proxy.get());
+}
+
+void BatteryStatusManagerLinuxTest::ExpectGetObjectProxy(
+    const std::string& object_path,
+    dbus::ObjectProxy* object_proxy) {
+  EXPECT_CALL(*mock_bus_.get(),
+              GetObjectProxy(kUPowerServiceName, dbus::ObjectPath(object_path)))
+      .WillOnce(Return(object_proxy));
+}
+
+void BatteryStatusManagerLinuxTest::DeviceSignalChanged(
+    MockBatteryObject* device) {
+  manager_->GetNotifierThreadForTesting()->task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&MockBatteryObject::SignalChanged, base::Unretained(device)));
+  SyncWithNotifierThread();
+}
+
+void BatteryStatusManagerLinuxTest::DeviceSignalPropertyChanged(
+    MockBatteryObject* device,
+    const std::string& property_name) {
+  manager_->GetNotifierThreadForTesting()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&MockBatteryObject::SignalPropertyChanged,
+                            base::Unretained(device), property_name));
+  SyncWithNotifierThread();
+}
+
+void BatteryStatusManagerLinuxTest::UPowerSignalDeviceAdded(
+    const std::string& device_path) {
+  ASSERT_FALSE(mock_upower_.signal_callback_device_added.is_null());
+  manager_->GetNotifierThreadForTesting()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&MockUPowerObject::SignalDeviceAdded,
+                            base::Unretained(&mock_upower_), device_path));
+  SyncWithNotifierThread();
+}
+
+void BatteryStatusManagerLinuxTest::UPowerSignalDeviceRemoved(
+    const std::string& device_path) {
+  ASSERT_FALSE(mock_upower_.signal_callback_device_removed.is_null());
+  manager_->GetNotifierThreadForTesting()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&MockUPowerObject::SignalDeviceRemoved,
+                            base::Unretained(&mock_upower_), device_path));
+  SyncWithNotifierThread();
+}
+
+void BatteryStatusManagerLinuxTest::StartBatteryStatusManagerLinux() {
+  manager_ = BatteryStatusManagerLinux::CreateForTesting(
+      base::Bind(&BatteryStatusManagerLinuxTest::BatteryUpdateCallback,
+                 base::Unretained(this)),
+      mock_bus_.get());
+  manager_->StartListeningBatteryChange();
+  SyncWithNotifierThread();
+}
 
-TEST(BatteryStatusManagerLinuxTest, EmptyDictionary) {
-  base::DictionaryValue dictionary;
+std::unique_ptr<MockBatteryObject>
+BatteryStatusManagerLinuxTest::CreateMockBatteryObject(
+    const std::string& object_path,
+    MockBatteryProperties* properties) {
+  std::unique_ptr<MockBatteryObject> mock_object(
+      new MockBatteryObject(mock_bus_.get(), object_path, properties));
+  ExpectGetObjectProxy(object_path, mock_object.get());
+  EXPECT_CALL(*mock_object->proxy.get(), MockCallMethodAndBlock(_, _))
+      .WillRepeatedly(Invoke(mock_object.get(),
+                             &MockBatteryObject::CreateCallMethodResponse));
+  return mock_object;
+}
+
+void BatteryStatusManagerLinuxTest::BatteryUpdateCallback(
+    const BatteryStatus& status) {
+  ++count_battery_updates_;
+  last_status_ = status;
+}
+
+void BatteryStatusManagerLinuxTest::SyncWithNotifierThread() {
+  ASSERT_TRUE(manager_ != nullptr);
+  base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
+                            base::WaitableEvent::InitialState::NOT_SIGNALED);
+  manager_->GetNotifierThreadForTesting()->task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&base::WaitableEvent::Signal, base::Unretained(&event)));
+  event.Wait();
+}
+
+TEST_F(BatteryStatusManagerLinuxTest, NoBattery) {
   BatteryStatus default_status;
-  BatteryStatus status = ComputeWebBatteryStatus(dictionary);
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
 
   EXPECT_EQ(default_status.charging, status.charging);
   EXPECT_EQ(default_status.charging_time, status.charging_time);
@@ -22,13 +560,18 @@ TEST(BatteryStatusManagerLinuxTest, EmptyDictionary) {
   EXPECT_EQ(default_status.level, status.level);
 }
 
-TEST(BatteryStatusManagerLinuxTest, ChargingHalfFull) {
-  base::DictionaryValue dictionary;
-  dictionary.SetDouble("State", UPOWER_DEVICE_STATE_CHARGING);
-  dictionary.SetDouble("TimeToFull", 0);
-  dictionary.SetDouble("Percentage", 50);
+TEST_F(BatteryStatusManagerLinuxTest, ChargingHalfFull) {
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING;
+  battery_bat0_properties.time_to_full = 0;
+  battery_bat0_properties.percentage = 50;
+  AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+      .ExpectConnectToSignalPropertyChanged();
 
-  BatteryStatus status = ComputeWebBatteryStatus(dictionary);
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
 
   EXPECT_TRUE(status.charging);
   EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
@@ -36,13 +579,18 @@ TEST(BatteryStatusManagerLinuxTest, ChargingHalfFull) {
   EXPECT_EQ(0.5, status.level);
 }
 
-TEST(BatteryStatusManagerLinuxTest, ChargingTimeToFull) {
-  base::DictionaryValue dictionary;
-  dictionary.SetDouble("State", UPOWER_DEVICE_STATE_CHARGING);
-  dictionary.SetDouble("TimeToFull", 100.f);
-  dictionary.SetDouble("Percentage", 1);
+TEST_F(BatteryStatusManagerLinuxTest, ChargingTimeToFull) {
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING;
+  battery_bat0_properties.time_to_full = 100;
+  battery_bat0_properties.percentage = 1;
+  AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+      .ExpectConnectToSignalPropertyChanged();
 
-  BatteryStatus status = ComputeWebBatteryStatus(dictionary);
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
 
   EXPECT_TRUE(status.charging);
   EXPECT_EQ(100, status.charging_time);
@@ -50,14 +598,18 @@ TEST(BatteryStatusManagerLinuxTest, ChargingTimeToFull) {
   EXPECT_EQ(.01, status.level);
 }
 
-TEST(BatteryStatusManagerLinuxTest, FullyCharged) {
-  base::DictionaryValue dictionary;
-  dictionary.SetDouble("State", UPOWER_DEVICE_STATE_FULL);
-  dictionary.SetDouble("TimeToFull", 100);
-  dictionary.SetDouble("TimeToEmpty", 200);
-  dictionary.SetDouble("Percentage", 100);
+TEST_F(BatteryStatusManagerLinuxTest, FullyCharged) {
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state = UPowerDeviceState::UPOWER_DEVICE_STATE_FULL;
+  battery_bat0_properties.time_to_full = 100;
+  battery_bat0_properties.time_to_empty = 200;
+  battery_bat0_properties.percentage = 100;
+  AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+      .ExpectConnectToSignalPropertyChanged();
 
-  BatteryStatus status = ComputeWebBatteryStatus(dictionary);
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
 
   EXPECT_TRUE(status.charging);
   EXPECT_EQ(0, status.charging_time);
@@ -65,14 +617,19 @@ TEST(BatteryStatusManagerLinuxTest, FullyCharged) {
   EXPECT_EQ(1, status.level);
 }
 
-TEST(BatteryStatusManagerLinuxTest, Discharging) {
-  base::DictionaryValue dictionary;
-  dictionary.SetDouble("State", UPOWER_DEVICE_STATE_DISCHARGING);
-  dictionary.SetDouble("TimeToFull", 0);
-  dictionary.SetDouble("TimeToEmpty", 200);
-  dictionary.SetDouble("Percentage", 90);
+TEST_F(BatteryStatusManagerLinuxTest, Discharging) {
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  battery_bat0_properties.time_to_full = 0;
+  battery_bat0_properties.time_to_empty = 200;
+  battery_bat0_properties.percentage = 90;
+  AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+      .ExpectConnectToSignalPropertyChanged();
 
-  BatteryStatus status = ComputeWebBatteryStatus(dictionary);
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
 
   EXPECT_FALSE(status.charging);
   EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
@@ -80,14 +637,19 @@ TEST(BatteryStatusManagerLinuxTest, Discharging) {
   EXPECT_EQ(.9, status.level);
 }
 
-TEST(BatteryStatusManagerLinuxTest, DischargingTimeToEmptyUnknown) {
-  base::DictionaryValue dictionary;
-  dictionary.SetDouble("State", UPOWER_DEVICE_STATE_DISCHARGING);
-  dictionary.SetDouble("TimeToFull", 0);
-  dictionary.SetDouble("TimeToEmpty", 0);
-  dictionary.SetDouble("Percentage", 90);
+TEST_F(BatteryStatusManagerLinuxTest, DischargingTimeToEmptyUnknown) {
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  battery_bat0_properties.time_to_full = 0;
+  battery_bat0_properties.time_to_empty = 0;
+  battery_bat0_properties.percentage = 90;
+  AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+      .ExpectConnectToSignalPropertyChanged();
 
-  BatteryStatus status = ComputeWebBatteryStatus(dictionary);
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
 
   EXPECT_FALSE(status.charging);
   EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
@@ -95,14 +657,19 @@ TEST(BatteryStatusManagerLinuxTest, DischargingTimeToEmptyUnknown) {
   EXPECT_EQ(.9, status.level);
 }
 
-TEST(BatteryStatusManagerLinuxTest, DeviceStateUnknown) {
-  base::DictionaryValue dictionary;
-  dictionary.SetDouble("State", UPOWER_DEVICE_STATE_UNKNOWN);
-  dictionary.SetDouble("TimeToFull", 0);
-  dictionary.SetDouble("TimeToEmpty", 0);
-  dictionary.SetDouble("Percentage", 50);
+TEST_F(BatteryStatusManagerLinuxTest, DeviceStateUnknown) {
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_UNKNOWN;
+  battery_bat0_properties.time_to_full = 0;
+  battery_bat0_properties.time_to_empty = 0;
+  battery_bat0_properties.percentage = 50;
+  AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+      .ExpectConnectToSignalPropertyChanged();
 
-  BatteryStatus status = ComputeWebBatteryStatus(dictionary);
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
 
   EXPECT_TRUE(status.charging);
   EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
@@ -110,14 +677,18 @@ TEST(BatteryStatusManagerLinuxTest, DeviceStateUnknown) {
   EXPECT_EQ(.5, status.level);
 }
 
-TEST(BatteryStatusManagerLinuxTest, DeviceStateEmpty) {
-  base::DictionaryValue dictionary;
-  dictionary.SetDouble("State", UPOWER_DEVICE_STATE_EMPTY);
-  dictionary.SetDouble("TimeToFull", 0);
-  dictionary.SetDouble("TimeToEmpty", 0);
-  dictionary.SetDouble("Percentage", 0);
+TEST_F(BatteryStatusManagerLinuxTest, DeviceStateEmpty) {
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state = UPowerDeviceState::UPOWER_DEVICE_STATE_EMPTY;
+  battery_bat0_properties.time_to_full = 0;
+  battery_bat0_properties.time_to_empty = 0;
+  battery_bat0_properties.percentage = 0;
+  AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+      .ExpectConnectToSignalPropertyChanged();
 
-  BatteryStatus status = ComputeWebBatteryStatus(dictionary);
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
 
   EXPECT_FALSE(status.charging);
   EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
@@ -125,12 +696,17 @@ TEST(BatteryStatusManagerLinuxTest, DeviceStateEmpty) {
   EXPECT_EQ(0, status.level);
 }
 
-TEST(BatteryStatusManagerLinuxTest, LevelRoundedToThreeSignificantDigits) {
-  base::DictionaryValue dictionary;
-  dictionary.SetDouble("State", UPOWER_DEVICE_STATE_DISCHARGING);
-  dictionary.SetDouble("Percentage", 14.56);
+TEST_F(BatteryStatusManagerLinuxTest, LevelRoundedToThreeSignificantDigits) {
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  battery_bat0_properties.percentage = 14.56;
+  AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+      .ExpectConnectToSignalPropertyChanged();
 
-  BatteryStatus status = ComputeWebBatteryStatus(dictionary);
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
 
   EXPECT_FALSE(status.charging);
   EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
@@ -138,6 +714,521 @@ TEST(BatteryStatusManagerLinuxTest, LevelRoundedToThreeSignificantDigits) {
   EXPECT_EQ(0.15, status.level);
 }
 
-}  // namespace
+TEST_F(BatteryStatusManagerLinuxTest, UsingFirstBatteryDevice) {
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  battery_bat0_properties.time_to_full = 0;
+  battery_bat0_properties.time_to_empty = 200;
+  battery_bat0_properties.percentage = 70;
+  AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+      .ExpectConnectToSignalPropertyChanged();
+
+  MockBatteryProperties battery_bat1_properties;
+  battery_bat1_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING;
+  battery_bat1_properties.time_to_full = 100;
+  battery_bat1_properties.time_to_empty = 0;
+  battery_bat1_properties.percentage = 80;
+  AddDeviceProxy(kUPowerDeviceBattery1Path, &battery_bat1_properties);
+
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
+
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(200, status.discharging_time);
+  EXPECT_EQ(0.7, status.level);
+}
+
+TEST_F(BatteryStatusManagerLinuxTest, SkipNonBatteryDevice) {
+  MockBatteryProperties line_power_AC_properties;
+  line_power_AC_properties.type =
+      UPowerDeviceType::UPOWER_DEVICE_TYPE_LINE_POWER;
+  AddDeviceProxy(kUPowerDeviceACLinePath, &line_power_AC_properties);
+
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  battery_bat0_properties.time_to_full = 0;
+  battery_bat0_properties.time_to_empty = 200;
+  battery_bat0_properties.percentage = 70;
+  AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+      .ExpectConnectToSignalPropertyChanged();
+
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
+
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(200, status.discharging_time);
+  EXPECT_EQ(0.7, status.level);
+}
+
+TEST_F(BatteryStatusManagerLinuxTest, UpdateDevicePropertyState) {
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING;
+  battery_bat0_properties.time_to_full = 100;
+  battery_bat0_properties.time_to_empty = 200;
+  battery_bat0_properties.percentage = 80;
+  MockBatteryObject& battery_bat0 =
+      AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+          .ExpectConnectToSignalPropertyChanged();
+
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
+
+  EXPECT_TRUE(status.charging);
+  EXPECT_EQ(100, status.charging_time);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
+  EXPECT_EQ(.8, status.level);
+
+  int last_count = count_battery_updates();
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  DeviceSignalPropertyChanged(&battery_bat0, kUPowerDevicePropertyState);
+  status = last_battery_status();
+
+  EXPECT_LT(last_count, count_battery_updates());
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(200, status.discharging_time);
+  EXPECT_EQ(.8, status.level);
+}
+
+TEST_F(BatteryStatusManagerLinuxTest, UpdateDevicePropertyPercentage) {
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  battery_bat0_properties.time_to_full = 100;
+  battery_bat0_properties.time_to_empty = 200;
+  battery_bat0_properties.percentage = 80;
+  MockBatteryObject& battery_bat0 =
+      AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+          .ExpectConnectToSignalPropertyChanged();
+
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
+
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(200, status.discharging_time);
+  EXPECT_EQ(.8, status.level);
+
+  int last_count = count_battery_updates();
+  battery_bat0_properties.percentage = 70;
+  DeviceSignalPropertyChanged(&battery_bat0, kUPowerDevicePropertyPercentage);
+  status = last_battery_status();
+
+  EXPECT_LT(last_count, count_battery_updates());
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(200, status.discharging_time);
+  EXPECT_EQ(.7, status.level);
+}
+
+TEST_F(BatteryStatusManagerLinuxTest, UpdateDevicePropertyTimeToEmpty) {
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  battery_bat0_properties.time_to_full = 100;
+  battery_bat0_properties.time_to_empty = 200;
+  battery_bat0_properties.percentage = 80;
+  MockBatteryObject& battery_bat0 =
+      AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+          .ExpectConnectToSignalPropertyChanged();
+
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
+
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(200, status.discharging_time);
+  EXPECT_EQ(.8, status.level);
+
+  int last_count = count_battery_updates();
+  battery_bat0_properties.time_to_empty = 150;
+  DeviceSignalPropertyChanged(&battery_bat0, kUPowerDevicePropertyTimeToEmpty);
+  status = last_battery_status();
+
+  EXPECT_LT(last_count, count_battery_updates());
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(150, status.discharging_time);
+  EXPECT_EQ(.8, status.level);
+}
+
+TEST_F(BatteryStatusManagerLinuxTest, UpdateDevicePropertyTimeToFull) {
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING;
+  battery_bat0_properties.time_to_full = 100;
+  battery_bat0_properties.time_to_empty = 200;
+  battery_bat0_properties.percentage = 80;
+  MockBatteryObject& battery_bat0 =
+      AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+          .ExpectConnectToSignalPropertyChanged();
+
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
+
+  EXPECT_TRUE(status.charging);
+  EXPECT_EQ(100, status.charging_time);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
+  EXPECT_EQ(.8, status.level);
+
+  int last_count = count_battery_updates();
+  battery_bat0_properties.time_to_full = 50;
+  DeviceSignalPropertyChanged(&battery_bat0, kUPowerDevicePropertyTimeToFull);
+  status = last_battery_status();
+
+  EXPECT_LT(last_count, count_battery_updates());
+  EXPECT_TRUE(status.charging);
+  EXPECT_EQ(50, status.charging_time);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
+  EXPECT_EQ(.8, status.level);
+}
+
+TEST_F(BatteryStatusManagerLinuxTest, OldDaemonDeviceChanged) {
+  mock_upower_.daemon_version = "0.9.23";
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  battery_bat0_properties.time_to_full = 100;
+  battery_bat0_properties.time_to_empty = 200;
+  battery_bat0_properties.percentage = 80;
+  MockBatteryObject& battery_bat0 =
+      AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+          .ExpectConnectToSignalChanged()
+          .ExpectConnectToSignalPropertyChanged();
+
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
+
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(200, status.discharging_time);
+  EXPECT_EQ(.8, status.level);
+
+  int last_count = count_battery_updates();
+  battery_bat0_properties.percentage = 70;
+  DeviceSignalChanged(&battery_bat0);
+  status = last_battery_status();
+
+  EXPECT_LT(last_count, count_battery_updates());
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(200, status.discharging_time);
+  EXPECT_EQ(.7, status.level);
+}
+
+TEST_F(BatteryStatusManagerLinuxTest, DisplayDeviceNoBattery) {
+  MockBatteryProperties display_device_properties;
+  display_device_properties.type = UPowerDeviceType::UPOWER_DEVICE_TYPE_UNKNOWN;
+  SetUpDisplayDeviceProxy(&display_device_properties);
+
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  battery_bat0_properties.time_to_full = 0;
+  battery_bat0_properties.time_to_empty = 200;
+  battery_bat0_properties.percentage = 90;
+  AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+      .ExpectConnectToSignalPropertyChanged();
+
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
+
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(200, status.discharging_time);
+  EXPECT_EQ(0.9, status.level);
+}
+
+TEST_F(BatteryStatusManagerLinuxTest, DisplayDeviceBattery) {
+  MockBatteryProperties display_device_properties;
+  display_device_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  display_device_properties.time_to_full = 0;
+  display_device_properties.time_to_empty = 200;
+  display_device_properties.percentage = 90;
+  SetUpDisplayDeviceProxy(&display_device_properties)
+      .ExpectConnectToSignalPropertyChanged();
+
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
+
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(200, status.discharging_time);
+  EXPECT_EQ(.9, status.level);
+}
+
+TEST_F(BatteryStatusManagerLinuxTest, DisplayDeviceBatterySkipsEnumerate) {
+  MockBatteryProperties display_device_properties;
+  display_device_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  display_device_properties.time_to_full = 0;
+  display_device_properties.time_to_empty = 200;
+  display_device_properties.percentage = 90;
+  SetUpDisplayDeviceProxy(&display_device_properties)
+      .ExpectConnectToSignalPropertyChanged();
+
+  AddDevicePath(kUPowerDeviceACLinePath);
+  AddDevicePath(kUPowerDeviceBattery0Path);
+  AddDevicePath(kUPowerDeviceBattery1Path);
+
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
+
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(200, status.discharging_time);
+  EXPECT_EQ(.9, status.level);
+}
+
+// Adding a display-device will make the BatteryStatusManagerLinux switch to
+// the display-device.
+TEST_F(BatteryStatusManagerLinuxTest, SignalDeviceAddedDisplayDevice) {
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  battery_bat0_properties.time_to_full = 0;
+  battery_bat0_properties.time_to_empty = 200;
+  battery_bat0_properties.percentage = 70;
+  AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+      .ExpectConnectToSignalPropertyChanged();
+
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
+
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(200, status.discharging_time);
+  EXPECT_EQ(0.7, status.level);
+
+  int last_count = count_battery_updates();
+  MockBatteryProperties display_device_properties;
+  display_device_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING;
+  display_device_properties.time_to_full = 100;
+  display_device_properties.time_to_empty = 150;
+  display_device_properties.percentage = 80;
+  SetUpDisplayDeviceProxy(&display_device_properties)
+      .ExpectConnectToSignalPropertyChanged();
+
+  UPowerSignalDeviceAdded(mock_upower_.display_device);
+  status = last_battery_status();
+  EXPECT_LT(last_count, count_battery_updates());
+
+  EXPECT_TRUE(status.charging);
+  EXPECT_EQ(100, status.charging_time);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
+  EXPECT_EQ(0.8, status.level);
+}
+
+// Prepending a battery should switch to that battery.
+TEST_F(BatteryStatusManagerLinuxTest, SignalDeviceAddedBatteryAtFront) {
+  MockBatteryProperties battery_bat1_properties;
+  battery_bat1_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  battery_bat1_properties.time_to_full = 0;
+  battery_bat1_properties.time_to_empty = 200;
+  battery_bat1_properties.percentage = 70;
+  AddDeviceProxy(kUPowerDeviceBattery1Path, &battery_bat1_properties)
+      .ExpectConnectToSignalPropertyChanged();
+
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
+
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(200, status.discharging_time);
+  EXPECT_EQ(0.7, status.level);
+
+  int last_count = count_battery_updates();
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  battery_bat0_properties.time_to_full = 0;
+  battery_bat0_properties.time_to_empty = 150;
+  battery_bat0_properties.percentage = 50;
+  PushFrontDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+      .ExpectConnectToSignalPropertyChanged();
+  UPowerSignalDeviceAdded(kUPowerDeviceBattery0Path);
+  status = last_battery_status();
+  EXPECT_LT(last_count, count_battery_updates());
+
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(150, status.discharging_time);
+  EXPECT_EQ(0.5, status.level);
+}
+
+// Appending a battery should keep the current battery.
+TEST_F(BatteryStatusManagerLinuxTest, SignalDeviceAddedBatteryAtBack) {
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  battery_bat0_properties.time_to_full = 0;
+  battery_bat0_properties.time_to_empty = 150;
+  battery_bat0_properties.percentage = 50;
+  AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+      .ExpectConnectToSignalPropertyChanged();
+
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
+
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(150, status.discharging_time);
+  EXPECT_EQ(0.5, status.level);
+
+  int last_count = count_battery_updates();
+  MockBatteryProperties battery_bat1_properties;
+  battery_bat1_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  battery_bat1_properties.time_to_full = 0;
+  battery_bat1_properties.time_to_empty = 200;
+  battery_bat1_properties.percentage = 70;
+  AddDeviceProxy(kUPowerDeviceBattery1Path, &battery_bat1_properties);
+  UPowerSignalDeviceAdded(kUPowerDeviceBattery1Path);
+  status = last_battery_status();
+  EXPECT_LT(last_count, count_battery_updates());
+
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(150, status.discharging_time);
+  EXPECT_EQ(0.5, status.level);
+}
+
+// Adding a device that is no battery should not change anything.
+TEST_F(BatteryStatusManagerLinuxTest, SignalDeviceAddedNoBattery) {
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  battery_bat0_properties.time_to_full = 0;
+  battery_bat0_properties.time_to_empty = 200;
+  battery_bat0_properties.percentage = 70;
+  AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+      .ExpectConnectToSignalPropertyChanged();
+
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
+
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(200, status.discharging_time);
+  EXPECT_EQ(0.7, status.level);
+
+  int last_count = count_battery_updates();
+  MockBatteryProperties line_power_AC_properties;
+  line_power_AC_properties.type =
+      UPowerDeviceType::UPOWER_DEVICE_TYPE_LINE_POWER;
+  PushFrontDeviceProxy(kUPowerDeviceACLinePath, &line_power_AC_properties);
+  UPowerSignalDeviceAdded(kUPowerDeviceACLinePath);
+  status = last_battery_status();
+  EXPECT_LT(last_count, count_battery_updates());
+
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(200, status.discharging_time);
+  EXPECT_EQ(0.7, status.level);
+}
+
+TEST_F(BatteryStatusManagerLinuxTest, SignalDeviceRemovedBattery) {
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  battery_bat0_properties.time_to_full = 0;
+  battery_bat0_properties.time_to_empty = 200;
+  battery_bat0_properties.percentage = 70;
+  AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+      .ExpectConnectToSignalPropertyChanged();
+
+  MockBatteryProperties battery_bat1_properties;
+  battery_bat1_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_CHARGING;
+  battery_bat1_properties.time_to_full = 100;
+  battery_bat1_properties.time_to_empty = 0;
+  battery_bat1_properties.percentage = 80;
+  MockBatteryObject& battery_bat1 =
+      AddDeviceProxy(kUPowerDeviceBattery1Path, &battery_bat1_properties);
+
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
+
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(200, status.discharging_time);
+  EXPECT_EQ(0.7, status.level);
+
+  int last_count = count_battery_updates();
+  ExpectGetObjectProxy(kUPowerDeviceBattery1Path, &battery_bat1);
+  battery_bat1.ExpectConnectToSignalPropertyChanged();
+
+  EXPECT_EQ(kUPowerDeviceBattery0Path, mock_upower_.devices.front());
+  mock_upower_.devices.pop_front();
+  UPowerSignalDeviceRemoved(kUPowerDeviceBattery0Path);
+  status = last_battery_status();
+  EXPECT_LT(last_count, count_battery_updates());
+
+  EXPECT_TRUE(status.charging);
+  EXPECT_EQ(100, status.charging_time);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
+  EXPECT_EQ(0.8, status.level);
+}
+
+TEST_F(BatteryStatusManagerLinuxTest, SignalDeviceRemovedOther) {
+  MockBatteryProperties battery_bat0_properties;
+  battery_bat0_properties.state =
+      UPowerDeviceState::UPOWER_DEVICE_STATE_DISCHARGING;
+  battery_bat0_properties.time_to_full = 0;
+  battery_bat0_properties.time_to_empty = 200;
+  battery_bat0_properties.percentage = 70;
+  AddDeviceProxy(kUPowerDeviceBattery0Path, &battery_bat0_properties)
+      .ExpectConnectToSignalPropertyChanged();
+
+  MockBatteryProperties line_power_AC_properties;
+  line_power_AC_properties.type =
+      UPowerDeviceType::UPOWER_DEVICE_TYPE_LINE_POWER;
+  AddDeviceProxy(kUPowerDeviceACLinePath, &line_power_AC_properties);
+
+  StartBatteryStatusManagerLinux();
+  BatteryStatus status = last_battery_status();
+  EXPECT_LE(1, count_battery_updates());
+
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(200, status.discharging_time);
+  EXPECT_EQ(0.7, status.level);
+
+  int last_count = count_battery_updates();
+  mock_upower_.devices.pop_back();
+  UPowerSignalDeviceRemoved(kUPowerDeviceACLinePath);
+  status = last_battery_status();
+  EXPECT_EQ(last_count, count_battery_updates());
+
+  EXPECT_FALSE(status.charging);
+  EXPECT_EQ(std::numeric_limits<double>::infinity(), status.charging_time);
+  EXPECT_EQ(200, status.discharging_time);
+  EXPECT_EQ(0.7, status.level);
+}
 

[timvolodine, 2016/06/16 16:12:24]

nit: maybe an idea for extra test (which doesn't seem to be really covered):
when there is no battery but other devices present.

[markuso, 2016/06/17 08:45:19]

True, there is no test for that.

There is "NoBattery" when no device is present, there is "SkipNonBatteryDevice"
to skip a device and find a battery afterwards. There is
"DisplayDeviceNoBattery" to skip the DisplayDevice if it is no battery.
So at least we already cover all steps that would be executed if there were
devices, but none of them a battery.

[markuso, 2016/06/17 10:01:17]

With the added test "OldDaemonSignalDeviceChanged" there is now such a part
included: first there is one device that is no battery. In a second step the
device is changed to type battery.

[timvolodine, 2016/07/05 16:21:07]

yes, thanks, just thought that the 'no battery' case would be quite common, e.g.
on desktops.

 }  // namespace device