WIP

chrome/browser/chromeos/arc/arc_auth_service.cc

 // Copyright 2015 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_auth_service.h"
 
 #include <utility>
 
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/wm_shell.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/strings/string16.h"
 #include "base/time/time.h"
 #include "chrome/browser/chromeos/arc/arc_auth_code_fetcher.h"
 #include "chrome/browser/chromeos/arc/arc_auth_context.h"
 #include "chrome/browser/chromeos/arc/arc_auth_notification.h"
 #include "chrome/browser/chromeos/arc/arc_optin_uma.h"
 #include "chrome/browser/chromeos/arc/arc_support_host.h"
+#include "chrome/browser/chromeos/arc/optin/arc_optin_preference_handler.h"
 #include "chrome/browser/chromeos/arc/policy/arc_android_management_checker.h"
 #include "chrome/browser/chromeos/arc/policy/arc_policy_util.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
-#include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/policy/profile_policy_connector.h"
 #include "chrome/browser/policy/profile_policy_connector_factory.h"
 #include "chrome/browser/prefs/pref_service_syncable_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_launcher.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_utils.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_util.h"
-#include "chrome/browser/ui/extensions/app_launch_params.h"
-#include "chrome/browser/ui/extensions/application_launch.h"
+#include "chrome/browser/ui/browser_commands.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/sync_preferences/pref_service_syncable.h"
 #include "components/user_manager/user.h"
 #include "content/public/browser/browser_thread.h"
-#include "extensions/browser/app_window/app_window_registry.h"
 #include "extensions/browser/extension_prefs.h"
