arc: Start ARC for Public Session users.

chrome/browser/chromeos/arc/arc_session_manager.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_session_manager.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 242 matching lines @@
     // no double message can happen in production.
     LOG(WARNING) << "Provisioning result was already reported. Ignoring "
                  << "additional result " << static_cast<int>(result) << ".";
     return;
   }
   provisioning_reported_ = true;
   if (scoped_opt_in_tracker_ && result != ProvisioningResult::SUCCESS)
     scoped_opt_in_tracker_->TrackError();
 
   if (result == ProvisioningResult::CHROME_SERVER_COMMUNICATION_ERROR) {
     if (IsArcKioskMode()) {

[hidehiko, 2017/06/08 12:02:27]

Need to check here, too?

[Sergey Poromov, 2017/06/08 13:56:18]

Done.

       VLOG(1) << "Robot account auth code fetching error";
       // Log out the user. All the cleanup will be done in Shutdown() method.
       // The callback is not called because auth code is empty.
       attempt_user_exit_callback_.Run();
       return;
     }
 
     // For backwards compatibility, use NETWORK_ERROR for
     // CHROME_SERVER_COMMUNICATION_ERROR case.
     UpdateOptInCancelUMA(OptInCancelReason::NETWORK_ERROR);
@@ skipping 26 matching lines @@
     // Launch Play Store app, except for the following cases:
     // * When Opt-in verification is disabled (for tests);
     // * In ARC Kiosk mode, because the only one UI in kiosk mode must be the
     //   kiosk app and device is not needed for opt-in;
     // * When ARC is managed and all OptIn preferences are managed too, because
     //   the whole OptIn flow should happen as seamless as possible for the
     //   user.
     const bool suppress_play_store_app =
         IsArcOptInVerificationDisabled() || IsArcKioskMode() ||
         (IsArcPlayStoreEnabledPreferenceManagedForProfile(profile_) &&
          AreArcAllOptInPreferencesManagedForProfile(profile_));

[Sergey Poromov, 2017/06/08 13:56:18]

While OptIn preferences should be managed for Public Sessions, why shouldn't
rely on that and never start Play Store app for Public Sessions as well.

     if (!suppress_play_store_app) {
       playstore_launcher_.reset(
           new ArcAppLauncher(profile_, kPlayStoreAppId, true, false));
     }
 
     for (auto& observer : observer_list_)
       observer.OnArcInitialStart();
     return;
   }
 
@@ skipping 86 matching lines @@
   // 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.
   //
   // Don't show UI for ARC Kiosk because the only one UI in kiosk mode must
   // be the kiosk app. In case of error the UI will be useless as well, because
   // in typical use case there will be no one nearby the kiosk device, who can
   // do some action to solve the problem be means of UI.
   if (!g_disable_ui_for_testing && !IsArcOptInVerificationDisabled() &&
       !IsArcKioskMode()) {

[hidehiko, 2017/06/08 12:02:26]

Clarification: Do we want to show error for Public user?

[Sergey Poromov, 2017/06/08 13:56:18]

I think not. In case of an error there is nothing the user can do. Most likely
we should just not start ARC then.
What for is the ArcSupportHost used, btw?

     DCHECK(!support_host_);
     support_host_ = base::MakeUnique<ArcSupportHost>(profile_);
     support_host_->SetErrorDelegate(this);
   }
 
   DCHECK_EQ(State::NOT_INITIALIZED, state_);
   SetState(State::STOPPED);
 
   context_ = base::MakeUnique<ArcAuthContext>(profile_);
 
@@ skipping 138 matching lines @@
     reenable_arc_ = true;
     return;
   }
 
   PrefService* const prefs = profile_->GetPrefs();
 
   // If it is marked that sign in has been successfully done, if ARC has been
   // set up to always start, then directly start ARC.
   // For Kiosk mode, skip ToS because it is very likely that near the device
   // there will be no one who is eligible to accept them.
-  // If opt-in verification is disabled, skip negotiation, too. This is for
-  // testing purpose.
+  // In Public Session mode ARC should be started silently without user
+  // interaction. If opt-in verification is disabled, skip negotiation, too.
+  // This is for testing purpose.
   const bool start_arc_directly = prefs->GetBoolean(prefs::kArcSignedIn) ||
                                   ShouldArcAlwaysStart() || IsArcKioskMode() ||
+                                  IsPublicSessionMode() ||
                                   IsArcOptInVerificationDisabled();
 
   // When ARC is blocked because of filesystem compatibility, do not proceed
   // to starting ARC nor follow further state transitions.
   if (IsArcBlockedDueToIncompatibleFileSystem(profile_)) {
     // If the next step was the ToS negotiation, show a notification instead.
     // Otherwise, be silent now. Users are notified when clicking ARC app icons.
     if (!start_arc_directly && !g_disable_ui_for_testing)
       arc::ShowArcMigrationGuideNotification(profile_);
     return;
@@ skipping 59 matching lines @@
   if (state_ == State::STOPPED && arc_session_runner_->IsStopped())
     MaybeStartArcDataRemoval();
 }
 
 void ArcSessionManager::MaybeStartTermsOfServiceNegotiation() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(profile_);
   DCHECK(!terms_of_service_negotiator_);
   // In Kiosk-mode, Terms of Service negotiation should be skipped.
   // See also RequestEnableImpl().
   DCHECK(!IsArcKioskMode());

[hidehiko, 2017/06/08 12:02:26]

DCHECK(!IsPublicSession());  too.

[Sergey Poromov, 2017/06/08 13:56:18]

Done.

   // If opt-in verification is disabled, Terms of Service negotiation should
   // be skipped, too. See also RequestEnableImpl().
   DCHECK(!IsArcOptInVerificationDisabled());
 
   // TODO(hidehiko): Remove this condition, when the state machine is fixed.
   if (!arc_session_runner_->IsStopped()) {
     // If the user attempts to re-enable ARC while the ARC instance is still
     // running the user should not be able to continue until the ARC instance
     // has stopped.
     ShowArcSupportHostError(
@@ skipping 143 matching lines @@
 }
 
 void ArcSessionManager::StartBackgroundAndroidManagementCheck() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_EQ(state_, State::ACTIVE);
   DCHECK(!android_management_checker_);
 
   // Skip Android management check for testing.
   // We also skip if Android management check for Kiosk mode,
   // because there are no managed human users for Kiosk exist.
   if (IsArcOptInVerificationDisabled() || IsArcKioskMode() ||

[hidehiko, 2017/06/08 12:02:27]

Is it ok to run the check for the Public session?

[Sergey Poromov, 2017/06/08 13:56:18]

Public Session is always Chrome OS managed user, so the check is useless in that
case.

       (g_disable_ui_for_testing &&
        !g_enable_check_android_management_for_testing)) {
     return;
   }
 
   android_management_checker_ = base::MakeUnique<ArcAndroidManagementChecker>(
       profile_, context_->token_service(), context_->account_id(),
       true /* retry_on_error */);
   android_management_checker_->StartCheck(
       base::Bind(&ArcSessionManager::OnBackgroundAndroidManagementChecked,
@@ skipping 203 matching lines @@
 
 #undef MAP_STATE
 
   // Some compilers report an error even if all values of an enum-class are
   // covered exhaustively in a switch statement.
   NOTREACHED() << "Invalid value " << static_cast<int>(state);
   return os;
 }
 
 }  // namespace arc