Create policy ReportArcStatus

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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/environment.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/test/scoped_path_override.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_data.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
+#include "chrome/browser/chromeos/arc/arc_auth_service.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/ownership/fake_owner_settings_service.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/settings/scoped_cros_settings_test_helper.h"
 #include "chrome/browser/chromeos/settings/stub_install_attributes.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
@@ skipping 33 matching lines @@
 
 namespace em = enterprise_management;
 
 namespace {
 
 const int64_t kMillisecondsPerDay = Time::kMicrosecondsPerDay / 1000;
 const char kKioskAccountId[] = "kiosk_user@localhost";
 const char kKioskAppId[] = "kiosk_app_id";
 const char kExternalMountPoint[] = "/a/b/c";
 const char kPublicAccountId[] = "public_user@localhost";
+const std::string kArcStatus = "{\"applications\":[ { "

[bartfab (slow), 2016/10/13 13:18:04]

Nit: You are adding static initializers, which are forbidden in Chrome code.
String constants should be char[] instead.

[phweiss, 2016/10/13 13:28:25]

Done.

+    "\"packageName\":\"com.android.providers.telephony\","
+    "\"versionName\":\"6.0.1\","
+    "\"permissions\": [\"android.permission.INTERNET\"] }],"
+    "\"userEmail\":\"xxx@google.com\"}";
+const std::string kDroidGuardInfo = "{\"droid_guard_info\":42}";
 
 class TestingDeviceStatusCollector : public policy::DeviceStatusCollector {
  public:
   TestingDeviceStatusCollector(
       PrefService* local_state,
       chromeos::system::StatisticsProvider* provider,
       const policy::DeviceStatusCollector::VolumeInfoFetcher&
           volume_info_fetcher,
       const policy::DeviceStatusCollector::CPUStatisticsFetcher& cpu_fetcher,
       const policy::DeviceStatusCollector::CPUTempFetcher& cpu_temp_fetcher,
@@ skipping 125 matching lines @@
   return std::vector<em::CPUTempInfo>();
 }
 
 void CallAndroidStatusReceiver(
     const policy::DeviceStatusCollector::AndroidStatusReceiver& receiver,
     mojo::String status,
     mojo::String droid_guard_info) {
   receiver.Run(status, droid_guard_info);
 }
 
+bool GetFakeAndroidStatus(
+    mojo::String status,
+    mojo::String droid_guard_info,
+    const policy::DeviceStatusCollector::AndroidStatusReceiver& receiver) {
+  // Post it to the thread because this call is expected to be asynchronous.
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&CallAndroidStatusReceiver, receiver,
+          status, droid_guard_info));
+  return true;
+}
+
 bool GetEmptyAndroidStatus(
     const policy::DeviceStatusCollector::AndroidStatusReceiver& receiver) {
   // Post it to the thread because this call is expected to be asynchronous.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&CallAndroidStatusReceiver, receiver, "", ""));
   return true;
 }
 
 std::vector<em::CPUTempInfo> GetFakeCPUTempInfo(
     const std::vector<em::CPUTempInfo>& cpu_temp_info) {
@@ skipping 737 matching lines @@
     EXPECT_TRUE(found) << "No matching CPUTempInfo for "
                        << expected_info.cpu_label();
   }
 
   // Now turn off hardware status reporting - should have no data.
   settings_helper_.SetBoolean(chromeos::kReportDeviceHardwareStatus, false);
   GetStatus();
   EXPECT_EQ(0, device_status_.cpu_temp_info_size());
 }
 
-TEST_F(DeviceStatusCollectorTest, NoSessionStatusIfNotKioskMode) {
+TEST_F(DeviceStatusCollectorTest, TestAndroidReporting) {
+  RestartStatusCollector(base::Bind(&GetEmptyVolumeInfo),
+                         base::Bind(&GetEmptyCPUStatistics),
+                         base::Bind(&GetEmptyCPUTempInfo),
+                         base::Bind(&GetFakeAndroidStatus, kArcStatus,
+                             kDroidGuardInfo));
+  GetStatus();
+  EXPECT_EQ(kArcStatus, session_status_.android_status().status_payload());
+  EXPECT_EQ(kDroidGuardInfo,
+      session_status_.android_status().droid_guard_info());
+}
+
+TEST_F(DeviceStatusCollectorTest, NoAndroidReportingWhenDisabled) {
+  RestartStatusCollector(base::Bind(&GetEmptyVolumeInfo),
+                         base::Bind(&GetEmptyCPUStatistics),
+                         base::Bind(&GetEmptyCPUTempInfo),
+                         base::Bind(&GetFakeAndroidStatus, kArcStatus,
+                             kDroidGuardInfo));
+
+  prefs_.SetBoolean(prefs::kReportArcStatus, false);
+  // Mock Kiosk app, so some session status is reported
+  status_collector_->set_kiosk_account(
+      base::MakeUnique<DeviceLocalAccount>(fake_device_local_account_));
+  MockRunningKioskApp(fake_device_local_account_);
+
+  GetStatus();
+  EXPECT_TRUE(got_session_status_);
+  EXPECT_FALSE(session_status_.has_android_status());
+}
+
+TEST_F(DeviceStatusCollectorTest, NoSessionStatusIfNotKioskAndNoArcReporting) {
   // Should not report session status if we don't have an active kiosk app.
   settings_helper_.SetBoolean(chromeos::kReportDeviceSessionStatus, true);
+  prefs_.SetBoolean(prefs::kReportArcStatus, false);
   GetStatus();
   EXPECT_FALSE(got_session_status_);
 }
 
 TEST_F(DeviceStatusCollectorTest, NoSessionStatusIfSessionReportingDisabled) {
   // Should not report session status if session status reporting is disabled.
   settings_helper_.SetBoolean(chromeos::kReportDeviceSessionStatus, false);
+  // ReportDeviceSessionStatus only controls Kiosk reporting, ARC reporting
+  // has to be disabled serarately.
+  prefs_.SetBoolean(prefs::kReportArcStatus, false);
   status_collector_->set_kiosk_account(
       base::MakeUnique<policy::DeviceLocalAccount>(fake_device_local_account_));
   // Set up a device-local account for single-app kiosk mode.
   MockRunningKioskApp(fake_device_local_account_);
 
   GetStatus();
   EXPECT_FALSE(got_session_status_);
 }
 
 TEST_F(DeviceStatusCollectorTest, ReportSessionStatus) {
@@ skipping 430 matching lines @@
       AccountId::FromUserEmail(kPublicAccountId));
   EXPECT_CALL(*user_manager_, IsLoggedInAsPublicAccount())
       .WillRepeatedly(Return(true));
 
   settings_helper_.SetBoolean(chromeos::kReportDeviceNetworkInterfaces, true);
   GetStatus();
   VerifyNetworkReporting();
 }
 
 }  // namespace policy