-#include "extensions/browser/extension_registry.h"
-#include "ui/base/l10n/l10n_util.h"
 
 namespace arc {
 
 namespace {
 
 // Weak pointer.  This class is owned by ArcServiceManager.
 ArcAuthService* g_arc_auth_service = nullptr;
 
 // Skip creating UI in unit tests
 bool g_disable_ui_for_testing = false;
 
 // Use specified ash::ShelfDelegate for unit tests.
 ash::ShelfDelegate* g_shelf_delegate_for_testing = nullptr;
 
 // The Android management check is disabled by default, it's used only for
 // testing.
 bool g_enable_check_android_management_for_testing = false;
 
 // Maximum amount of time we'll wait for ARC to finish booting up. Once this
 // timeout expires, keep ARC running in case the user wants to file feedback,
 // but present the UI to try again.
 constexpr base::TimeDelta kArcSignInTimeout = base::TimeDelta::FromMinutes(5);
 
+using ErrorType = ArcSupportHost::ErrorType;
+using UIPage = ArcSupportHost::UIPage;
+
 ash::ShelfDelegate* GetShelfDelegate() {
   if (g_shelf_delegate_for_testing)
     return g_shelf_delegate_for_testing;
   if (ash::WmShell::HasInstance()) {
     DCHECK(ash::WmShell::Get()->shelf_delegate());
     return ash::WmShell::Get()->shelf_delegate();
   }
   return nullptr;
 }
 
@@ skipping 287 matching lines @@
   DCHECK_EQ(state_, State::ACTIVE);
   DCHECK(!sign_in_time_.is_null());
 
   arc_sign_in_timer_.Stop();
 
   UpdateProvisioningTiming(base::Time::Now() - sign_in_time_, false,
                            policy_util::IsAccountManaged(profile_));
   UpdateOptInCancelUMA(OptInCancelReason::CLOUD_PROVISION_FLOW_FAIL);
   UpdateProvisioningResultUMA(result, policy_util::IsAccountManaged(profile_));
 
-  int error_message_id;
+  ErrorType error_type;
   switch (result) {
     case ProvisioningResult::GMS_NETWORK_ERROR:
-      error_message_id = IDS_ARC_SIGN_IN_NETWORK_ERROR;
+      error_type = ErrorType::SIGN_IN_NETWORK_ERROR;
       break;
     case ProvisioningResult::GMS_SERVICE_UNAVAILABLE:
     case ProvisioningResult::GMS_SIGN_IN_FAILED:
     case ProvisioningResult::GMS_SIGN_IN_TIMEOUT:
     case ProvisioningResult::GMS_SIGN_IN_INTERNAL_ERROR:
-      error_message_id = IDS_ARC_SIGN_IN_SERVICE_UNAVAILABLE_ERROR;
+      error_type = ErrorType::SIGN_IN_SERVICE_UNAVAILABLE_ERROR;
       break;
     case ProvisioningResult::GMS_BAD_AUTHENTICATION:
-      error_message_id = IDS_ARC_SIGN_IN_BAD_AUTHENTICATION_ERROR;
+      error_type = ErrorType::SIGN_IN_BAD_AUTHENTICATION_ERROR;
       break;
     case ProvisioningResult::DEVICE_CHECK_IN_FAILED:
     case ProvisioningResult::DEVICE_CHECK_IN_TIMEOUT:
     case ProvisioningResult::DEVICE_CHECK_IN_INTERNAL_ERROR:
-      error_message_id = IDS_ARC_SIGN_IN_GMS_NOT_AVAILABLE_ERROR;
+      error_type = ErrorType::SIGN_IN_GMS_NOT_AVAILABLE_ERROR;
       break;
     case ProvisioningResult::CLOUD_PROVISION_FLOW_FAILED:
     case ProvisioningResult::CLOUD_PROVISION_FLOW_TIMEOUT:
     case ProvisioningResult::CLOUD_PROVISION_FLOW_INTERNAL_ERROR:
-      error_message_id = IDS_ARC_SIGN_IN_CLOUD_PROVISION_FLOW_FAIL_ERROR;
+      error_type = ErrorType::SIGN_IN_CLOUD_PROVISION_FLOW_FAIL_ERROR;
       break;
     default:
-      error_message_id = IDS_ARC_SIGN_IN_UNKNOWN_ERROR;
+      error_type = ErrorType::SIGN_IN_UNKNOWN_ERROR;
       break;
   }
 
   if (result == ProvisioningResult::ARC_STOPPED) {
     if (profile_->GetPrefs()->HasPrefPath(prefs::kArcSignedIn))
       profile_->GetPrefs()->SetBoolean(prefs::kArcSignedIn, false);
-    ShutdownBridgeAndShowUI(UIPage::ERROR,
-                            l10n_util::GetStringUTF16(error_message_id));
+    ShutdownBridge();
+    if (support_host_)
+      support_host_->ShowErrorPage(error_type, false);
     return;
   }
 
   if (result == ProvisioningResult::CLOUD_PROVISION_FLOW_FAILED ||
       result == ProvisioningResult::CLOUD_PROVISION_FLOW_TIMEOUT ||
       result == ProvisioningResult::CLOUD_PROVISION_FLOW_INTERNAL_ERROR ||
       // OVERALL_SIGN_IN_TIMEOUT might be an indication that ARC believes it is
       // fully setup, but Chrome does not.
       result == ProvisioningResult::OVERALL_SIGN_IN_TIMEOUT ||
       // Just to be safe, remove data if we don't know the cause.
       result == ProvisioningResult::UNKNOWN_ERROR) {
     RemoveArcData();
   }
 
   // We'll delay shutting down the bridge in this case to allow people to send
   // feedback.
-  ShowUI(UIPage::ERROR_WITH_FEEDBACK,
-         l10n_util::GetStringUTF16(error_message_id));
+  if (support_host_)
+    support_host_->ShowErrorPage(error_type, true /* show feedback button */);
 }
 
 void ArcAuthService::GetIsAccountManaged(
     const GetIsAccountManagedCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   callback.Run(policy_util::IsAccountManaged(profile_));
 }
 
 void ArcAuthService::SetState(State state) {
@@ skipping 24 matching lines @@
       policy_util::IsAccountManaged(profile)) {
     VLOG(2) << "Enterprise users are not supported in ARC.";
     return;
   }
 
   profile_ = profile;
   // Create the support host at initialization. Note that, practically,
   // ARC support Chrome app is rarely used (only opt-in and re-auth flow).
   // So, it may be better to initialize it lazily.
   // TODO(hidehiko): Revisit to think about lazy initialization.
-  support_host_.reset(new ArcSupportHost());
+  if (!g_disable_ui_for_testing && !IsOptInVerificationDisabled()) {
+    LOG(ERROR) << "HOGEHOGE";
+    support_host_.reset(new ArcSupportHost(profile_));
+    support_host_->set_observer(this);
+  }
   SetState(State::STOPPED);
 
+  preference_handler_ = base::MakeUnique<arc::ArcOptInPreferenceHandler>(
+      this, profile_->GetPrefs());
+  // This automatically updates all preferences.
+  preference_handler_->Start();
+
   PrefServiceSyncableFromProfile(profile_)->AddSyncedPrefObserver(
       prefs::kArcEnabled, this);
 
   context_.reset(new ArcAuthContext(this, profile_));
 
   // In case UI is disabled we assume that ARC is opted-in.
   if (IsOptInVerificationDisabled()) {
     auth_code_.clear();
     StartArc();
     return;
@@ skipping 28 matching lines @@
   if (IsArcEnabled())
     OnOptInPreferenceChanged();
 
   if (!g_disable_ui_for_testing && profile_->IsNewProfile() &&
       !profile_->GetPrefs()->HasPrefPath(prefs::kArcEnabled)) {
     ArcAuthNotification::Show(profile_);
   }
 }
 
 void ArcAuthService::Shutdown() {
-  ShutdownBridgeAndCloseUI();
+  ShutdownBridge();
+  CloseUI();
   if (profile_) {
     sync_preferences::PrefServiceSyncable* pref_service_syncable =
         PrefServiceSyncableFromProfile(profile_);
     pref_service_syncable->RemoveObserver(this);
     pref_service_syncable->RemoveSyncedPrefObserver(prefs::kArcEnabled, this);
   }
   pref_change_registrar_.RemoveAll();
   context_.reset();
   profile_ = nullptr;
   SetState(State::NOT_INITIALIZED);
 }
 
-void ArcAuthService::ShowUI(UIPage page, const base::string16& status) {
-  if (g_disable_ui_for_testing || IsOptInVerificationDisabled())
-    return;
-
-  SetUIPage(page, status);
-  const extensions::AppWindowRegistry* const app_window_registry =
-      extensions::AppWindowRegistry::Get(profile_);
-  DCHECK(app_window_registry);
-  if (app_window_registry->GetCurrentAppWindowForApp(
-          ArcSupportHost::kHostAppId)) {
-    return;
-  }
-
-  const extensions::Extension* extension =
-      extensions::ExtensionRegistry::Get(profile_)->GetInstalledExtension(
-          ArcSupportHost::kHostAppId);
-  CHECK(extension && extensions::util::IsAppLaunchable(
-                         ArcSupportHost::kHostAppId, profile_));
-  OpenApplication(CreateAppLaunchParamsUserContainer(
-      profile_, extension, WindowOpenDisposition::NEW_WINDOW,
-      extensions::SOURCE_CHROME_INTERNAL));
-}
-
 void ArcAuthService::OnContextReady() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   DCHECK(!initial_opt_in_);
 
   // TODO(hidehiko): The check is not necessary if this is a part of re-auth
   // flow. Remove this.
   android_management_checker_.reset(new ArcAndroidManagementChecker(
       profile_, context_->token_service(), context_->account_id(),
       false /* retry_on_error */));
@@ skipping 19 matching lines @@
         shelf_delegate->UnpinAppWithID(ArcSupportHost::kHostAppId);
     }
   }
 }
 
 void ArcAuthService::StopArc() {
   if (state_ != State::STOPPED) {
     UpdateEnabledStateUMA(false);
     profile_->GetPrefs()->SetBoolean(prefs::kArcSignedIn, false);
   }
-  ShutdownBridgeAndCloseUI();
+  ShutdownBridge();
+  CloseUI();
 }
 
 void ArcAuthService::OnOptInPreferenceChanged() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(profile_);
 
   // TODO(dspaid): Move code from OnSyncedPrefChanged into this method.
   OnSyncedPrefChanged(prefs::kArcEnabled, IsArcManaged());
 
   const bool arc_enabled = IsArcEnabled();
