Removing FRE UI for unicorn accounts.

chrome/browser/chromeos/login/session/user_session_manager.cc

 // Copyright 2014 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/login/session/user_session_manager.h"
 
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
@@ skipping 47 matching lines @@
 #include "chrome/browser/net/crl_set_fetcher.h"
 #include "chrome/browser/net/nss_context.h"
 #include "chrome/browser/pref_service_flags_storage.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/rlz/rlz.h"
 #include "chrome/browser/signin/account_tracker_service_factory.h"
 #include "chrome/browser/signin/easy_unlock_service.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
+#include "chrome/browser/supervised_user/child_accounts/child_account_service.h"
+#include "chrome/browser/supervised_user/child_accounts/child_account_service_factory.h"
 #include "chrome/browser/ui/app_list/start_page_service.h"
 #include "chrome/browser/ui/startup/startup_browser_creator.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chromeos/cert_loader.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/cryptohome_util.h"
 #include "chromeos/dbus/cryptohome_client.h"
@@ skipping 240 matching lines @@
 UserSessionManager::UserSessionManager()
     : delegate_(nullptr),
       authenticator_(nullptr),
       has_auth_cookies_(false),
       user_sessions_restored_(false),
       user_sessions_restore_in_progress_(false),
       exit_after_session_restore_(false),
       session_restore_strategy_(
           OAuth2LoginManager::RESTORE_FROM_SAVED_OAUTH2_REFRESH_TOKEN),
       running_easy_unlock_key_ops_(false),
