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 kBackupRestoreEnabled[] = "backupRestoreEnabled";
+const char kCanEnable[] = "canEnable";
 const char kCode[] = "code";
-const char kCanEnable[] = "canEnable";
-const char kStatus[] = "status";
 const char kData[] = "data";
 const char kDeviceId[] = "deviceId";
+const char kEnabled[] = "enabled";
 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 kActionStartLso[] = "startLso";
 const char kActionCancelAuthCode[] = "cancelAuthCode";
 const char kActionSetAuthCode[] = "setAuthCode";
 const char kActionEnableMetrics[] = "enableMetrics";
 const char kActionSendFeedback[] = "sendFeedback";
+const char kActionSetBackupRestore[] = "setBackupRestore";
 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("countryCode", country_code);
 
-  webui::SetLoadTimeDataDefaults(app_locale, localized_strings.get());
 
   arc::ArcAuthService* arc_auth_service = arc::ArcAuthService::Get();
+
+  localized_strings->SetBoolean(

[elijahtaylor1, 2016/06/30 01:59:06]

We want the default to be checked, and set the pref based on the result of the
checkbox when the user agrees.  We don't care about the previous state of this
pref here (or its default state).

This could be initialized in javascript and you wouldn't need
kBackupRestoreEnabled and communication of this to the support extension.

[malaykeshav, 2016/06/30 02:46:19]

What about the case where the opt-in fails. Do we not save the state when the
user retries?

[elijahtaylor1, 2016/06/30 04:52:34]

That's a good point, and I do think it's the right thing to preserve that
selection.  But we still need to change this so the default is true instead of
false, which I think is the default for an unset boolean pref.

[malaykeshav, 2016/06/30 18:25:46]

This is already set when defining the boolean preference value here:
https://codereview.chromium.org/2104893003/diff/140001/chrome/browser/chromeo...

[khmel, 2016/06/30 18:30:11]

BTW, if OptIn fails, 'Get Started' page is not shown, retry starts from LSO page

[xiyuan, 2016/06/30 18:34:22]

What about user disables ARC then re-enables it in settings? Think we should
always get the pref value to init the opt-in page to be correct.

[malaykeshav, 2016/06/30 18:50:59]

The user's choice persists across the disable-renable

[khmel, 2016/06/30 19:00:43]

I also still think that 
 pref_change_registrar_.Add(prefs::kArcBackupRestoreEnabled) might make sense

+      kBackupRestoreEnabled,
+      arc_auth_service->profile()->GetPrefs()->GetBoolean(
+          prefs::kArcBackupRestoreEnabled));
+
+  webui::SetLoadTimeDataDefaults(app_locale, localized_strings.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);
   request.Set(kData, std::move(localized_strings));
   request.SetString(kDeviceId, device_id);
@@ skipping 54 matching lines @@
 
   base::DictionaryValue response;
   response.SetString(kAction, kActionShowPage);
   response.SetInteger(kPage, static_cast<int>(page));
   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::EnableMetrics(bool is_enabled) {
+  InitiateMetricsReportingChange(is_enabled, OnMetricsReportingCallbackType());
+}
+
+void ArcSupportHost::EnableBackupRestore(bool is_enabled) {
+  PrefService* pref_service = arc::ArcAuthService::Get()->profile()->GetPrefs();
+  pref_service->SetBoolean(prefs::kArcBackupRestoreEnabled, is_enabled);
 }
 
 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;
   }
@@ skipping 12 matching lines @@
   } else if (action == kActionSetAuthCode) {
     std::string code;
     if (!request->GetString(kCode, &code)) {
       NOTREACHED();
       return;
     }
     arc_auth_service->SetAuthCodeAndStartArc(code);
   } else if (action == kActionCancelAuthCode) {
     arc_auth_service->CancelAuthCode();
   } else if (action == kActionEnableMetrics) {
-    EnableMetrics();
+    bool is_enabled;
+    if (!request->GetBoolean(kEnabled, &is_enabled)) {
+      NOTREACHED();
+      return;
+    }
+    EnableMetrics(is_enabled);
   } else if (action == kActionSendFeedback) {
     chrome::OpenFeedbackDialog(nullptr);
+  } else if (action == kActionSetBackupRestore) {
+    bool is_enabled;
+    if (!request->GetBoolean(kEnabled, &is_enabled)) {
+      NOTREACHED();
+      return;
+    }
+    EnableBackupRestore(is_enabled);
   } else {
     NOTREACHED();
   }
 }
 
 scoped_refptr<base::SingleThreadTaskRunner> ArcSupportHost::task_runner()
     const {
   return base::ThreadTaskRunnerHandle::Get();
 }