Enable enterprise device reporting features by default.

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 "base/environment.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 173 matching lines @@
     // Finish pending tasks.
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     message_loop_.RunUntilIdle();
 
     // Restore the real DeviceSettingsProvider.
     EXPECT_TRUE(
       cros_settings_->RemoveSettingsProvider(&stub_settings_provider_));
     cros_settings_->AddSettingsProvider(device_settings_provider_);
   }
 
+  virtual void SetUp() OVERRIDE {
+    // Disable network interface reporting since it requires additional setup.
+    cros_settings_->SetBoolean(chromeos::kReportDeviceNetworkInterfaces, false);
+  }
+
   void RestartStatusCollector() {
     policy::DeviceStatusCollector::LocationUpdateRequester callback =
         base::Bind(&MockPositionUpdateRequester);
     status_collector_.reset(
         new TestingDeviceStatusCollector(&prefs_,
                                          &statistics_provider_,
                                          &callback));
   }
 
   void GetStatus() {
@@ skipping 214 matching lines @@
 
   // Collect one more data point to trigger pruning.
   status_collector_->Simulate(test_states, 1);
 
   // Check that we don't exceed the max number of periods.
   status_.clear_active_period();
   GetStatus();
   EXPECT_LT(status_.active_period_size(), kMaxDays);
 }
 
