Map signal_strength from percentage to dBm per spec

chrome/browser/chromeos/policy/device_status_collector_browsertest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/policy/device_status_collector.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 967 matching lines @@
     "", "", "",
     -1 },
 };
 
 // Fake network state.
 struct FakeNetworkState {
   const char* name;
   const char* device_path;
   const char* type;
   int signal_strength;
+  int expected_signal_strength;
   const char* connection_status;
   int expected_state;
   const char* address;
   const char* gateway;
 };
 
 // List of fake networks - primarily used to make sure that signal strength
 // and connection state are properly populated in status reports. Note that
 // by convention shill will not report a signal strength of 0 for a visible
 // network, so we use 1 below.
 static const FakeNetworkState kFakeNetworks[] = {
-  { "offline", "/device/wifi", shill::kTypeWifi, 35,
+  { "offline", "/device/wifi", shill::kTypeWifi, 35, -85,
     shill::kStateOffline, em::NetworkState::OFFLINE, "", "" },
-  { "ethernet", "/device/ethernet", shill::kTypeEthernet, 0,
+  { "ethernet", "/device/ethernet", shill::kTypeEthernet, 0, 0,
     shill::kStateOnline, em::NetworkState::ONLINE,
     "192.168.0.1", "8.8.8.8" },
-  { "wifi", "/device/wifi", shill::kTypeWifi, 23, shill::kStatePortal,
+  { "wifi", "/device/wifi", shill::kTypeWifi, 23, -97, shill::kStatePortal,
     em::NetworkState::PORTAL, "", "" },
-  { "idle", "/device/cellular1", shill::kTypeCellular, 0, shill::kStateIdle,
+  { "idle", "/device/cellular1", shill::kTypeCellular, 0, 0, shill::kStateIdle,

[Thiemo Nagel, 2015/04/16 15:16:33]

I'm unsure what the expected behaviour for cellular should be.  My hunch is that
signal strength should be passed through unchanged and thus I'd suggest to
replace "0, 0" by "10, 10" to test for that.

[Andrew T Wilson (Slow), 2015/04/17 14:41:02]

I've changed this to just not report for cellular networks, and added a test for
that case.

     em::NetworkState::IDLE, "", "" },
-  { "carrier", "/device/cellular1", shill::kTypeCellular, 0,
+  { "carrier", "/device/cellular1", shill::kTypeCellular, 0, 0,
     shill::kStateCarrier, em::NetworkState::CARRIER, "", "" },
-  { "association", "/device/cellular1", shill::kTypeCellular, 0,
+  { "association", "/device/cellular1", shill::kTypeCellular, 0, 0,
     shill::kStateAssociation, em::NetworkState::ASSOCIATION, "", "" },
-  { "config", "/device/cellular1", shill::kTypeCellular, 0,
+  { "config", "/device/cellular1", shill::kTypeCellular, 0, 0,
     shill::kStateConfiguration, em::NetworkState::CONFIGURATION, "", "" },
-  { "ready", "/device/cellular1", shill::kTypeCellular, 0, shill::kStateReady,
-    em::NetworkState::READY, "", "" },
-  { "disconnect", "/device/wifi", shill::kTypeWifi, 1,
+  { "ready", "/device/cellular1", shill::kTypeCellular, 0, 0,
+    shill::kStateReady, em::NetworkState::READY, "", "" },
+  { "disconnect", "/device/wifi", shill::kTypeWifi, 1, -119,
     shill::kStateDisconnect, em::NetworkState::DISCONNECT, "", "" },
-  { "failure", "/device/wifi", shill::kTypeWifi, 1, shill::kStateFailure,
+  { "failure", "/device/wifi", shill::kTypeWifi, 1, -119, shill::kStateFailure,
     em::NetworkState::FAILURE, "", "" },
-  { "activation-failure", "/device/cellular1", shill::kTypeCellular, 0,
+  { "activation-failure", "/device/cellular1", shill::kTypeCellular, 0, 0,
     shill::kStateActivationFailure, em::NetworkState::ACTIVATION_FAILURE,
     "", "" },
-  { "unknown", "", shill::kTypeWifi, 1, "unknown", em::NetworkState::UNKNOWN,
-    "", "" },
+  { "unknown", "", shill::kTypeWifi, 1, -119, "unknown",
+    em::NetworkState::UNKNOWN, "", "" },
 };
 
 static const FakeNetworkState kUnconfiguredNetwork = {
-  "unconfigured", "/device/unconfigured", shill::kTypeWifi, 35,
+  "unconfigured", "/device/unconfigured", shill::kTypeWifi, 35, -85,
   shill::kStateOffline, em::NetworkState::OFFLINE, "", ""
 };
 
 class DeviceStatusCollectorNetworkInterfacesTest
     : public DeviceStatusCollectorTest {
  protected:
   void SetUp() override {
     chromeos::DBusThreadManager::Initialize();
     chromeos::NetworkHandler::Initialize();
     chromeos::ShillDeviceClient::TestInterface* test_device_client =
@@ skipping 164 matching lines @@
 
   EXPECT_EQ(count, status_.network_interface_size());
 
   // Now make sure network state list is correct.
   EXPECT_EQ(arraysize(kFakeNetworks),
             static_cast<size_t>(status_.network_state_size()));
   for (const FakeNetworkState& state : kFakeNetworks) {
     bool found_match = false;
     for (const em::NetworkState& proto_state : status_.network_state()) {
       // Make sure every item has a matching entry in the proto.
+      bool should_have_signal_strength = state.expected_signal_strength != 0;
       if (proto_state.has_device_path() == (strlen(state.device_path) > 0) &&
-          proto_state.signal_strength() == state.signal_strength &&
+          proto_state.has_signal_strength() == should_have_signal_strength &&
+          proto_state.signal_strength() == state.expected_signal_strength &&
           proto_state.connection_state() == state.expected_state) {
         if (proto_state.has_ip_address())
           EXPECT_EQ(proto_state.ip_address(), state.address);
         else
           EXPECT_EQ(0U, strlen(state.address));
         if (proto_state.has_gateway())
           EXPECT_EQ(proto_state.gateway(), state.gateway);
         else
           EXPECT_EQ(0U, strlen(state.gateway));
         found_match = true;
         break;
       }
     }
     EXPECT_TRUE(found_match) << "No matching state for fake network "
                              << " (" << state.name << ")";
   }
 }
 
 }  // namespace policy