Disable network state reporting.

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 75 matching lines @@
       PrefService* local_state,
       chromeos::system::StatisticsProvider* provider,
       const policy::DeviceStatusCollector::LocationUpdateRequester&
           location_update_requester,
       const policy::DeviceStatusCollector::VolumeInfoFetcher&
           volume_info_fetcher)
       : policy::DeviceStatusCollector(
           local_state,
           provider,
           location_update_requester,
-          volume_info_fetcher) {
+          volume_info_fetcher),
+        kiosk_mode_(false) {
     // Set the baseline time to a fixed value (1 AM) to prevent test flakiness
     // due to a single activity period spanning two days.
     SetBaselineTime(Time::Now().LocalMidnight() + TimeDelta::FromHours(1));
   }
 
   void Simulate(ui::IdleState* states, int len) {
     for (int i = 0; i < len; i++)
       IdleStateCallback(states[i]);
   }
 
@@ skipping 14 matching lines @@
   void set_mock_cpu_usage(double total_cpu_usage, int num_processors) {
     std::vector<double> usage;
     for (int i = 0; i < num_processors; ++i)
       usage.push_back(total_cpu_usage / num_processors);
 
     mock_cpu_usage_ = usage;
 
     RefreshSampleResourceUsage();
   }
 
+  void set_kiosk_mode(bool is_kiosk) {
+    kiosk_mode_ = is_kiosk;
+  }
+
+  bool IsAutoLaunchedKioskSession() override {
+    return kiosk_mode_;
+  }
+
   void RefreshSampleResourceUsage() {
     // Refresh our samples. Sample more than kMaxHardwareSamples times to
     // make sure that the code correctly caps the number of cached samples.
     for (int i = 0; i < static_cast<int>(kMaxResourceUsageSamples + 1); ++i)
       SampleResourceUsage();
   }
 
  protected:
   void CheckIdleState() override {
     // This should never be called in testing, as it results in a dbus call.
@@ skipping 13 matching lines @@
   }
 
  private:
   // Baseline time for the fake times returned from GetCurrentTime().
   Time baseline_time_;
 
   // The number of simulated periods since the baseline time.
   int baseline_offset_periods_;
 
   std::vector<double> mock_cpu_usage_;
+
+  bool kiosk_mode_;
 };
 
 // Return the total number of active milliseconds contained in a device
 // status report.
 int64 GetActiveMilliseconds(em::DeviceStatusReportRequest& status) {
   int64 active_milliseconds = 0;
   for (int i = 0; i < status.active_period_size(); i++) {
     active_milliseconds += status.active_period(i).active_duration();
   }
   return active_milliseconds;
@@ skipping 844 matching lines @@
         &state_list);
     ASSERT_EQ(arraysize(kFakeNetworks), state_list.size());
   }
 
   void TearDown() override {
     chromeos::NetworkHandler::Shutdown();
     chromeos::DBusThreadManager::Shutdown();
   }
 };
 
+TEST_F(DeviceStatusCollectorNetworkInterfacesTest, NoNetworkStateIfNotKiosk) {
+  // If not in an active kiosk session, there should be network interfaces
+  // reported, but no network state.
+  GetStatus();
+  EXPECT_LT(0, status_.network_interface_size());
+  EXPECT_EQ(0, status_.network_state_size());
+}
+
 TEST_F(DeviceStatusCollectorNetworkInterfacesTest, NetworkInterfaces) {
+  // Mock that we are in kiosk mode so we report network state.
+  status_collector_->set_kiosk_mode(true);
+
   // Interfaces should be reported by default.
   GetStatus();
   EXPECT_LT(0, status_.network_interface_size());
   EXPECT_LT(0, status_.network_state_size());
 
   // No interfaces should be reported if the policy is off.
   cros_settings_->SetBoolean(chromeos::kReportDeviceNetworkInterfaces, false);
   GetStatus();
   EXPECT_EQ(0, status_.network_interface_size());
   EXPECT_EQ(0, status_.network_state_size());
@@ skipping 56 matching lines @@
         found_match = true;
         break;
       }
     }
     EXPECT_TRUE(found_match) << "No matching state for fake network "
                              << " (" << state.name << ")";
   }
 }
 
 }  // namespace policy