Turn on enterprise network state reporting for affiliated users.

Network state should be reported in three conditions.
1- Primary user signed in is affiliated.
2- Managed device is in kiosk mode.
3- Managed guest session is running.

Bug: 1027086
Test: browser_tests --gtest_filter=DeviceStatusCollectorNetwork*
Change-Id: I29aaad9f5e442ea164bd1afd28a3bca72c66e459
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1928702
Commit-Queue: Omar Morsi <omorsi@google.com>
Reviewed-by: Maksim Ivanov <emaxx@chromium.org>
Cr-Commit-Position: refs/heads/master@{#720225}

chrome/browser/chromeos/policy/status_collector/device_status_collector.cc

@@ -1448,9 +1448,11 @@ bool DeviceStatusCollector::GetNetworkInterfaces(
     anything_reported = true;
   }
 
-  // Don't write any network state if we aren't in a kiosk or public session.
-  if (!GetAutoLaunchedKioskSessionInfo() &&
-      !user_manager::UserManager::Get()->IsLoggedInAsPublicAccount()) {
+  user_manager::UserManager* user_manager = user_manager::UserManager::Get();
+  const user_manager::User* const primary_user = user_manager->GetPrimaryUser();
+  // Don't write network state for unaffiliated users or when no user is signed
+  // in.
+  if (!primary_user || !primary_user->IsAffiliated()) {
     return anything_reported;
   }
 

chrome/browser/chromeos/policy/status_collector/device_status_collector_browsertest.cc

@@ -2554,8 +2554,7 @@ static const FakeNetworkState kUnconfiguredNetwork = {
   shill::kStateOffline, em::NetworkState::OFFLINE, "", ""
 };
 
-class DeviceStatusCollectorNetworkInterfacesTest
-    : public DeviceStatusCollectorTest {
+class DeviceStatusCollectorNetworkTest : public DeviceStatusCollectorTest {
  protected:
   void SetUp() override {
     DeviceStatusCollectorTest::SetUp();
@@ -2673,7 +2672,13 @@ class DeviceStatusCollectorNetworkInterfacesTest
     DeviceStatusCollectorTest::TearDown();
   }
 
-  void VerifyNetworkReporting() {
+  virtual void VerifyReporting() = 0;
+};
+
+class DeviceStatusCollectorNetworkInterfacesTest
+    : public DeviceStatusCollectorNetworkTest {
+ protected:
+  void VerifyReporting() override {
     int count = 0;
     for (const FakeDeviceData& dev : kFakeDevices) {
       if (dev.expected_type == -1)
@@ -2704,8 +2709,71 @@ class DeviceStatusCollectorNetworkInterfacesTest
     }
 
     EXPECT_EQ(count, device_status_.network_interfaces_size());
+  }
+};
+
+TEST_F(DeviceStatusCollectorNetworkInterfacesTest, Default) {
+  // Network interfaces should be reported by default.
+  GetStatus();
+  VerifyReporting();
+
+  // Network interfaces shouldn't be reported if the policy is off.
+  scoped_testing_cros_settings_.device_settings()->SetBoolean(
+      chromeos::kReportDeviceNetworkInterfaces, false);
+  GetStatus();
+  EXPECT_EQ(0, device_status_.network_interfaces_size());
+
+  // Switch the policy on and verify the interface list is present.
+  scoped_testing_cros_settings_.device_settings()->SetBoolean(
+      chromeos::kReportDeviceNetworkInterfaces, true);
+  GetStatus();
+  VerifyReporting();
+}
+
+TEST_F(DeviceStatusCollectorNetworkInterfacesTest, IfUnaffiliatedUser) {
+  // Network interfaces should be reported for unaffiliated users.
+  const AccountId account_id0(AccountId::FromUserEmail("user0@managed.com"));
+  user_manager_->AddUserWithAffiliationAndType(account_id0, false,
+                                               user_manager::USER_TYPE_REGULAR);
+  GetStatus();
+  VerifyReporting();
+}
+
+TEST_F(DeviceStatusCollectorNetworkInterfacesTest, IfAffiliatedUser) {
+  // Network interfaces should be reported for affiliated users.
+  const AccountId account_id0(AccountId::FromUserEmail("user0@managed.com"));
+  user_manager_->AddUserWithAffiliationAndType(account_id0, true,
+                                               user_manager::USER_TYPE_REGULAR);
+  GetStatus();
+  VerifyReporting();
+}
+
+TEST_F(DeviceStatusCollectorNetworkInterfacesTest, IfPublicSession) {
+  // Network interfaces should be reported if in public session.
+  user_manager_->CreatePublicAccountUser(
+      AccountId::FromUserEmail(kPublicAccountId));
+  EXPECT_CALL(*user_manager_, IsLoggedInAsPublicAccount())
+      .WillRepeatedly(Return(true));
 
-    // Now make sure network state list is correct.
+  GetStatus();
+  VerifyReporting();
+}
+
+TEST_F(DeviceStatusCollectorNetworkInterfacesTest, IfKioskMode) {
+  // Network interfaces should be reported if in kiosk mode.
+
+  user_manager_->CreateKioskAppUser(AccountId::FromUserEmail(kKioskAccountId));
+  EXPECT_CALL(*user_manager_, IsLoggedInAsKioskApp())
+      .WillRepeatedly(Return(true));
+
+  GetStatus();
+  VerifyReporting();
+}
+
+class DeviceStatusCollectorNetworkStateTest
+    : public DeviceStatusCollectorNetworkTest {
+ protected:
+  void VerifyReporting() override {
     EXPECT_EQ(base::size(kFakeNetworks),
               static_cast<size_t>(device_status_.network_states_size()));
     for (const FakeNetworkState& state : kFakeNetworks) {
@@ -2736,51 +2804,69 @@ class DeviceStatusCollectorNetworkInterfacesTest
   }
 };
 
-TEST_F(DeviceStatusCollectorNetworkInterfacesTest, NoNetworkStateIfNotKiosk) {
-  // If not in an active kiosk session, there should be network interfaces
-  // reported, but no network state.
+TEST_F(DeviceStatusCollectorNetworkStateTest, Default) {
+  // Network state shouldn't be reported by default.
   GetStatus();
-  EXPECT_LT(0, device_status_.network_interfaces_size());
   EXPECT_EQ(0, device_status_.network_states_size());
-}
 
-TEST_F(DeviceStatusCollectorNetworkInterfacesTest, NetworkInterfaces) {
-  // Mock that we are in kiosk mode so we report network state.
-  status_collector_->set_kiosk_account(
-      std::make_unique<policy::DeviceLocalAccount>(
-          fake_kiosk_device_local_account_));
+  // Mock that the device is in kiosk mode to report network state.
+  user_manager_->CreateKioskAppUser(AccountId::FromUserEmail(kKioskAccountId));
+  EXPECT_CALL(*user_manager_, IsLoggedInAsKioskApp())
+      .WillRepeatedly(Return(true));
 
-  // Interfaces should be reported by default.
   GetStatus();
-  EXPECT_LT(0, device_status_.network_interfaces_size());
-  EXPECT_LT(0, device_status_.network_states_size());
+  VerifyReporting();
 
-  // No interfaces should be reported if the policy is off.
+  // Network state shouldn't be reported if the policy is off.
   scoped_testing_cros_settings_.device_settings()->SetBoolean(
       chromeos::kReportDeviceNetworkInterfaces, false);
   GetStatus();
-  EXPECT_EQ(0, device_status_.network_interfaces_size());
   EXPECT_EQ(0, device_status_.network_states_size());
 
-  // Switch the policy on and verify the interface list is present.
+  // Switch the policy on and verify that network state is reported
   scoped_testing_cros_settings_.device_settings()->SetBoolean(
       chromeos::kReportDeviceNetworkInterfaces, true);
   GetStatus();
+  VerifyReporting();
+}
+
+TEST_F(DeviceStatusCollectorNetworkStateTest, IfUnaffiliatedUser) {
+  // Network state shouldn't be reported for unaffiliated users.
+  const AccountId account_id0(AccountId::FromUserEmail("user0@managed.com"));
+  user_manager_->AddUserWithAffiliationAndType(account_id0, false,
+                                               user_manager::USER_TYPE_REGULAR);
+  GetStatus();
+  EXPECT_EQ(0, device_status_.network_states_size());
+}
 
-  VerifyNetworkReporting();
+TEST_F(DeviceStatusCollectorNetworkStateTest, IfAffiliatedUser) {
+  // Network state should be reported for affiliated users.
+  const AccountId account_id0(AccountId::FromUserEmail("user0@managed.com"));
+  user_manager_->AddUserWithAffiliationAndType(account_id0, true,
+                                               user_manager::USER_TYPE_REGULAR);
+  GetStatus();
+  VerifyReporting();
 }
 
-TEST_F(DeviceStatusCollectorNetworkInterfacesTest, ReportIfPublicSession) {
-  // Report netowork state for public accounts.
+TEST_F(DeviceStatusCollectorNetworkStateTest, IfPublicSession) {
+  // Network state should be reported if in public session.
   user_manager_->CreatePublicAccountUser(
       AccountId::FromUserEmail(kPublicAccountId));
   EXPECT_CALL(*user_manager_, IsLoggedInAsPublicAccount())
       .WillRepeatedly(Return(true));
 
-  scoped_testing_cros_settings_.device_settings()->SetBoolean(
-      chromeos::kReportDeviceNetworkInterfaces, true);
   GetStatus();
-  VerifyNetworkReporting();
+  VerifyReporting();
+}
+
+TEST_F(DeviceStatusCollectorNetworkStateTest, IfKioskMode) {
+  // Network state should be reported if in kiosk mode.
+  user_manager_->CreateKioskAppUser(AccountId::FromUserEmail(kKioskAccountId));
+  EXPECT_CALL(*user_manager_, IsLoggedInAsKioskApp())
+      .WillRepeatedly(Return(true));
+
+  GetStatus();
+  VerifyReporting();
 }
 
 }  // namespace policy