Delete unused tutorial code from profile switcher/user manager.

chrome/browser/profiles/profile_window.cc

 // Copyright 2013 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/profiles/profile_window.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
@@ skipping 105 matching lines @@
   }
 
   // Profile for which the browser should be opened.
   Profile* profile_;
   ProfileManager::CreateCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserAddedForProfileObserver);
 };
 
 // Called after a |system_profile| is available to be used by the user manager.
-// Based on the value of |tutorial_mode| we determine a url to be displayed
-// by the webui and run the |callback|, if it exists. Depending on the value of
+// Runs |callback|, if it exists. Depending on the value of
 // |user_manager_action|, executes an action once the user manager displays or
 // after a profile is opened.
 void OnUserManagerSystemProfileCreated(
     const base::FilePath& profile_path_to_focus,
-    profiles::UserManagerTutorialMode tutorial_mode,
     profiles::UserManagerAction user_manager_action,
     const base::Callback<void(Profile*, const std::string&)>& callback,
     Profile* system_profile,
     Profile::CreateStatus status) {
   if (status != Profile::CREATE_STATUS_INITIALIZED || callback.is_null())
     return;
 
   // Tell the webui which user should be focused.
   std::string page = chrome::kChromeUIMdUserManagerUrl;
 
-  if (tutorial_mode == profiles::USER_MANAGER_TUTORIAL_OVERVIEW) {
-    page += profiles::kUserManagerDisplayTutorial;
-  } else if (!profile_path_to_focus.empty()) {
+  if (!profile_path_to_focus.empty()) {
     // The file path is processed in the same way as base::CreateFilePathValue
     // (i.e. convert to std::string with AsUTF8Unsafe()), and then URI encoded.
     page += "#";
     page += net::EscapeUrlEncodedData(profile_path_to_focus.AsUTF8Unsafe(),
                                       false);
   } else if (user_manager_action ==
              profiles::USER_MANAGER_OPEN_CREATE_USER_PAGE) {
     page += profiles::kUserManagerOpenCreateUserPage;
   } else if (user_manager_action ==
              profiles::USER_MANAGER_SELECT_PROFILE_TASK_MANAGER) {
@@ skipping 23 matching lines @@
 
   if (!callback.is_null())
     callback.Run(profile, Profile::CREATE_STATUS_INITIALIZED);
 }
 
 }  // namespace
 
 namespace profiles {
 
 // User Manager parameters are prefixed with hash.
-const char kUserManagerDisplayTutorial[] = "#tutorial";
 const char kUserManagerOpenCreateUserPage[] = "#create-user";
 const char kUserManagerSelectProfileTaskManager[] = "#task-manager";
 const char kUserManagerSelectProfileAboutChrome[] = "#about-chrome";
 const char kUserManagerSelectProfileChromeSettings[] = "#chrome-settings";
 const char kUserManagerSelectProfileAppLauncher[] = "#app-launcher";
 
 base::FilePath GetPathOfProfileWithEmail(ProfileManager* profile_manager,
                                          const std::string& email) {
   base::string16 profile_email = base::UTF8ToUTF16(email);
   std::vector<ProfileAttributesEntry*> entries =
@@ skipping 153 matching lines @@
       base::Bind(&profiles::OpenBrowserWindowForProfile,
                  callback,
                  true,
                  true),
       std::string());
   ProfileMetrics::LogProfileAddNewUser(metric);
 }
 
 void ProfileBrowserCloseSuccess(const base::FilePath& profile_path) {
   UserManager::Show(base::FilePath(),
-                    profiles::USER_MANAGER_NO_TUTORIAL,
                     profiles::USER_MANAGER_SELECT_PROFILE_NO_ACTION);
 }
 
 void CloseGuestProfileWindows() {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   Profile* profile = profile_manager->GetProfileByPath(
       ProfileManager::GetGuestProfilePath());
 
   if (profile) {
     BrowserList::CloseAllBrowsersWithProfile(
@@ skipping 10 matching lines @@
   DCHECK(has_entry);
   entry->SetIsSigninRequired(true);
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   // Profile guaranteed to exist for it to have been locked.
   BlockExtensions(profile_manager->GetProfileByPath(profile_path));
 #endif  // BUILDFLAG(ENABLE_EXTENSIONS)
 
   chrome::HideTaskManager();
   UserManager::Show(profile_path,
-                    profiles::USER_MANAGER_NO_TUTORIAL,
                     profiles::USER_MANAGER_SELECT_PROFILE_NO_ACTION);
 }
 
 void LockProfile(Profile* profile) {
   DCHECK(profile);
   if (profile) {
     BrowserList::CloseAllBrowsersWithProfile(
         profile, base::Bind(&LockBrowserCloseSuccess),
         BrowserList::CloseCallback(), false);
   }
@@ skipping 35 matching lines @@
 
 void CloseProfileWindows(Profile* profile) {
   DCHECK(profile);
   BrowserList::CloseAllBrowsersWithProfile(
       profile, base::Bind(&ProfileBrowserCloseSuccess),
       BrowserList::CloseCallback(), false);
 }
 
 void CreateSystemProfileForUserManager(
     const base::FilePath& profile_path_to_focus,
-    profiles::UserManagerTutorialMode tutorial_mode,
     profiles::UserManagerAction user_manager_action,
     const base::Callback<void(Profile*, const std::string&)>& callback) {
   // Create the system profile, if necessary, and open the User Manager
   // from the system profile.
   g_browser_process->profile_manager()->CreateProfileAsync(
       ProfileManager::GetSystemProfilePath(),
       base::Bind(&OnUserManagerSystemProfileCreated,
                  profile_path_to_focus,
-                 tutorial_mode,
                  user_manager_action,
                  callback),
       base::string16(),
       std::string(),
       std::string());
 }
 
-void ShowUserManagerMaybeWithTutorial(Profile* profile) {
-  // Guest users cannot appear in the User Manager, nor display a tutorial.
-  if (!profile || profile->IsGuestSession()) {
-    UserManager::Show(base::FilePath(),
-                      profiles::USER_MANAGER_NO_TUTORIAL,
-                      profiles::USER_MANAGER_SELECT_PROFILE_NO_ACTION);
-    return;
-  }
-  UserManager::Show(base::FilePath(),
-                    profiles::USER_MANAGER_TUTORIAL_OVERVIEW,
-                    profiles::USER_MANAGER_SELECT_PROFILE_NO_ACTION);
-}
-
-void BubbleViewModeFromAvatarBubbleMode(
-    BrowserWindow::AvatarBubbleMode mode,
-    BubbleViewMode* bubble_view_mode,
-    TutorialMode* tutorial_mode) {
-  *tutorial_mode = TUTORIAL_MODE_NONE;
+void BubbleViewModeFromAvatarBubbleMode(BrowserWindow::AvatarBubbleMode mode,
+                                        BubbleViewMode* bubble_view_mode) {
   switch (mode) {
     case BrowserWindow::AVATAR_BUBBLE_MODE_ACCOUNT_MANAGEMENT:
       *bubble_view_mode = BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT;
       return;
     case BrowserWindow::AVATAR_BUBBLE_MODE_SIGNIN:
       *bubble_view_mode = BUBBLE_VIEW_MODE_GAIA_SIGNIN;
       return;
     case BrowserWindow::AVATAR_BUBBLE_MODE_ADD_ACCOUNT:
       *bubble_view_mode = BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT;
       return;
     case BrowserWindow::AVATAR_BUBBLE_MODE_REAUTH:
       *bubble_view_mode = BUBBLE_VIEW_MODE_GAIA_REAUTH;
       return;
     case BrowserWindow::AVATAR_BUBBLE_MODE_CONFIRM_SIGNIN:
       *bubble_view_mode = BUBBLE_VIEW_MODE_PROFILE_CHOOSER;
-      *tutorial_mode = TUTORIAL_MODE_CONFIRM_SIGNIN;
       return;
     case BrowserWindow::AVATAR_BUBBLE_MODE_SHOW_ERROR:
       *bubble_view_mode = BUBBLE_VIEW_MODE_PROFILE_CHOOSER;
-      *tutorial_mode = TUTORIAL_MODE_SHOW_ERROR;
       return;
     default:
       *bubble_view_mode = profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER;
   }
 }
 
-bool ShouldShowWelcomeUpgradeTutorial(
-    Profile* profile, TutorialMode tutorial_mode) {
-  const int show_count = profile->GetPrefs()->GetInteger(
-      prefs::kProfileAvatarTutorialShown);
-  // Do not show the tutorial if user has dismissed it.
-  if (show_count > signin_ui_util::kUpgradeWelcomeTutorialShowMax)
-    return false;
-
-  return tutorial_mode == TUTORIAL_MODE_WELCOME_UPGRADE ||
-         show_count != signin_ui_util::kUpgradeWelcomeTutorialShowMax;
-}
-
 }  // namespace profiles