@@ skipping 43 matching lines @@
   auth_account_callback_.Reset();
   android_management_checker_.reset();
   auth_code_fetcher_.reset();
   arc_bridge_service()->RequestStop();
   if (state_ != State::NOT_INITIALIZED)
     SetState(State::STOPPED);
   for (auto& observer : observer_list_)
     observer.OnShutdownBridge();
 }
 
-void ArcAuthService::ShutdownBridgeAndCloseUI() {
-  ShutdownBridge();
-  CloseUI();
-}
-
-void ArcAuthService::ShutdownBridgeAndShowUI(UIPage page,
-                                             const base::string16& status) {
-  ShutdownBridge();
-  ShowUI(page, status);
-}
-
 void ArcAuthService::AddObserver(Observer* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   observer_list_.AddObserver(observer);
 }
 
 void ArcAuthService::RemoveObserver(Observer* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   observer_list_.RemoveObserver(observer);
 }
 
 void ArcAuthService::CloseUI() {
-  ui_page_ = UIPage::NO_PAGE;
-  ui_page_status_.clear();
   if (support_host_)
     support_host_->Close();
   if (!g_disable_ui_for_testing)
     ArcAuthNotification::Hide();
 }
 
-void ArcAuthService::SetUIPage(UIPage page, const base::string16& status) {
-  ui_page_ = page;
-  ui_page_status_ = status;
-  if (support_host_)
-    support_host_->ShowPage(ui_page_, ui_page_status_);
-}
-
 // This is the special method to support enterprise mojo API.
 // TODO(hidehiko): Remove this.
 void ArcAuthService::StopAndEnableArc() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(!arc_bridge_service()->stopped());
   reenable_arc_ = true;
   StopArc();
 }
 
 void ArcAuthService::StartArc() {
@@ skipping 15 matching lines @@
       return;
     } else {
       auth_account_callback_.Run(auth_code, !IsOptInVerificationDisabled(),
                                  mojom::ChromeAccountType::USER_ACCOUNT);
       auth_account_callback_.Reset();
       return;
     }
   }
 
   if (state_ != State::FETCHING_CODE) {
-    ShutdownBridgeAndCloseUI();
+    ShutdownBridge();
+    CloseUI();
     return;
   }
 
   sign_in_time_ = base::Time::Now();
   VLOG(1) << "Starting ARC for first sign in.";
 