-TEST_F(DeviceStatusCollectorTest, ActivityTimesDisabledByDefault) {
-  // If the pref for collecting device activity times isn't explicitly turned
-  // on, no data on activity times should be reported.
+TEST_F(DeviceStatusCollectorTest, ActivityTimesEnabledByDefault) {
+  // Device activity times should be reported by default.
+  IdleState test_states[] = {
+    IDLE_STATE_ACTIVE,
+    IDLE_STATE_ACTIVE,
+    IDLE_STATE_ACTIVE
+  };
+  status_collector_->Simulate(test_states,
+                              sizeof(test_states) / sizeof(IdleState));
+  GetStatus();
+  EXPECT_EQ(1, status_.active_period_size());
+  EXPECT_EQ(3 * ActivePeriodMilliseconds(), GetActiveMilliseconds(status_));
+}
+
+TEST_F(DeviceStatusCollectorTest, ActivityTimesOff) {
+  // Device activity times should not be reported if explicitly disabled.
+  cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, false);
 
   IdleState test_states[] = {
     IDLE_STATE_ACTIVE,
     IDLE_STATE_ACTIVE,
     IDLE_STATE_ACTIVE
   };
   status_collector_->Simulate(test_states,
                               sizeof(test_states) / sizeof(IdleState));
   GetStatus();
   EXPECT_EQ(0, status_.active_period_size());
@@ skipping 49 matching lines @@
 
   // After indicating a successful submit, the submitted status gets cleared,
   // but what got collected meanwhile sticks around.
   status_collector_->Simulate(test_states, 1);
   status_collector_->OnSubmittedSuccessfully();
   GetStatus();
   EXPECT_EQ(ActivePeriodMilliseconds(), GetActiveMilliseconds(status_));
 }
 
 TEST_F(DeviceStatusCollectorTest, DevSwitchBootMode) {
-  // Test that boot mode data is not reported if the pref is not turned on.
+  // Test that boot mode data is reported by default.
+  EXPECT_CALL(statistics_provider_,
+              GetMachineStatistic("devsw_boot", NotNull()))
+      .WillOnce(DoAll(SetArgPointee<1>("0"), Return(true)));
+  GetStatus();
+  EXPECT_EQ("Verified", status_.boot_mode());
+
+  // Test that boot mode data is not reported if the pref turned off.
+  cros_settings_->SetBoolean(chromeos::kReportDeviceBootMode, false);
+
   EXPECT_CALL(statistics_provider_,
               GetMachineStatistic("devsw_boot", NotNull()))
       .WillRepeatedly(DoAll(SetArgPointee<1>("0"), Return(true)));
   GetStatus();
   EXPECT_FALSE(status_.has_boot_mode());
 
   // Turn the pref on, and check that the status is reported iff the
   // statistics provider returns valid data.
   cros_settings_->SetBoolean(chromeos::kReportDeviceBootMode, true);
 
@@ skipping 16 matching lines @@
   EXPECT_EQ("Verified", status_.boot_mode());
 
   EXPECT_CALL(statistics_provider_,
               GetMachineStatistic("devsw_boot", NotNull()))
       .WillOnce(DoAll(SetArgPointee<1>("1"), Return(true)));
   GetStatus();
   EXPECT_EQ("Dev", status_.boot_mode());
 }
 
 TEST_F(DeviceStatusCollectorTest, VersionInfo) {
+  // Expect the version info to be reported by default.
+  GetStatus();
+  EXPECT_TRUE(status_.has_browser_version());
+  EXPECT_TRUE(status_.has_os_version());
+  EXPECT_TRUE(status_.has_firmware_version());
+
   // When the pref to collect this data is not enabled, expect that none of
   // the fields are present in the protobuf.
+  cros_settings_->SetBoolean(chromeos::kReportDeviceVersionInfo, false);
   GetStatus();
   EXPECT_FALSE(status_.has_browser_version());
   EXPECT_FALSE(status_.has_os_version());
   EXPECT_FALSE(status_.has_firmware_version());
 
   cros_settings_->SetBoolean(chromeos::kReportDeviceVersionInfo, true);
   GetStatus();
   EXPECT_TRUE(status_.has_browser_version());
   EXPECT_TRUE(status_.has_os_version());
   EXPECT_TRUE(status_.has_firmware_version());
@@ skipping 55 matching lines @@
 
 TEST_F(DeviceStatusCollectorTest, ReportUsers) {
   user_manager_->CreatePublicAccountUser("public@localhost");
   user_manager_->AddUser("user0@managed.com");
   user_manager_->AddUser("user1@managed.com");
   user_manager_->AddUser("user2@managed.com");
   user_manager_->AddUser("user3@unmanaged.com");
   user_manager_->AddUser("user4@managed.com");
   user_manager_->AddUser("user5@managed.com");
 
-  // Verify that users are not reported by default.
+  // Verify that users are reported by default.
   GetStatus();
-  EXPECT_EQ(0, status_.user_size());
+  EXPECT_EQ(5, status_.user_size());
 
   // Verify that users are reported after enabling the setting.
   cros_settings_->SetBoolean(chromeos::kReportDeviceUsers, true);
   GetStatus();
   EXPECT_EQ(5, status_.user_size());
   EXPECT_EQ(em::DeviceUser::USER_TYPE_MANAGED, status_.user(0).type());
   EXPECT_EQ("user0@managed.com", status_.user(0).email());
   EXPECT_EQ(em::DeviceUser::USER_TYPE_MANAGED, status_.user(1).type());
   EXPECT_EQ("user1@managed.com", status_.user(1).email());
   EXPECT_EQ(em::DeviceUser::USER_TYPE_MANAGED, status_.user(2).type());
@@ skipping 96 matching lines @@
     base::RunLoop().RunUntilIdle();
   }
 
   virtual void TearDown() OVERRIDE {
     chromeos::NetworkHandler::Shutdown();
     chromeos::DBusThreadManager::Shutdown();
   }
 };
 
 TEST_F(DeviceStatusCollectorNetworkInterfacesTest, NetworkInterfaces) {
+  // Interfaces should be reported by default.
+  GetStatus();
+  EXPECT_TRUE(status_.network_interface_size() > 0);
+
   // No interfaces should be reported if the policy is off.
+  cros_settings_->SetBoolean(chromeos::kReportDeviceNetworkInterfaces, false);
   GetStatus();
   EXPECT_EQ(0, status_.network_interface_size());
 
   // Switch the policy on and verify the interface list is present.
   cros_settings_->SetBoolean(chromeos::kReportDeviceNetworkInterfaces, true);
   GetStatus();
 
   int count = 0;
   for (size_t i = 0; i < arraysize(kFakeDevices); ++i) {
     const FakeDeviceData& dev = kFakeDevices[i];
@@ skipping 21 matching lines @@
     }
 
     EXPECT_TRUE(found_match) << "No matching interface for fake device " << i;
     count++;
   }
 
   EXPECT_EQ(count, status_.network_interface_size());
 }
 
 }  // namespace policy