arc: Support managed Arc and managed Location Service and B&R consents.

chrome/browser/chromeos/arc/arc_support_host.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 "chrome/browser/chromeos/arc/arc_support_host.h"
 
 #include <string>
 
 #include "ash/common/system/chromeos/devicetype_utils.h"
 #include "base/i18n/timezone.h"
@@ skipping 12 matching lines @@
 #include "chrome/grit/generated_resources.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/prefs/pref_service.h"
 #include "components/user_manager/known_user.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/webui/web_ui_util.h"
 #include "ui/display/screen.h"
 
 namespace {
 const char kAction[] = "action";
-const char kBackupRestoreEnabled[] = "backupRestoreEnabled";
-const char kLocationServiceEnabled[] = "locationServiceEnabled";
+const char kArcManaged[] = "arcManaged";
 const char kCanEnable[] = "canEnable";
 const char kCode[] = "code";
 const char kData[] = "data";
 const char kDeviceId[] = "deviceId";
 const char kEnabled[] = "enabled";
+const char kManaged[] = "managed";
 const char kOn[] = "on";
 const char kPage[] = "page";
 const char kStatus[] = "status";
 const char kText[] = "text";
 const char kActionInitialize[] = "initialize";
 const char kActionSetMetricsMode[] = "setMetricsMode";
+const char kActionBackupAndRestoreMode[] = "setBackupAndRestoreMode";
+const char kActionLocationServiceMode[] = "setLocationServiceMode";
 const char kActionSetWindowBounds[] = "setWindowBounds";
 const char kActionStartLso[] = "startLso";
 const char kActionCancelAuthCode[] = "cancelAuthCode";
 const char kActionSetAuthCode[] = "setAuthCode";
 const char kActionEnableMetrics[] = "enableMetrics";
 const char kActionSendFeedback[] = "sendFeedback";
 const char kActionSetBackupRestore[] = "setBackupRestore";
 const char kActionSetLocationService[] = "setLocationService";
 const char kActionCloseUI[] = "closeUI";
 const char kActionShowPage[] = "showPage";
@@ skipping 20 matching lines @@
 ArcSupportHost::ArcSupportHost() {
   arc::ArcAuthService* arc_auth_service = arc::ArcAuthService::Get();
   DCHECK(arc_auth_service);
 
   if (!arc_auth_service->IsAllowed())
     return;
 
   arc_auth_service->AddObserver(this);
   display::Screen::GetScreen()->AddObserver(this);
 
-  pref_change_registrar_.Init(g_browser_process->local_state());
-  pref_change_registrar_.Add(
+  pref_local_change_registrar_.Init(g_browser_process->local_state());
+  pref_local_change_registrar_.Add(
       metrics::prefs::kMetricsReportingEnabled,
       base::Bind(&ArcSupportHost::OnMetricsPreferenceChanged,
                  base::Unretained(this)));
+
+  pref_change_registrar_.Init(arc_auth_service->profile()->GetPrefs());
+  pref_change_registrar_.Add(
+      prefs::kArcBackupRestoreEnabled,
+      base::Bind(&ArcSupportHost::OnBackupAndRestorePreferenceChanged,
+                 base::Unretained(this)));
+  pref_change_registrar_.Add(
+      prefs::kArcLocationServiceEnabled,
+      base::Bind(&ArcSupportHost::OnLocationServicePreferenceChanged,
+                 base::Unretained(this)));
 }
 
 ArcSupportHost::~ArcSupportHost() {
   display::Screen::GetScreen()->RemoveObserver(this);
   arc::ArcAuthService* arc_auth_service = arc::ArcAuthService::Get();
   if (arc_auth_service)
     arc_auth_service->RemoveObserver(this);
 }
 
 void ArcSupportHost::Start(Client* client) {
   DCHECK(!client_);
   client_ = client;
 
   if (!Initialize()) {
     OnOptInUIClose();
     return;
   }
 
   SendMetricsMode();
+  SendBackupAndRestoreMode();
+  SendLocationServicesMode();
 
   arc::ArcAuthService* arc_auth_service = arc::ArcAuthService::Get();
   DCHECK(arc_auth_service);
   OnOptInUIShowPage(arc_auth_service->ui_page(),
                     arc_auth_service->ui_page_status());
 }
 
 bool ArcSupportHost::Initialize() {
   DCHECK(client_);
   arc::ArcAuthService* arc_auth_service = arc::ArcAuthService::Get();
@@ skipping 35 matching lines @@
       l10n_util::GetStringUTF16(IDS_ARC_OPT_IN_DIALOG_TERMS_OF_SERVICE));
   loadtime_data->SetString(
       "textBackupRestore",
       l10n_util::GetStringUTF16(IDS_ARC_OPT_IN_DIALOG_BACKUP_RESTORE));
   loadtime_data->SetString(
       "textLocationService",
       l10n_util::GetStringUTF16(IDS_ARC_OPT_IN_LOCATION_SETTING));
   loadtime_data->SetString(
       "serverError",
       l10n_util::GetStringUTF16(IDS_ARC_SERVER_COMMUNICATION_ERROR));
+  loadtime_data->SetString(
+      "controlledByPolicy",
+      l10n_util::GetStringUTF16(IDS_OPTIONS_CONTROLLED_SETTING_POLICY));
 
   const std::string& app_locale = g_browser_process->GetApplicationLocale();
   const std::string& country_code = base::CountryCodeForCurrentTimezone();
   loadtime_data->SetString("countryCode", country_code);
-
-  loadtime_data->SetBoolean(kBackupRestoreEnabled,
-                            arc_auth_service->profile()->GetPrefs()->GetBoolean(
-                                prefs::kArcBackupRestoreEnabled));
-  loadtime_data->SetBoolean(kLocationServiceEnabled,
-                            arc_auth_service->profile()->GetPrefs()->GetBoolean(
-                                prefs::kArcLocationServiceEnabled));
+  loadtime_data->SetBoolean(kArcManaged, arc_auth_service->IsArcManaged());
 
   webui::SetLoadTimeDataDefaults(app_locale, loadtime_data.get());
   DCHECK(arc_auth_service);
   const std::string device_id = user_manager::known_user::GetDeviceId(
       multi_user_util::GetAccountIdFromProfile(arc_auth_service->profile()));
   DCHECK(!device_id.empty());
 
   base::DictionaryValue request;
   std::string request_string;
   request.SetString(kAction, kActionInitialize);
@@ skipping 15 matching lines @@
   std::string request_string;
   request.SetString(kAction, kActionSetWindowBounds);
   base::JSONWriter::Write(request, &request_string);
   client_->PostMessageFromNativeHost(request_string);
 }
 
 void ArcSupportHost::OnMetricsPreferenceChanged() {
   SendMetricsMode();
 }
 
+void ArcSupportHost::OnBackupAndRestorePreferenceChanged() {
+  SendBackupAndRestoreMode();
+}
+
+void ArcSupportHost::OnLocationServicePreferenceChanged() {
+  SendLocationServicesMode();
+}
+
 void ArcSupportHost::SendMetricsMode() {
   arc::ArcAuthService* arc_auth_service = arc::ArcAuthService::Get();
   DCHECK(arc_auth_service && arc_auth_service->IsAllowed());
   const Profile* profile = arc_auth_service->profile();
 
   const bool metrics_managed = IsMetricsReportingPolicyManaged();
   const bool owner_profile =
       profile && chromeos::ProfileHelper::IsOwnerProfile(profile);
   const bool metrics_on =
       ChromeMetricsServiceAccessor::IsMetricsAndCrashReportingEnabled();
@@ skipping 11 matching lines @@
   std::string request_string;
   request.SetString(kAction, kActionSetMetricsMode);
   request.SetString(kText, l10n_util::GetStringUTF16(message_id));
   request.SetBoolean(kCanEnable,
                      !metrics_on && !metrics_managed && owner_profile);
   request.SetBoolean(kOn, metrics_on);
   base::JSONWriter::Write(request, &request_string);
   client_->PostMessageFromNativeHost(request_string);
 }
 
+void ArcSupportHost::SendOptionMode(const std::string& action_name,
+                                    const std::string& pref_name) {
+  const arc::ArcAuthService* arc_auth_service = arc::ArcAuthService::Get();
+  DCHECK(arc_auth_service);
+  const bool enabled =
+      arc_auth_service->profile()->GetPrefs()->GetBoolean(pref_name);
+  const bool managed =
+      arc_auth_service->profile()->GetPrefs()->IsManagedPreference(pref_name);
+
+  base::DictionaryValue request;
+  std::string request_string;
+  request.SetString(kAction, action_name);
+  request.SetBoolean(kEnabled, enabled);
+  request.SetBoolean(kManaged, managed);
+  base::JSONWriter::Write(request, &request_string);
+  client_->PostMessageFromNativeHost(request_string);
+}
+
+void ArcSupportHost::SendBackupAndRestoreMode() {
+  SendOptionMode(kActionBackupAndRestoreMode, prefs::kArcBackupRestoreEnabled);
+}
+
+void ArcSupportHost::SendLocationServicesMode() {
+  SendOptionMode(kActionLocationServiceMode, prefs::kArcLocationServiceEnabled);
+}
+
 void ArcSupportHost::OnOptInUIClose() {
   if (!client_)
     return;
 
   base::DictionaryValue response;
   response.SetString(kAction, kActionCloseUI);
   std::string response_string;
   base::JSONWriter::Write(response, &response_string);
   client_->PostMessageFromNativeHost(response_string);
 }
@@ skipping 84 matching lines @@
     EnableLocationService(is_enabled);
   } else {
     NOTREACHED();
   }
 }
 
 scoped_refptr<base::SingleThreadTaskRunner> ArcSupportHost::task_runner()
     const {
   return base::ThreadTaskRunnerHandle::Get();
 }