-  SetUIPage(UIPage::START_PROGRESS, base::string16());
+  if (support_host_)
+    support_host_->ShowLoadingPage();
   ShutdownBridge();
   auth_code_ = auth_code;
   arc_sign_in_timer_.Start(FROM_HERE, kArcSignInTimeout,
                            base::Bind(&ArcAuthService::OnArcSignInTimeout,
                                       weak_ptr_factory_.GetWeakPtr()));
   StartArc();
 }
 
 void ArcAuthService::OnArcSignInTimeout() {
   LOG(ERROR) << "Timed out waiting for first sign in.";
   OnSignInFailedInternal(ProvisioningResult::OVERALL_SIGN_IN_TIMEOUT);
 }
 
 void ArcAuthService::StartLso() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // Update UMA only if error (with or without feedback) is currently shown.
-  if (ui_page_ == UIPage::ERROR) {
+  if (support_host_ && support_host_->ui_page() == UIPage::ERROR) {
     UpdateOptInActionUMA(OptInActionType::RETRY);
-  } else if (ui_page_ == UIPage::ERROR_WITH_FEEDBACK) {
-    UpdateOptInActionUMA(OptInActionType::RETRY);
-    ShutdownBridge();
+    if (support_host_->error_page_has_send_feedback_button()) {
+      ShutdownBridge();
+    }
   }
 
   // TODO(khmel): Use PrepareContextForAuthCodeRequest for this case.
   initial_opt_in_ = false;
   StartUI();
 }
 
 void ArcAuthService::CancelAuthCode() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (state_ == State::NOT_INITIALIZED) {
     NOTREACHED();
     return;
   }
 
   // In case |state_| is ACTIVE, |ui_page_| can be START_PROGRESS (which means
   // normal Arc booting) or  ERROR or ERROR_WITH_FEEDBACK (in case Arc can not
   // be started). If Arc is booting normally dont't stop it on progress close.
