Skip ARC initial screen when everything is set up by policy

chrome/browser/chromeos/arc/arc_session_manager_unittest.cc

 // Copyright 2016 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 <memory>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/observer_list.h"
 #include "base/run_loop.h"
+#include "base/values.h"
 #include "chrome/browser/chromeos/arc/arc_optin_uma.h"
 #include "chrome/browser/chromeos/arc/arc_session_manager.h"
 #include "chrome/browser/chromeos/arc/optin/arc_terms_of_service_oobe_negotiator.h"
 #include "chrome/browser/chromeos/arc/test/arc_data_removed_waiter.h"
 #include "chrome/browser/chromeos/login/screens/arc_terms_of_service_screen_actor.h"
 #include "chrome/browser/chromeos/login/screens/arc_terms_of_service_screen_actor_observer.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host.h"
 #include "chrome/browser/chromeos/login/users/fake_chrome_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/policy/profile_policy_connector.h"
 #include "chrome/browser/policy/profile_policy_connector_factory.h"
 #include "chrome/browser/prefs/pref_service_syncable_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_list_prefs.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_session_manager_client.h"
 #include "components/arc/arc_service_manager.h"
 #include "components/arc/arc_session_runner.h"
 #include "components/arc/arc_util.h"
 #include "components/arc/test/fake_arc_session.h"
 #include "components/prefs/pref_service.h"
+#include "components/prefs/testing_pref_service.h"
 #include "components/signin/core/account_id/account_id.h"
 #include "components/sync/model/fake_sync_change_processor.h"
 #include "components/sync/model/sync_error_factory_mock.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "components/user_manager/user_manager.h"
 #include "components/user_manager/user_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
@@ skipping 380 matching lines @@
   // On error, UI to send feedback is showing. In that case,
   // the ARC is still necessary to run on background for gathering the logs.
   EXPECT_TRUE(prefs->GetBoolean(prefs::kArcSignedIn));
   EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
   EXPECT_TRUE(arc_session_manager()->IsSessionRunning());
 
   // Correctly stop service.
   arc_session_manager()->Shutdown();
 }
 
+TEST_F(ArcSessionManagerTest, SkippingTermsDueToPolicies) {
+  sync_preferences::TestingPrefServiceSyncable* const prefs =
+      profile()->GetTestingPrefService();
+
+  // Values of the ArcBackupRestoreEnabled pref to be tested.
+  const std::vector<base::Value> test_backup_pref_values = {
+      base::Value(), base::Value(false), base::Value(true)};
+  // Values of the ArcLocationServiceEnabled pref to be tested.
+  const std::vector<base::Value> test_location_pref_values = {
+      base::Value(), base::Value(false), base::Value(true)};
+
+  for (const auto& backup_pref_value : test_backup_pref_values) {
+    for (const auto& location_pref_value : test_location_pref_values) {
+      EXPECT_FALSE(prefs->GetBoolean(prefs::kArcSignedIn));
+      EXPECT_FALSE(prefs->GetBoolean(prefs::kArcTermsAccepted));
+
+      // Set ARC to be managed.
+      prefs->SetManagedPref(prefs::kArcEnabled,
+                            base::MakeUnique<base::Value>(true).release());
+
+      // Assign test values to the prefs.
+      if (backup_pref_value.is_bool()) {
+        prefs->SetManagedPref(prefs::kArcBackupRestoreEnabled,
+                              backup_pref_value.DeepCopy());
+      } else {
+        prefs->RemoveManagedPref(prefs::kArcBackupRestoreEnabled);
+      }
+      if (location_pref_value.is_bool()) {
+        prefs->SetManagedPref(prefs::kArcLocationServiceEnabled,
+                              location_pref_value.DeepCopy());
+      } else {
+        prefs->RemoveManagedPref(prefs::kArcLocationServiceEnabled);
+      }
+
+      arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
+      EXPECT_TRUE(arc_session_manager()->IsArcEnabled());
+      EXPECT_TRUE(arc_session_manager()->IsArcManaged());
+
+      // Terms of Service should be shown if either ArcBackupRestoreEnabled or
+      // ArcLocationServiceEnabled is unmanaged.
+      const ArcSessionManager::State expected_state =
+          backup_pref_value.is_bool() && location_pref_value.is_bool()
+              ? ArcSessionManager::State::ACTIVE
+              : ArcSessionManager::State::SHOWING_TERMS_OF_SERVICE;
+      EXPECT_EQ(expected_state, arc_session_manager()->state())
+          << "ArcBackupRestoreEnabled pref is " << backup_pref_value
+          << "ArcLocationServiceEnabled pref is " << location_pref_value;
+
+      // Stop ARC and shutdown the service.
+      prefs->RemoveManagedPref(prefs::kArcEnabled);
+      WaitForDataRemoved(ArcSessionManager::State::STOPPED);
+      arc_session_manager()->Shutdown();
+    }
+  }
+}
+
+TEST_F(ArcSessionManagerTest, DefaultPreferences) {
+  sync_preferences::TestingPrefServiceSyncable* const prefs =
+      profile()->GetTestingPrefService();
+
+  // Backup-restore and location-service prefs are off by default.
+  EXPECT_FALSE(prefs->GetBoolean(prefs::kArcBackupRestoreEnabled));
+  EXPECT_FALSE(prefs->GetBoolean(prefs::kArcLocationServiceEnabled));
+
+  // Set ARC to be managed, and assign managed test values to the prefs.
+  prefs->SetManagedPref(prefs::kArcEnabled,
+                        base::MakeUnique<base::Value>(true).release());
+  prefs->SetManagedPref(prefs::kArcBackupRestoreEnabled,
+                        base::MakeUnique<base::Value>(true).release());
+  prefs->SetManagedPref(prefs::kArcLocationServiceEnabled,
+                        base::MakeUnique<base::Value>(true).release());
+
+  arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
+  EXPECT_TRUE(arc_session_manager()->IsArcEnabled());
+  EXPECT_TRUE(arc_session_manager()->IsArcManaged());
+
+  // Terms of Service are skipped.
+  EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
+
+  // Unset managed values for the prefs.
+  prefs->RemoveManagedPref(prefs::kArcBackupRestoreEnabled);
+  prefs->RemoveManagedPref(prefs::kArcLocationServiceEnabled);
+
+  // Terms of Service don't get shown. The prefs return to the default false
+  // value.
+  EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
+  EXPECT_FALSE(prefs->GetBoolean(prefs::kArcBackupRestoreEnabled));
+  EXPECT_FALSE(prefs->GetBoolean(prefs::kArcLocationServiceEnabled));
+}
+
 TEST_F(ArcSessionManagerTest, DisabledForDeviceLocalAccount) {
   PrefService* const prefs = profile()->GetPrefs();
   EXPECT_FALSE(prefs->GetBoolean(prefs::kArcSignedIn));
   prefs->SetBoolean(prefs::kArcEnabled, true);
   arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
   arc_session_manager()->StartArc();
   EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
 
   // Create device local account and set it as active.
   const std::string email = "device-local-account@fake-email.com";
@@ skipping 319 matching lines @@
   MaybeWaitForDataRemoved();
   EXPECT_EQ(ArcSessionManager::State::SHOWING_TERMS_OF_SERVICE,
             arc_session_manager()->state());
   CloseLoginDisplayHost();
   ReportActorDestroyed();
   EXPECT_EQ(ArcSessionManager::State::STOPPED, arc_session_manager()->state());
   EXPECT_FALSE(!IsManagedUser() && arc_session_manager()->IsArcEnabled());
 }
 
 }  // namespace arc