arc: Handle closing OptIn window for managed Arc.

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/shelf/shelf_delegate.h"
 #include "ash/shell.h"
@@ skipping 434 matching lines @@
                                      : OptInActionType::OPTED_OUT);
 
     if (!disable_arc_from_ui_ && !arc_enabled && !IsArcManaged()) {
       ash::ShelfDelegate* shelf_delegate = GetShelfDelegate();
       if (shelf_delegate)
         shelf_delegate->UnpinAppWithID(ArcSupportHost::kHostAppId);
     }
   }
 }
 
+void ArcAuthService::StopArc() {
+  if (state_ != State::STOPPED) {
+    UpdateEnabledStateUMA(false);
+    profile_->GetPrefs()->SetBoolean(prefs::kArcSignedIn, false);
+  }
+  ShutdownBridgeAndCloseUI();
+}
+
 void ArcAuthService::OnOptInPreferenceChanged() {
   DCHECK(thread_checker.Get().CalledOnValidThread());
   DCHECK(profile_);
 
   const bool arc_enabled = IsArcEnabled();
   FOR_EACH_OBSERVER(Observer, observer_list_, OnOptInEnabled(arc_enabled));
 
   if (!arc_enabled) {
-    if (state_ != State::STOPPED) {
-      UpdateEnabledStateUMA(false);
-      profile_->GetPrefs()->SetBoolean(prefs::kArcSignedIn, false);
-    }
-    ShutdownBridgeAndCloseUI();
+    StopArc();
     return;
   }
 
   if (state_ == State::ACTIVE)
     return;
   CloseUI();
   auth_code_.clear();
 
   if (!profile_->GetPrefs()->GetBoolean(prefs::kArcSignedIn)) {
     // Need pre-fetch auth code and show OptIn UI if needed.
@@ skipping 100 matching lines @@
     ShutdownBridge();
   }
 
   initial_opt_in_ = false;
   StartUI();
 }
 
 void ArcAuthService::CancelAuthCode() {
   DCHECK(thread_checker.Get().CalledOnValidThread());
 
-  if (ui_page_ == UIPage::ERROR_WITH_FEEDBACK) {
-    ShutdownBridge();

[khmel, 2016/06/29 23:53:55]

This is handled in StopArc and by adding check on the line 597

-    if (profile_->GetPrefs()->HasPrefPath(prefs::kArcSignedIn))
-      profile_->GetPrefs()->SetBoolean(prefs::kArcSignedIn, false);
-  }
-
   if (state_ != State::FETCHING_CODE && ui_page_ != UIPage::ERROR &&

[Luis Héctor Chávez, 2016/06/30 17:04:13]

Given that silent opt-in is now off the table, can we still have the behavior of
closing the window means shutting down the container? If so, this condition
should be

if (state_ == State::NOT_INITIALIZED || state_ == State::STOPPED)

[khmel, 2016/06/30 17:41:50]

I added State::NOT_INITIALIZED handling and comment about State::ACTIVE. In case
State::ACTIVE progress is auxiliary UI and closing it should not stop Arc.

About State::STOPPED: This state is handled correctly at StopArc. Also we cannot
exit early with it because this call (CancelAuthcCode) not only stops the
container but also set arc.enabled=off in preferences (if not managed)    

[Luis Héctor Chávez, 2016/06/30 20:46:46]

Discussed this with mitsuji@. He was also of the idea that we shouldn't require
another opt-in flow if the window is closed after the opt-in was done. That
leaves us with two non-conflicting options:

a) Add a global timeout. If the instance has not finished booted after a certain
period of time, we consider that an unrecoverble failure (like the provisioning
failure), and allow for both retry and potentially sending feedback. The problem
that mitsuji@ mentioned is that since you've already closed the window, we would
need some text explaining what happened.
b) Have a way to restore the window to whatever state it was before closing.
Currently if you click on the Play Store icon, nothing happens. If we hit the
timeout, that'l potentially be that way for a couple of minutes. This might also
need some text changes.

       ui_page_ != UIPage::ERROR_WITH_FEEDBACK)
     return;
 
   // Update UMA with user cancel only if error is not currently shown.
-  if (ui_page_ != UIPage::ERROR && ui_page_ != UIPage::NO_PAGE)
+  if (ui_page_ != UIPage::ERROR && ui_page_ == UIPage::ERROR_WITH_FEEDBACK &&
+      ui_page_ != UIPage::NO_PAGE) {
     UpdateOptInCancelUMA(OptInCancelReason::USER_CANCEL);
+  }
+
+  StopArc();
+
+  if (IsArcManaged())
+    return;
 
   base::AutoReset<bool> auto_reset(&disable_arc_from_ui_, true);
   DisableArc();
 }
 
 bool ArcAuthService::IsArcManaged() const {
   DCHECK(thread_checker.Get().CalledOnValidThread());
   DCHECK(profile_);
   return profile_->GetPrefs()->IsManagedPreference(prefs::kArcEnabled);
 }
 
 bool ArcAuthService::IsArcEnabled() const {
   DCHECK(thread_checker.Get().CalledOnValidThread());
   DCHECK(profile_);
   return profile_->GetPrefs()->GetBoolean(prefs::kArcEnabled);
 }
 
 void ArcAuthService::EnableArc() {
   DCHECK(thread_checker.Get().CalledOnValidThread());
   DCHECK(profile_);
-  profile_->GetPrefs()->SetBoolean(prefs::kArcEnabled, true);
+
+  if (!IsArcEnabled()) {
+    if (IsArcManaged())
+      return;
+    profile_->GetPrefs()->SetBoolean(prefs::kArcEnabled, true);
+  } else {
+    OnOptInPreferenceChanged();
+  }
 }
 
 void ArcAuthService::DisableArc() {
   DCHECK(thread_checker.Get().CalledOnValidThread());
   DCHECK(profile_);
   profile_->GetPrefs()->SetBoolean(prefs::kArcEnabled, false);
 }
 
 void ArcAuthService::StartUI() {
   DCHECK(thread_checker.Get().CalledOnValidThread());
@@ skipping 86 matching lines @@
       return os << kStateFetchingCode;
     case ArcAuthService::State::ACTIVE:
       return os << kStateActive;
     default:
       NOTREACHED();
       return os;
   }
 }
 
 }  // namespace arc