-  if (state_ != State::FETCHING_CODE && ui_page_ != UIPage::ERROR &&
-      ui_page_ != UIPage::ERROR_WITH_FEEDBACK) {
+  if (state_ != State::FETCHING_CODE &&
+      (support_host_ && support_host_->ui_page() != UIPage::ERROR))
     return;
-  }
 
   // Update UMA with user cancel only if error is not currently shown.
-  if (ui_page_ != UIPage::ERROR && ui_page_ == UIPage::ERROR_WITH_FEEDBACK &&
-      ui_page_ != UIPage::NO_PAGE) {
+  if (support_host_ &&
+      support_host_->ui_page() != UIPage::ERROR &&
+      support_host_->ui_page() != UIPage::NO_PAGE)
     UpdateOptInCancelUMA(OptInCancelReason::USER_CANCEL);
-  }
 
   StopArc();
 
   if (IsArcManaged())
     return;
 
   DisableArc();
 }
 
 bool ArcAuthService::IsArcManaged() const {
@@ skipping 29 matching lines @@
   DCHECK(profile_);
   profile_->GetPrefs()->SetBoolean(prefs::kArcEnabled, false);
 }
 
 void ArcAuthService::StartUI() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (!arc_bridge_service()->stopped()) {
     // If the user attempts to re-enable ARC while the bridge is still running
     // the user should not be able to continue until the bridge has stopped.
-    ShowUI(UIPage::ERROR, l10n_util::GetStringUTF16(
-                              IDS_ARC_SIGN_IN_SERVICE_UNAVAILABLE_ERROR));
+    if (support_host_)
+      support_host_->ShowErrorPage(
+          ErrorType::SIGN_IN_SERVICE_UNAVAILABLE_ERROR, false);
     return;
   }
 
   SetState(State::FETCHING_CODE);
 
   if (initial_opt_in_) {
     initial_opt_in_ = false;
-    ShowUI(UIPage::TERMS, base::string16());
+    if (support_host_)
+      support_host_->ShowTermsOfServicePage();
   } else {
     context_->PrepareContext();
   }
 }
 
 void ArcAuthService::OnPrepareContextFailed() {
   DCHECK_EQ(state_, State::FETCHING_CODE);
-
-  ShutdownBridgeAndShowUI(
-      UIPage::ERROR,
-      l10n_util::GetStringUTF16(IDS_ARC_SERVER_COMMUNICATION_ERROR));
+  ShutdownBridge();
+  if (support_host_)
+    support_host_->ShowErrorPage(ErrorType::SERVER_COMMUNICATION_ERROR, false);
   UpdateOptInCancelUMA(OptInCancelReason::NETWORK_ERROR);
 }
 
 void ArcAuthService::OnAuthCodeSuccess(const std::string& auth_code) {
   SetAuthCodeAndStartArc(auth_code);
 }
 
 void ArcAuthService::OnAuthCodeFailed() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(state_, State::FETCHING_CODE);
