Add '.mojom' suffix for battery mojom modules.

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 <limits>
 #include <list>
 #include <string>
 
@@ skipping 349 matching lines @@
   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_; }
+  const mojom::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 BatteryUpdateCallback(const mojom::BatteryStatus& status);
   void SyncWithNotifierThread();
 
   std::unique_ptr<BatteryStatusManagerLinux> manager_;
   int count_battery_updates_ = 0;
-  BatteryStatus last_status_;
+  mojom::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);
 
@@ skipping 114 matching lines @@
   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) {
+    const mojom::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;
+  mojom::BatteryStatus default_status;
   StartBatteryStatusManagerLinux();
-  BatteryStatus status = last_battery_status();
+  mojom::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_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();
 
   StartBatteryStatusManagerLinux();
-  BatteryStatus status = last_battery_status();
+  mojom::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_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();
 
   StartBatteryStatusManagerLinux();
-  BatteryStatus status = last_battery_status();
+  mojom::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_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();
 
   StartBatteryStatusManagerLinux();
-  BatteryStatus status = last_battery_status();
+  mojom::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_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();
 
   StartBatteryStatusManagerLinux();
-  BatteryStatus status = last_battery_status();
+  mojom::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, 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();
 
   StartBatteryStatusManagerLinux();
-  BatteryStatus status = last_battery_status();
+  mojom::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_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();
 
   StartBatteryStatusManagerLinux();
-  BatteryStatus status = last_battery_status();
+  mojom::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_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();
 
   StartBatteryStatusManagerLinux();
-  BatteryStatus status = last_battery_status();
+  mojom::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_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();
 
   StartBatteryStatusManagerLinux();
-  BatteryStatus status = last_battery_status();
+  mojom::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);
 }
 
 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();
+  mojom::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();
+  mojom::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();
+  mojom::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;
@@ skipping 12 matching lines @@
   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();
+  mojom::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);
@@ skipping 11 matching lines @@
   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();
+  mojom::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);
@@ skipping 11 matching lines @@
   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();
+  mojom::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);
@@ skipping 14 matching lines @@
       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();
+  mojom::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);
@@ skipping 14 matching lines @@
   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();
+  mojom::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();
+  mojom::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();
+  mojom::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();
+  mojom::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 =
@@ skipping 19 matching lines @@
   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();
+  mojom::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 =
@@ skipping 18 matching lines @@
   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();
+  mojom::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 =
@@ skipping 17 matching lines @@
   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();
+  mojom::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 =
@@ skipping 22 matching lines @@
   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();
+  mojom::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();
@@ skipping 19 matching lines @@
   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();
+  mojom::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