Re-sort preference update protocol between Chrome and ArcSupport.

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 13 matching lines @@
 #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 {
 constexpr char kAction[] = "action";
 constexpr char kArcManaged[] = "arcManaged";
-constexpr char kCanEnable[] = "canEnable";
 constexpr char kData[] = "data";
 constexpr char kDeviceId[] = "deviceId";
-constexpr char kEnabled[] = "enabled";
-constexpr char kManaged[] = "managed";
-constexpr char kOn[] = "on";
 constexpr char kPage[] = "page";
 constexpr char kStatus[] = "status";
-constexpr char kText[] = "text";
 constexpr char kActionInitialize[] = "initialize";
 constexpr char kActionSetMetricsMode[] = "setMetricsMode";
 constexpr char kActionBackupAndRestoreMode[] = "setBackupAndRestoreMode";
 constexpr char kActionLocationServiceMode[] = "setLocationServiceMode";
 constexpr char kActionSetWindowBounds[] = "setWindowBounds";
 constexpr char kActionCloseWindow[] = "closeWindow";
 constexpr char kActionShowPage[] = "showPage";
 
+// The preference update should have those two fields.
+constexpr char kEnabled[] = "enabled";
+constexpr char kManaged[] = "managed";
+
 // The JSON data sent from the extension should have at least "event" field.
 // Each event data is defined below.
 // The key of the event type.
 constexpr char kEvent[] = "event";
 
 // "onWindowClosed" is fired when the extension window is closed.
 // No data will be provided.
 constexpr char kEventOnWindowClosed[] = "onWindowClosed";
 
 // "onAuthSucceeded" is fired when successfully done to LSO authorization in
@@ skipping 133 matching lines @@
   loadtime_data->SetString(
       "progressAndroidLoading",
       l10n_util::GetStringUTF16(IDS_ARC_OPT_IN_DIALOG_PROGRESS_ANDROID));
   loadtime_data->SetString(
       "authorizationFailed",
       l10n_util::GetStringUTF16(IDS_ARC_OPT_IN_DIALOG_AUTHORIZATION_FAILED));
   loadtime_data->SetString(
       "termsOfService",
       l10n_util::GetStringUTF16(IDS_ARC_OPT_IN_DIALOG_TERMS_OF_SERVICE));
   loadtime_data->SetString(
+      "textMetricsEnabled",
+      l10n_util::GetStringUTF16(IDS_ARC_OPT_IN_DIALOG_METRICS_ENABLED));
+  loadtime_data->SetString(
+      "textMetricsDisabled",
+      l10n_util::GetStringUTF16(IDS_ARC_OPT_IN_DIALOG_METRICS_DISABLED));
+  loadtime_data->SetString(
+      "textMetricsManagedEnabled",
+      l10n_util::GetStringUTF16(IDS_ARC_OPT_IN_DIALOG_METRICS_MANAGED_ENABLED));
+  loadtime_data->SetString("textMetricsManagedDisabled",
+                           l10n_util::GetStringUTF16(
+                               IDS_ARC_OPT_IN_DIALOG_METRICS_MANAGED_DISABLED));
+  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",
@@ skipping 14 matching lines @@
   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(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());
+  loadtime_data->SetBoolean(
+      "isOwnerProfile",
+      chromeos::ProfileHelper::IsOwnerProfile(arc_auth_service->profile()));
 
   base::DictionaryValue request;
   std::string request_string;
   request.SetString(kAction, kActionInitialize);
   request.Set(kData, std::move(loadtime_data));
   request.SetString(kDeviceId, device_id);
   base::JSONWriter::Write(request, &request_string);
   client_->PostMessageFromNativeHost(request_string);
 
   return true;
@@ skipping 18 matching lines @@
 
 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();
-
-  int message_id;
-  if (metrics_managed || !owner_profile) {
-    message_id = metrics_on ? IDS_ARC_OPT_IN_DIALOG_METRICS_MANAGED_ENABLED
-                            : IDS_ARC_OPT_IN_DIALOG_METRICS_MANAGED_DISABLED;
-  } else {
-    message_id = metrics_on ? IDS_ARC_OPT_IN_DIALOG_METRICS_ENABLED
-                            : IDS_ARC_OPT_IN_DIALOG_METRICS_DISABLED;
-  }
-
-  base::DictionaryValue request;
-  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);
+  SendPreferenceUpdate(
+      kActionSetMetricsMode,
+      ChromeMetricsServiceAccessor::IsMetricsAndCrashReportingEnabled(),
+      IsMetricsReportingPolicyManaged());
 }
 
 void ArcSupportHost::SendBackupAndRestoreMode() {
   SendOptionMode(kActionBackupAndRestoreMode, prefs::kArcBackupRestoreEnabled);
 }
 
 void ArcSupportHost::SendLocationServicesMode() {
   SendOptionMode(kActionLocationServiceMode, prefs::kArcLocationServiceEnabled);
 }
 
+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);
+  SendPreferenceUpdate(
+      action_name,
+      arc_auth_service->profile()->GetPrefs()->GetBoolean(pref_name),
+      arc_auth_service->profile()->GetPrefs()->IsManagedPreference(pref_name));
+}
+
+void ArcSupportHost::SendPreferenceUpdate(const std::string& action_name,
+                                          bool is_enabled,
+                                          bool is_managed) {
+  base::DictionaryValue request;
+  std::string request_string;
+  request.SetString(kAction, action_name);
+  request.SetBoolean(kEnabled, is_enabled);
+  request.SetBoolean(kManaged, is_managed);
+  base::JSONWriter::Write(request, &request_string);
+  client_->PostMessageFromNativeHost(request_string);
+}
+
 void ArcSupportHost::OnOptInUIClose() {
   Close();
 }
 
 void ArcSupportHost::OnOptInUIShowPage(arc::ArcAuthService::UIPage page,
                                        const base::string16& status) {
   if (!client_)
     return;
 
   base::DictionaryValue response;
@@ skipping 73 matching lines @@
   } else {
     LOG(ERROR) << "Unknown message: " << message_string;
     NOTREACHED();
   }
 }
 
 scoped_refptr<base::SingleThreadTaskRunner> ArcSupportHost::task_runner()
     const {
   return base::ThreadTaskRunnerHandle::Get();
 }