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

device/battery/battery_status_manager_linux_unittest.cc

 // Copyright 2014 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 "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 "device/battery/battery_status_manager_linux-inl.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 {
-
-TEST(BatteryStatusManagerLinuxTest, EmptyDictionary) {
-  base::DictionaryValue dictionary;
+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_changed;
+  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();
+  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();
+  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();
+}
+
+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);
   EXPECT_EQ(default_status.discharging_time, status.discharging_time);
   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);
   EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
   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);
   EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
   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);
   EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
   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);
   EXPECT_EQ(200, status.discharging_time);
   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);
   EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
   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);
   EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
   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);
   EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
   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);
   EXPECT_EQ(std::numeric_limits<double>::infinity(), status.discharging_time);
   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, OldDaemonDeviceSignalChanged) {
+  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);
+}
 
 }  // namespace device