Adds a new checkbox for backup and restore in opt-in flow.

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"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/metrics/chrome_metrics_service_accessor.h"
 #include "chrome/browser/metrics/metrics_reporting_state.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_util.h"
 #include "chrome/browser/ui/browser_commands.h"
+#include "chrome/common/pref_names.h"
 #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"
 
 namespace {
 const char kAction[] = "action";
 const char kCanEnable[] = "canEnable";
 const char kCode[] = "code";
 const char kCountryCode[] = "countryCode";
 const char kData[] = "data";
 const char kDeviceId[] = "deviceId";
 const char kOn[] = "on";
 const char kSilentMode[] = "silentMode";
 const char kStatus[] = "status";
 const char kPage[] = "page";
 const char kText[] = "text";
 const char kActionInitialize[] = "initialize";
 const char kActionSetMetricsMode[] = "setMetricsMode";
 const char kActionStartLso[] = "startLso";
 const char kActionCancelAuthCode[] = "cancelAuthCode";
 const char kActionSetAuthCode[] = "setAuthCode";
 const char kActionEnableMetrics[] = "enableMetrics";
 const char kActionSendFeedback[] = "sendFeedback";
+const char kActionEnableBackupRestore[] = "enableBackupRestore";
 const char kActionCloseUI[] = "closeUI";
 const char kActionShowPage[] = "showPage";
 }  // namespace
 
 // static
 const char ArcSupportHost::kHostName[] = "com.google.arc_support";
 
 // static
 const char ArcSupportHost::kHostAppId[] = "cnbgggchhmkkdmeppjobngjoejnihlei";
 
@@ skipping 35 matching lines @@
   SendMetricsMode();
 
   arc::ArcAuthService* arc_auth_service = arc::ArcAuthService::Get();
   DCHECK(arc_auth_service);
   OnOptInUIShowPage(arc_auth_service->ui_page(),
                     arc_auth_service->ui_page_status());
 }
 
 void ArcSupportHost::Initialize() {
   DCHECK(client_);
-
   std::unique_ptr<base::DictionaryValue> localized_strings(
       new base::DictionaryValue());
   base::string16 device_name = ash::GetChromeOSDeviceName();
   localized_strings->SetString(
       "greetingHeader",
       l10n_util::GetStringFUTF16(IDS_ARC_OPT_IN_DIALOG_HEADER, device_name));
   localized_strings->SetString(
       "greetingDescription",
       l10n_util::GetStringFUTF16(IDS_ARC_OPT_IN_DIALOG_DESCRIPTION,
                                  device_name));
@@ skipping 14 matching lines @@
       l10n_util::GetStringUTF16(IDS_ARC_OPT_IN_DIALOG_PROGRESS_LSO));
   localized_strings->SetString(
       "progressAndroidLoading",
       l10n_util::GetStringUTF16(IDS_ARC_OPT_IN_DIALOG_PROGRESS_ANDROID));
   localized_strings->SetString(
       "authorizationFailed",
       l10n_util::GetStringUTF16(IDS_ARC_OPT_IN_DIALOG_AUTHORIZATION_FAILED));
   localized_strings->SetString(
       "termsOfService",
       l10n_util::GetStringUTF16(IDS_ARC_OPT_IN_DIALOG_TERMS_OF_SERVICE));
+  localized_strings->SetString(
+      "textBackupRestore",
+      l10n_util::GetStringUTF16(IDS_ARC_OPT_IN_DIALOG_BACKUP_RESTORE));
 
   const std::string& app_locale = g_browser_process->GetApplicationLocale();
   const std::string& country_code = base::CountryCodeForCurrentTimezone();
   localized_strings->SetString(kCountryCode, country_code);
 
   webui::SetLoadTimeDataDefaults(app_locale, localized_strings.get());
 
   arc::ArcAuthService* arc_auth_service = arc::ArcAuthService::Get();
   DCHECK(arc_auth_service);
   const std::string device_id = user_manager::known_user::GetDeviceId(
@@ skipping 68 matching lines @@
   response.SetString(kStatus, status);
   std::string response_string;
   base::JSONWriter::Write(response, &response_string);
   client_->PostMessageFromNativeHost(response_string);
 }
 
 void ArcSupportHost::EnableMetrics() {
   InitiateMetricsReportingChange(true, OnMetricsReportingCallbackType());
 }
 
+void ArcSupportHost::EnableBackupRestore() {
+  PrefService* pref_service = arc::ArcAuthService::Get()->profile()->GetPrefs();
+  pref_service->SetBoolean(prefs::kArcBackupRestoreEnabled, true);
+}
+
 void ArcSupportHost::OnMessage(const std::string& request_string) {
   std::unique_ptr<base::Value> request_value =
       base::JSONReader::Read(request_string);
   base::DictionaryValue* request;
   if (!request_value || !request_value->GetAsDictionary(&request)) {
     NOTREACHED();
     return;
   }
 
   std::string action;
@@ skipping 13 matching lines @@
       NOTREACHED();
       return;
     }
     arc_auth_service->SetAuthCodeAndStartArc(code);
   } else if (action == kActionCancelAuthCode) {
     arc_auth_service->CancelAuthCode();
   } else if (action == kActionEnableMetrics) {
     EnableMetrics();
   } else if (action == kActionSendFeedback) {
     chrome::OpenFeedbackDialog(nullptr);
+  } else if (action == kActionEnableBackupRestore) {
+    EnableBackupRestore();
   } else {
     NOTREACHED();
   }
 }
 
 scoped_refptr<base::SingleThreadTaskRunner> ArcSupportHost::task_runner()
     const {
   return base::ThreadTaskRunnerHandle::Get();
 }