-  ShutdownBridgeAndShowUI(
-      UIPage::ERROR,
-      l10n_util::GetStringUTF16(IDS_ARC_SERVER_COMMUNICATION_ERROR));
+  ShutdownBridge();
+  if (support_host_)
+    support_host_->ShowErrorPage(ErrorType::SERVER_COMMUNICATION_ERROR, false);
   UpdateOptInCancelUMA(OptInCancelReason::NETWORK_ERROR);
 }
 
 void ArcAuthService::OnAndroidManagementChecked(
     policy::AndroidManagementClient::Result result) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   switch (result) {
     case policy::AndroidManagementClient::Result::UNMANAGED:
       OnAndroidManagementPassed();
       break;
     case policy::AndroidManagementClient::Result::MANAGED:
-      ShutdownBridgeAndShowUI(
-          UIPage::ERROR,
-          l10n_util::GetStringUTF16(IDS_ARC_ANDROID_MANAGEMENT_REQUIRED_ERROR));
+      ShutdownBridge();
+      if (support_host_) {
+        support_host_->ShowErrorPage(
+            ErrorType::ANDROID_MANAGEMENT_REQUIRED_ERROR, false);
+      }
       UpdateOptInCancelUMA(OptInCancelReason::ANDROID_MANAGEMENT_REQUIRED);
       break;
     case policy::AndroidManagementClient::Result::ERROR:
-      ShutdownBridgeAndShowUI(
-          UIPage::ERROR,
-          l10n_util::GetStringUTF16(IDS_ARC_SERVER_COMMUNICATION_ERROR));
+      ShutdownBridge();
+      if (support_host_) {
+        support_host_->ShowErrorPage(
+            ErrorType::SERVER_COMMUNICATION_ERROR, false);
+      }
       UpdateOptInCancelUMA(OptInCancelReason::NETWORK_ERROR);
       break;
   }
 }
 
 void ArcAuthService::OnBackgroundAndroidManagementChecked(
     policy::AndroidManagementClient::Result result) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   switch (result) {
     case policy::AndroidManagementClient::Result::UNMANAGED:
@@ skipping 17 matching lines @@
   std::string auth_endpoint;
   if (command_line->HasSwitch(chromeos::switches::kArcUseAuthEndpoint)) {
     auth_endpoint = command_line->GetSwitchValueASCII(
         chromeos::switches::kArcUseAuthEndpoint);
   }
 
   if (!auth_endpoint.empty()) {
     auth_code_fetcher_.reset(new ArcAuthCodeFetcher(
         this, context_->GetURLRequestContext(), profile_, auth_endpoint));
   } else {
-    ShowUI(UIPage::LSO_PROGRESS, base::string16());
+    if (support_host_)
+      support_host_->ShowLsoPage();
   }
 }
 
 void ArcAuthService::OnAndroidManagementPassed() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (state_ == State::ACTIVE) {
     if (IsAuthCodeRequest())
       FetchAuthCode();
     return;
   }
 
   if (profile_->GetPrefs()->GetBoolean(prefs::kArcSignedIn) ||
       IsOptInVerificationDisabled()) {
     StartArc();
   } else {
     FetchAuthCode();
   }
 }
 
+void ArcAuthService::OnMetricsModeChanged(bool enabled, bool managed) {
+  if (support_host_)
+    support_host_->SetMetricsCheckbox(enabled, managed);
+}
+
+void ArcAuthService::OnBackupAndRestoreModeChanged(
+    bool enabled, bool managed) {
+  if (support_host_)
+    support_host_->SetBackupAndRestoreCheckbox(enabled, managed);
+}
+
+void ArcAuthService::OnLocationServicesModeChanged(
+    bool enabled, bool managed) {
+  if (support_host_)
+    support_host_->SetLocationServiceCheckbox(enabled, managed);
+}
+
+void ArcAuthService::OnWindowClosed() {
+  CancelAuthCode();
+}
+
+void ArcAuthService::OnTermsAgreed(bool is_metrics_enabled,
+                                   bool is_backup_and_restore_enabled,
+                                   bool is_location_service_enabled) {
+  preference_handler_->EnableMetrics(is_metrics_enabled);
+  preference_handler_->EnableBackupRestore(is_backup_and_restore_enabled);
+  preference_handler_->EnableLocationService(is_location_service_enabled);
+  StartLso();
+}
+
+void ArcAuthService::OnAuthSucceeded(const std::string& auth_code) {
+  SetAuthCodeAndStartArc(auth_code);
+}
+
+void ArcAuthService::OnSendFeedbackClicked() {
+  chrome::OpenFeedbackDialog(nullptr);
+}
+
 std::ostream& operator<<(std::ostream& os, const ArcAuthService::State& state) {
   switch (state) {
     case ArcAuthService::State::NOT_INITIALIZED:
       return os << "NOT_INITIALIZED";
     case ArcAuthService::State::STOPPED:
       return os << "STOPPED";
     case ArcAuthService::State::FETCHING_CODE:
       return os << "FETCHING_CODE";
     case ArcAuthService::State::ACTIVE:
       return os << "ACTIVE";
     default:
       NOTREACHED();
       return os;
   }
 }
 
 }  // namespace arc