Implemented DeviceStatusCollector::GetDeviceSessionStatus()

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"
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chromeos/login/users/mock_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
+#include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/stub_enterprise_install_attributes.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #include "chrome/browser/chromeos/settings/stub_cros_settings_provider.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chromeos/dbus/cros_disks_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_ipconfig_client.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "chromeos/disks/disk_mount_manager.h"
 #include "chromeos/disks/mock_disk_mount_manager.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "chromeos/settings/cros_settings_provider.h"
 #include "chromeos/system/fake_statistics_provider.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/geolocation_provider.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_utils.h"
 #include "policy/proto/device_management_backend.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
+using ::testing::Return;
 using ::testing::ReturnRef;
 using base::Time;
 using base::TimeDelta;
 using chromeos::disks::DiskMountManager;
 
 namespace em = enterprise_management;
 
 namespace {
 
 const int64 kMillisecondsPerDay = Time::kMicrosecondsPerDay / 1000;
+const char kKioskAccountId[] = "kiosk_user@localhost";
+const char kKioskAppId[] = "kiosk_app_id";
 
 scoped_ptr<content::Geoposition> mock_position_to_return_next;
 
 void SetMockPositionToReturnNext(const content::Geoposition &position) {
   mock_position_to_return_next.reset(new content::Geoposition(position));
 }
 
 void MockPositionUpdateRequester(
     const content::GeolocationProvider::LocationUpdateCallback& callback) {
   if (!mock_position_to_return_next.get())
@@ skipping 16 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),
-        kiosk_mode_(false) {
+          volume_info_fetcher) {
+
     // 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;
+  void set_kiosk_account(scoped_ptr<policy::DeviceLocalAccount> account) {
+    kiosk_account_ = account.Pass();
   }
 
-  bool IsAutoLaunchedKioskSession() override {
-    return kiosk_mode_;
+  scoped_ptr<policy::DeviceLocalAccount>
+  GetAutoLaunchedKioskSessionInfo() override {
+    if (kiosk_account_)
+      return make_scoped_ptr(new policy::DeviceLocalAccount(*kiosk_account_));
+    return scoped_ptr<policy::DeviceLocalAccount>();
+  }
+
+  std::string GetAppVersion(const std::string& app_id) override {
+    // Just return the app_id as the version - this makes it easy for tests
+    // to confirm that the correct app's version was requested.
+    return app_id;
   }
 
   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:
@@ skipping 16 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_;
+  scoped_ptr<policy::DeviceLocalAccount> kiosk_account_;
 };
 
 // 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 37 matching lines @@
  public:
   DeviceStatusCollectorTest()
     : ui_thread_(content::BrowserThread::UI, &message_loop_),
       file_thread_(content::BrowserThread::FILE, &message_loop_),
       io_thread_(content::BrowserThread::IO, &message_loop_),
       install_attributes_("managed.com",
                           "user@managed.com",
                           "device_id",
                           DEVICE_MODE_ENTERPRISE),
       user_manager_(new chromeos::MockUserManager()),
-      user_manager_enabler_(user_manager_) {
+      user_manager_enabler_(user_manager_),
+      fake_device_local_account_(
+          policy::DeviceLocalAccount::TYPE_KIOSK_APP,
+          kKioskAccountId,
+          kKioskAppId,
+          std::string() /* kiosk_app_update_url */) {
     // Run this test with a well-known timezone so that Time::LocalMidnight()
     // returns the same values on all machines.
     scoped_ptr<base::Environment> env(base::Environment::Create());
     env->SetVar("TZ", "UTC");
 
     // Initialize our mock mounted disk volumes.
     scoped_ptr<chromeos::disks::MockDiskMountManager> mock_disk_mount_manager =
         make_scoped_ptr(new chromeos::disks::MockDiskMountManager());
     AddMountPoint("/mount/volume1");
     AddMountPoint("/mount/volume2");
@@ skipping 90 matching lines @@
 
   void CheckThatALocationErrorIsReported() {
     GetStatus();
     EXPECT_TRUE(status_.has_device_location());
     em::DeviceLocation location = status_.device_location();
     EXPECT_TRUE(location.has_error_code());
     EXPECT_EQ(em::DeviceLocation::ERROR_CODE_POSITION_UNAVAILABLE,
               location.error_code());
   }
 
+  void MockRunningKioskApp(const DeviceLocalAccount& account) {
+    std::vector<DeviceLocalAccount> accounts;
+    accounts.push_back(account);
+    SetDeviceLocalAccounts(cros_settings_, accounts);
+    user_manager_->CreateKioskAppUser(account.user_id);
+    EXPECT_CALL(*user_manager_, IsLoggedInAsKioskApp()).WillRepeatedly(
+        Return(true));
+  }
+
  protected:
   // Convenience method.
   int64 ActivePeriodMilliseconds() {
     return policy::DeviceStatusCollector::kIdlePollIntervalSeconds * 1000;
   }
 
   // Since this is a unit test running in browser_tests we must do additional
   // unit test setup and make a TestingBrowserProcess. Must be first member.
   TestingBrowserProcessInitializer initializer_;
   base::MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
   content::TestBrowserThread io_thread_;
 
   ScopedStubEnterpriseInstallAttributes install_attributes_;
   TestingPrefServiceSimple prefs_;
   chromeos::system::ScopedFakeStatisticsProvider fake_statistics_provider_;
   DiskMountManager::MountPointMap mount_point_map_;
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
   chromeos::CrosSettings* cros_settings_;
   chromeos::CrosSettingsProvider* device_settings_provider_;
   chromeos::StubCrosSettingsProvider stub_settings_provider_;
   chromeos::MockUserManager* user_manager_;
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
   em::DeviceStatusReportRequest status_;
   scoped_ptr<TestingDeviceStatusCollector> status_collector_;
+  const policy::DeviceLocalAccount fake_device_local_account_;
 };
 
 TEST_F(DeviceStatusCollectorTest, AllIdle) {
   ui::IdleState test_states[] = {
     ui::IDLE_STATE_IDLE,
     ui::IDLE_STATE_IDLE,
     ui::IDLE_STATE_IDLE
   };
   cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, true);
 
@@ skipping 454 matching lines @@
             status_.cpu_utilization_pct().size());
   for (const auto utilization : status_.cpu_utilization_pct())
     EXPECT_EQ(idle_cpu_usage, utilization);
 
   // Turning off hardware reporting should not report CPU utilization.
   cros_settings_->SetBoolean(chromeos::kReportDeviceHardwareStatus, false);
   GetStatus();
   EXPECT_EQ(0, status_.cpu_utilization_pct().size());
 }
 
+TEST_F(DeviceStatusCollectorTest, NoSessionStatusIfNotKioskMode) {
+  // Should not report session status if we don't have an active kiosk app.
+  cros_settings_->SetBoolean(chromeos::kReportDeviceSessionStatus, true);
+  em::SessionStatusReportRequest session_status;
+  EXPECT_FALSE(status_collector_->GetDeviceSessionStatus(&session_status));
+}
+
+TEST_F(DeviceStatusCollectorTest, NoSessionStatusIfSessionReportingDisabled) {
+  // Should not report session status if session status reporting is disabled.
+  cros_settings_->SetBoolean(chromeos::kReportDeviceSessionStatus, false);
+  status_collector_->set_kiosk_account(make_scoped_ptr(
+      new policy::DeviceLocalAccount(fake_device_local_account_)).Pass());
+  // Set up a device-local account for single-app kiosk mode.
+  MockRunningKioskApp(fake_device_local_account_);
+
+  em::SessionStatusReportRequest session_status;
+  EXPECT_FALSE(status_collector_->GetDeviceSessionStatus(&session_status));
+}
+
+TEST_F(DeviceStatusCollectorTest, ReportSessionStatus) {
+  cros_settings_->SetBoolean(chromeos::kReportDeviceSessionStatus, true);
+  status_collector_->set_kiosk_account(make_scoped_ptr(
+      new policy::DeviceLocalAccount(fake_device_local_account_)).Pass());
+
+  // Set up a device-local account for single-app kiosk mode.
+  MockRunningKioskApp(fake_device_local_account_);
+
+  em::SessionStatusReportRequest session_status;
+  EXPECT_TRUE(status_collector_->GetDeviceSessionStatus(&session_status));
+  ASSERT_EQ(1, session_status.installed_apps_size());
+  EXPECT_EQ(kKioskAccountId, session_status.device_local_account_id());
+  const em::AppStatus app = session_status.installed_apps(0);
+  EXPECT_EQ(kKioskAppId, app.app_id());
+  // Test code just sets the version to the app ID.
+  EXPECT_EQ(kKioskAppId, app.extension_version());
+  EXPECT_FALSE(app.has_status());
+  EXPECT_FALSE(app.has_error());
+}
+
 // Fake device state.
 struct FakeDeviceData {
   const char* device_path;
   const char* type;
   const char* object_path;
   const char* mac_address;
   const char* meid;
   const char* imei;
   int expected_type;  // proto enum type value, -1 for not present.
 };
@@ skipping 185 matching lines @@
 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);
+  status_collector_->set_kiosk_account(make_scoped_ptr(
+      new policy::DeviceLocalAccount(fake_device_local_account_)).Pass());
 
   // 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());
@@ skipping 57 matching lines @@
         found_match = true;
         break;
       }
     }
     EXPECT_TRUE(found_match) << "No matching state for fake network "
                              << " (" << state.name << ")";
   }
 }
 
 }  // namespace policy