-      should_launch_browser_(true) {
+      should_launch_browser_(true),
+      flags_fetching_ended_(false),
+      requesting_start_urls_(false),
+      profile_fetching_flags_(nullptr),
+      weak_factory_(this) {
   net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
   user_manager::UserManager::Get()->AddSessionStateObserver(this);
 }
 
 UserSessionManager::~UserSessionManager() {
   // UserManager is destroyed before singletons, so we need to check if it
   // still exists.
   // TODO(nkostylev): fix order of destruction of UserManager
   // / UserSessionManager objects.
   if (user_manager::UserManager::IsInitialized())
     user_manager::UserManager::Get()->RemoveSessionStateObserver(this);
   net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
 }
 
+// static
+const int UserSessionManager::kFlagsFetchingLoginTimeoutMs = 1000;
+
 void UserSessionManager::CompleteGuestSessionLogin(const GURL& start_url) {
   VLOG(1) << "Completing guest session login";
 
   // For guest session we ask session_manager to restart Chrome with --bwsi
   // flag. We keep only some of the arguments of this process.
   const base::CommandLine& browser_command_line =
       *base::CommandLine::ForCurrentProcess();
   base::CommandLine command_line(browser_command_line.GetProgram());
   std::string cmd_line_str =
       GetOffTheRecordCommandLine(start_url,
@@ skipping 419 matching lines @@
     // users once it is fully multi-profile aware. http://crbug.com/238987
     // For now if we have other user pending sessions they'll override OAuth
     // session restore for previous users.
     RestoreAuthenticationSession(profile);
   }
 
   // Restore other user sessions if any.
   RestorePendingUserSessions();
 }
 
+void UserSessionManager::OnFlagsFetchingError() {
+  FlagsFetchingStopped();
+}
+
+void UserSessionManager::OnFlagsFetchingCancelled() {
+  FlagsFetchingStopped();
+}
+
+void UserSessionManager::OnFlagsFetchingCompleted(bool is_child_account) {
+  FlagsFetchingStopped();
+}
+
+void UserSessionManager::FlagsFetchingStopped() {
+  flags_fetching_ended_ = true;
+  if (requesting_start_urls_) {
+    InitializeStartUrls();
+    requesting_start_urls_ = false;
+  }
+  ChildAccountServiceFactory::GetForProfile(profile_fetching_flags_)->
+      RemoveFlagFetchingObserver(this);
+  profile_fetching_flags_ = nullptr;
+}
+
 void UserSessionManager::CreateUserSession(const UserContext& user_context,
                                            bool has_auth_cookies) {
   user_context_ = user_context;
   has_auth_cookies_ = has_auth_cookies;
   InitSessionRestoreStrategy();
 }
 
 void UserSessionManager::PreStartSession() {
   // Switch log file as soon as possible.
   if (base::SysInfo::IsRunningOnChromeOS())
@@ skipping 246 matching lines @@
 void UserSessionManager::ActivateWizard(const std::string& screen_name) {
   LoginDisplayHost* host = LoginDisplayHostImpl::default_host();
   CHECK(host);
   host->StartWizard(screen_name);
 }
 
 void UserSessionManager::InitializeStartUrls() const {
   std::vector<std::string> start_urls;
 
   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
+
   bool can_show_getstarted_guide =
       user_manager->GetActiveUser()->GetType() ==
           user_manager::USER_TYPE_REGULAR &&
       !user_manager->IsCurrentUserNonCryptohomeDataEphemeral();
+
   // Skip the default first-run behavior for public accounts.
   if (!user_manager->IsLoggedInAsPublicAccount()) {
     if (AccessibilityManager::Get()->IsSpokenFeedbackEnabled()) {
       const char* url = kChromeVoxTutorialURLPattern;
       PrefService* prefs = g_browser_process->local_state();
       const std::string current_locale =
           base::StringToLowerASCII(prefs->GetString(prefs::kApplicationLocale));
       std::string vox_url = base::StringPrintf(url, current_locale.c_str());
       start_urls.push_back(vox_url);
       can_show_getstarted_guide = false;
@@ skipping 11 matching lines @@
         ::switches::kSilentLaunch);
     first_run::MaybeLaunchDialogAfterSessionStart();
   } else {
     for (size_t i = 0; i < start_urls.size(); ++i) {
       base::CommandLine::ForCurrentProcess()->AppendArg(start_urls[i]);
     }
   }
 }
 
 bool UserSessionManager::InitializeUserSession(Profile* profile) {
+  ChildAccountServiceFactory::GetForProfile(profile)->
+      AddFlagFetchingObserver(this);

[Marc Treib, 2015/03/04 09:59:15]

Could the "is child account" status already be known here? Then you wouldn't get
any notification from the CAService.

[merkulova, 2015/03/04 10:06:27]

Yes, it might be already know. Then we wait for the timeout. Then the FRE UI
decision is processed based on user status (which was set much earlier) and it's
ok.

[Marc Treib, 2015/03/04 10:17:53]

Then I'd add an "IsChildAccountStatusKnown" method to the CAService (returns
true after flag fetching succeeded for the first time), so we don't have to wait
for the timeout if we already know. (Or maybe introduce an enum
ChildAccountStatus { CHILD, NON_CHILD, DONT_KNOW }?)
We should probably also store it in a pref.

[merkulova, 2015/03/04 14:55:11]

Done.

+  base::MessageLoopProxy::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&UserSessionManager::OnFlagsFetchingCancelled,
+                 weak_factory_.GetWeakPtr()),
+      base::TimeDelta::FromMilliseconds(kFlagsFetchingLoginTimeoutMs));
+  profile_fetching_flags_ = profile;
+
   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
 
   // Kiosk apps has their own session initialization pipeline.
   if (user_manager->IsLoggedInAsKioskApp())
     return false;
 
   if (start_session_type_ == PRIMARY_USER_SESSION) {
     UserFlow* user_flow = ChromeUserManager::Get()->GetCurrentUserFlow();
     WizardController* oobe_controller = WizardController::default_controller();
     base::CommandLine* cmdline = base::CommandLine::ForCurrentProcess();
     bool skip_post_login_screens =
         user_flow->ShouldSkipPostLoginScreens() ||
         (oobe_controller && oobe_controller->skip_post_login_screens()) ||
         cmdline->HasSwitch(chromeos::switches::kOobeSkipPostLogin);
 
     if (user_manager->IsCurrentUserNew() && !skip_post_login_screens) {
       // Don't specify start URLs if the administrator has configured the start
       // URLs via policy.
-      if (!SessionStartupPref::TypeIsManaged(profile->GetPrefs()))
-        InitializeStartUrls();
+      if (!SessionStartupPref::TypeIsManaged(profile->GetPrefs())) {
+        if (flags_fetching_ended_)
+          InitializeStartUrls();
+        else
+          requesting_start_urls_ = true;
+      }
 
       // Mark the device as registered., i.e. the second part of OOBE as
       // completed.
       if (!StartupUtils::IsDeviceRegistered())
         StartupUtils::MarkDeviceRegistered(base::Closure());
 
       ActivateWizard(WizardController::kTermsOfServiceScreenName);
       return false;
     }
   }
@@ skipping 429 matching lines @@
   default_ime_states_.erase(profile);
 }
 
 void UserSessionManager::InjectStubUserContext(
     const UserContext& user_context) {
   injected_user_context_.reset(new UserContext(user_context));
   authenticator_ = NULL;
 }
 
 }  // namespace chromeos