Safety check: added parsing displayed strings on the backend and split status updates

Bug: 1015841
Change-Id: I2b9db68ada58615108c459f33bcca258fb5a88d6
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2089868
Commit-Queue: Andrey Zaytsev <andzaytsev@google.com>
Reviewed-by: Vasilii Sukhanov <vasilii@chromium.org>
Cr-Commit-Position: refs/heads/master@{#748646}

chrome/browser/ui/webui/settings/safety_check_handler.cc

@@ -7,18 +7,32 @@
 #include "base/bind.h"
 #include "base/metrics/user_metrics.h"
 #include "base/metrics/user_metrics_action.h"
+#include "base/strings/string16.h"
+#include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
 #include "chrome/browser/password_manager/bulk_leak_check_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/url_constants.h"
+#include "chrome/grit/chromium_strings.h"
+#include "chrome/grit/generated_resources.h"
 #include "components/prefs/pref_service.h"
 #include "components/safe_browsing/core/common/safe_browsing_prefs.h"
+#include "ui/base/l10n/l10n_util.h"
+
+#if defined(OS_CHROMEOS)
+#include "ui/chromeos/devicetype_utils.h"
+#endif
 
 namespace {
 
 // Constants for communication with JS.
-constexpr char kStatusChanged[] = "safety-check-status-changed";
+constexpr char kUpdatesEvent[] = "safety-check-updates-status-changed";
+constexpr char kPasswordsEvent[] = "safety-check-passwords-status-changed";
+constexpr char kSafeBrowsingEvent[] =
+    "safety-check-safe-browsing-status-changed";
 constexpr char kPerformSafetyCheck[] = "performSafetyCheck";
-constexpr char kSafetyCheckComponent[] = "safetyCheckComponent";
 constexpr char kNewState[] = "newState";
+constexpr char kDisplayedString[] = "displayedString";
 constexpr char kPasswordsCompromised[] = "passwordsCompromised";
 
 // Converts the VersionUpdater::Status to the UpdateStatus enum to be passed
@@ -125,31 +139,111 @@ void SafetyCheckHandler::OnUpdateCheckResult(VersionUpdater::Status status,
                                              const base::string16& message) {
   UpdateStatus update_status = ConvertToUpdateStatus(status);
   base::DictionaryValue event;
-  event.SetIntKey(kSafetyCheckComponent,
-                  static_cast<int>(SafetyCheckComponent::kUpdates));
   event.SetIntKey(kNewState, static_cast<int>(update_status));
-  FireWebUIListener(kStatusChanged, event);
+  event.SetStringKey(kDisplayedString, GetStringForUpdates(update_status));
+  FireWebUIListener(kUpdatesEvent, event);
 }
 
 void SafetyCheckHandler::OnSafeBrowsingCheckResult(
     SafetyCheckHandler::SafeBrowsingStatus status) {
   base::DictionaryValue event;
-  event.SetIntKey(kSafetyCheckComponent,
-                  static_cast<int>(SafetyCheckComponent::kSafeBrowsing));
   event.SetIntKey(kNewState, static_cast<int>(status));
-  FireWebUIListener(kStatusChanged, event);
+  event.SetStringKey(kDisplayedString, GetStringForSafeBrowsing(status));
+  FireWebUIListener(kSafeBrowsingEvent, event);
 }
 
 void SafetyCheckHandler::OnPasswordsCheckResult(PasswordsStatus status,
                                                 int num_compromised) {
   base::DictionaryValue event;
-  event.SetIntKey(kSafetyCheckComponent,
-                  static_cast<int>(SafetyCheckComponent::kPasswords));
   event.SetIntKey(kNewState, static_cast<int>(status));
   if (status == PasswordsStatus::kCompromisedExist) {
     event.SetIntKey(kPasswordsCompromised, num_compromised);
   }
-  FireWebUIListener(kStatusChanged, event);
+  event.SetStringKey(kDisplayedString,
+                     GetStringForPasswords(status, num_compromised));
+  FireWebUIListener(kPasswordsEvent, event);
+}
+
+base::string16 SafetyCheckHandler::GetStringForUpdates(UpdateStatus status) {
+  switch (status) {
+    case UpdateStatus::kChecking:
+      return l10n_util::GetStringUTF16(IDS_SETTINGS_SAFETY_CHECK_RUNNING);
+    case UpdateStatus::kUpdated:
+#if defined(OS_CHROMEOS)
+      return ui::SubstituteChromeOSDeviceType(IDS_SETTINGS_UPGRADE_UP_TO_DATE);
+#else
+      return l10n_util::GetStringUTF16(IDS_SETTINGS_UPGRADE_UP_TO_DATE);
+#endif
+    case UpdateStatus::kUpdating:
+      return l10n_util::GetStringUTF16(IDS_SETTINGS_UPGRADE_UPDATING);
+    case UpdateStatus::kRelaunch:
+      return l10n_util::GetStringUTF16(
+          IDS_SETTINGS_UPGRADE_SUCCESSFUL_RELAUNCH);
+    case UpdateStatus::kDisabledByAdmin:
+      return l10n_util::GetStringFUTF16(
+          IDS_SETTINGS_SAFETY_CHECK_UPDATES_DISABLED_BY_ADMIN,
+          base::ASCIIToUTF16(chrome::kWhoIsMyAdministratorHelpURL));
+    case UpdateStatus::kFailedOffline:
+      return l10n_util::GetStringUTF16(
+          IDS_SETTINGS_SAFETY_CHECK_UPDATES_FAILED_OFFLINE);
+    case UpdateStatus::kFailed:
+      return l10n_util::GetStringFUTF16(
+          IDS_SETTINGS_SAFETY_CHECK_UPDATES_FAILED,
+          base::ASCIIToUTF16(chrome::kChromeFixUpdateProblems));
+  }
+}
+
+base::string16 SafetyCheckHandler::GetStringForSafeBrowsing(
+    SafeBrowsingStatus status) {
+  switch (status) {
+    case SafeBrowsingStatus::kChecking:
+      return l10n_util::GetStringUTF16(IDS_SETTINGS_SAFETY_CHECK_RUNNING);
+    case SafeBrowsingStatus::kEnabled:
+      return l10n_util::GetStringUTF16(
+          IDS_SETTINGS_SAFETY_CHECK_SAFE_BROWSING_ENABLED);
+    case SafeBrowsingStatus::kDisabled:
+      return l10n_util::GetStringUTF16(
+          IDS_SETTINGS_SAFETY_CHECK_SAFE_BROWSING_DISABLED);
+    case SafeBrowsingStatus::kDisabledByAdmin:
+      return l10n_util::GetStringFUTF16(
+          IDS_SETTINGS_SAFETY_CHECK_SAFE_BROWSING_DISABLED_BY_ADMIN,
+          base::ASCIIToUTF16(chrome::kWhoIsMyAdministratorHelpURL));
+    case SafeBrowsingStatus::kDisabledByExtension:
+      return l10n_util::GetStringUTF16(
+          IDS_SETTINGS_SAFETY_CHECK_SAFE_BROWSING_DISABLED_BY_EXTENSION);
+  }
+}
+
+base::string16 SafetyCheckHandler::GetStringForPasswords(PasswordsStatus status,
+                                                         int num_compromised) {
+  switch (status) {
+    case PasswordsStatus::kChecking:
+      return l10n_util::GetStringUTF16(IDS_SETTINGS_SAFETY_CHECK_RUNNING);
+    case PasswordsStatus::kSafe:
+      return l10n_util::GetStringUTF16(
+          IDS_SETTINGS_SAFETY_CHECK_PASSWORDS_SAFE);
+    case PasswordsStatus::kCompromisedExist:
+      return l10n_util::GetPluralStringFUTF16(
+          IDS_SETTINGS_SAFETY_CHECK_PASSWORDS_COMPROMISED, num_compromised);
+    case PasswordsStatus::kOffline:
+      return l10n_util::GetStringUTF16(
+          IDS_SETTINGS_SAFETY_CHECK_PASSWORDS_OFFLINE);
+    case PasswordsStatus::kNoPasswords:
+      return l10n_util::GetStringUTF16(
+          IDS_SETTINGS_SAFETY_CHECK_PASSWORDS_NO_PASSWORDS);
+    case PasswordsStatus::kSignedOut:
+      return l10n_util::GetStringUTF16(
+          IDS_SETTINGS_SAFETY_CHECK_PASSWORDS_SIGNED_OUT);
+    case PasswordsStatus::kQuotaLimit:
+      return l10n_util::GetStringUTF16(
+          IDS_SETTINGS_SAFETY_CHECK_PASSWORDS_QUOTA_LIMIT);
+    case PasswordsStatus::kTooManyPasswords:
+      return l10n_util::GetStringUTF16(
+          IDS_SETTINGS_SAFETY_CHECK_PASSWORDS_TOO_MANY_PASSWORDS);
+    case PasswordsStatus::kError:
+      return l10n_util::GetStringUTF16(
+          IDS_SETTINGS_SAFETY_CHECK_PASSWORDS_ERROR);
+  }
 }
 
 void SafetyCheckHandler::OnStateChanged(

chrome/browser/ui/webui/settings/safety_check_handler.h

@@ -25,14 +25,6 @@ class SafetyCheckHandler
     : public settings::SettingsPageUIHandler,
       public password_manager::BulkLeakCheckService::Observer {
  public:
-  // Used in communication with the frontend to indicate which component the
-  // communicated status update applies to.
-  enum class SafetyCheckComponent {
-    kUpdates,
-    kPasswords,
-    kSafeBrowsing,
-    kExtensions,
-  };
   // The following enums represent the state of each component of the safety
   // check and should be kept in sync with the JS frontend
   // (safety_check_browser_proxy.js).
@@ -100,11 +92,16 @@ class SafetyCheckHandler
                            const std::string& version,
                            int64_t update_size,
                            const base::string16& message);
-
   void OnSafeBrowsingCheckResult(SafeBrowsingStatus status);
-
   void OnPasswordsCheckResult(PasswordsStatus status, int num_compromised);
 
+  // Methods for building user-visible strings based on the safety check
+  // state.
+  base::string16 GetStringForUpdates(UpdateStatus status);
+  base::string16 GetStringForSafeBrowsing(SafeBrowsingStatus status);
+  base::string16 GetStringForPasswords(PasswordsStatus status,
+                                       int num_compromised);
+
   // BulkLeakCheckService::Observer implementation.
   void OnStateChanged(
       password_manager::BulkLeakCheckService::State state) override;