Remove HostDesktopType from profiles

chrome/browser/ui/webui/signin/user_manager_screen_handler.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/ui/webui/signin/user_manager_screen_handler.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 85 matching lines @@
 const char kJsApiUserManagerGetRemoveWarningDialogMessage[] =
     "getRemoveWarningDialogMessage";
 const size_t kAvatarIconSize = 180;
 const int kMaxOAuthRetries = 3;
 
 void HandleAndDoNothing(const base::ListValue* args) {
 }
 
 // This callback is run if the only profile has been deleted, and a new
 // profile has been created to replace it.
-void OpenNewWindowForProfile(
-    chrome::HostDesktopType desktop_type,
-    Profile* profile,
-    Profile::CreateStatus status) {
+void OpenNewWindowForProfile(Profile* profile, Profile::CreateStatus status) {
   if (status != Profile::CREATE_STATUS_INITIALIZED)
     return;
   profiles::FindOrCreateNewWindowForProfile(
-    profile,
-    chrome::startup::IS_PROCESS_STARTUP,
-    chrome::startup::IS_FIRST_RUN,
-    desktop_type,
-    false);
+      profile, chrome::startup::IS_PROCESS_STARTUP,
+      chrome::startup::IS_FIRST_RUN, false);
 }
 
 std::string GetAvatarImageAtIndex(
     size_t index, ProfileInfoCache* info_cache) {
   bool is_gaia_picture =
       info_cache->IsUsingGAIAPictureOfProfileAtIndex(index) &&
       info_cache->GetGAIAPictureOfProfileAtIndex(index);
 
   // If the avatar is too small (i.e. the old-style low resolution avatar),
   // it will be pixelated when displayed in the User Manager, so we should
@@ skipping 40 matching lines @@
   ~UrlHashHelper() override;
 
   void ExecuteUrlHash();
 
   // chrome::BrowserListObserver overrides:
   void OnBrowserRemoved(Browser* browser) override;
 
  private:
   Browser* browser_;
   Profile* profile_;
-  chrome::HostDesktopType desktop_type_;
   std::string hash_;
 
   DISALLOW_COPY_AND_ASSIGN(UrlHashHelper);
 };
 
 UrlHashHelper::UrlHashHelper(Browser* browser, const std::string& hash)
     : browser_(browser),
       profile_(browser->profile()),
-      desktop_type_(browser->host_desktop_type()),
       hash_(hash) {
   BrowserList::AddObserver(this);
 }
 
 UrlHashHelper::~UrlHashHelper() {
   BrowserList::RemoveObserver(this);
 }
 
 void UrlHashHelper::OnBrowserRemoved(Browser* browser) {
   if (browser == browser_)
     browser_ = nullptr;
 }
 
 void UrlHashHelper::ExecuteUrlHash() {
   if (hash_ == profiles::kUserManagerSelectProfileAppLauncher) {
-    AppListService* app_list_service = AppListService::Get(desktop_type_);
+    AppListService* app_list_service =
+        AppListService::Get(chrome::HOST_DESKTOP_TYPE_NATIVE);
     app_list_service->ShowForProfile(profile_);
     return;
   }
 
   Browser* target_browser = browser_;
   if (!target_browser) {
     target_browser = chrome::FindLastActiveWithProfile(profile_);
     if (!target_browser)
       return;
   }
@@ skipping 80 matching lines @@
 
   ProfileManager* profile_manager_;
 
   UserManagerScreenHandler* user_manager_handler_;  // Weak; owns us.
 
   DISALLOW_COPY_AND_ASSIGN(ProfileUpdateObserver);
 };
 
 // UserManagerScreenHandler ---------------------------------------------------
 
-UserManagerScreenHandler::UserManagerScreenHandler()
-    : desktop_type_(chrome::GetActiveDesktop()),
-      weak_ptr_factory_(this) {
+UserManagerScreenHandler::UserManagerScreenHandler() : weak_ptr_factory_(this) {
   profileInfoCacheObserver_.reset(
       new UserManagerScreenHandler::ProfileUpdateObserver(
           g_browser_process->profile_manager(), this));
 }
 
 UserManagerScreenHandler::~UserManagerScreenHandler() {
   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(NULL);
 }
 
 void UserManagerScreenHandler::ShowBannerMessage(
@@ skipping 70 matching lines @@
 }
 
 void UserManagerScreenHandler::HandleInitialize(const base::ListValue* args) {
   // If the URL has a hash parameter, store it for later.
   args->GetString(0, &url_hash_);
 
   SendUserList();
   web_ui()->CallJavascriptFunction("cr.ui.Oobe.showUserManagerScreen",
       base::FundamentalValue(IsGuestModeEnabled()),
       base::FundamentalValue(IsAddPersonEnabled()));
-  desktop_type_ = chrome::GetHostDesktopTypeForNativeView(
-      web_ui()->GetWebContents()->GetNativeView());
 
   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(this);
 }
 
 void UserManagerScreenHandler::HandleAddUser(const base::ListValue* args) {
   if (!IsAddPersonEnabled()) {
     // The 'Add User' UI should not be showing.
     NOTREACHED();
     return;
   }
   profiles::CreateAndSwitchToNewProfile(
-      desktop_type_,
       base::Bind(&UserManagerScreenHandler::OnSwitchToProfileComplete,
                  weak_ptr_factory_.GetWeakPtr()),
       ProfileMetrics::ADD_NEW_USER_MANAGER);
 }
 
 void UserManagerScreenHandler::HandleAuthenticatedLaunchUser(
     const base::ListValue* args) {
   const base::Value* profile_path_value;
   if (!args->Get(0, &profile_path_value))
     return;
@@ skipping 67 matching lines @@
     NOTREACHED();
     return;
   }
 
   if (!profiles::IsMultipleProfilesEnabled()) {
     NOTREACHED();
     return;
   }
 
   g_browser_process->profile_manager()->ScheduleProfileForDeletion(
-      profile_path,
-      base::Bind(&OpenNewWindowForProfile, desktop_type_));
+      profile_path, base::Bind(&OpenNewWindowForProfile));
   ProfileMetrics::LogProfileDeleteUser(
       ProfileMetrics::DELETE_PROFILE_USER_MANAGER);
 }
 
 void UserManagerScreenHandler::HandleLaunchGuest(const base::ListValue* args) {
   if (IsGuestModeEnabled()) {
     profiles::SwitchToGuestProfile(
-        desktop_type_,
         base::Bind(&UserManagerScreenHandler::OnSwitchToProfileComplete,
                    weak_ptr_factory_.GetWeakPtr()));
   } else {
     // The UI should have prevented the user from allowing the selection of
     // guest mode.
     NOTREACHED();
   }
 }
 
 void UserManagerScreenHandler::HandleLaunchUser(const base::ListValue* args) {
@@ skipping 17 matching lines @@
   // It's possible that a user breaks into the user-manager page using the
   // JavaScript Inspector and causes a "locked" profile to call this
   // unauthenticated version of "launch" instead of the proper one.  Thus,
   // we have to validate in (secure) C++ code that it really is a profile
   // not needing authentication.  If it is, just ignore the "launch" request.
   if (info_cache.ProfileIsSigninRequiredAtIndex(profile_index))
     return;
   ProfileMetrics::LogProfileAuthResult(ProfileMetrics::AUTH_UNNECESSARY);
 
   profiles::SwitchToProfile(
-      profile_path,
-      desktop_type_,
-      false,  /* reuse any existing windows */
+      profile_path, false, /* reuse any existing windows */
       base::Bind(&UserManagerScreenHandler::OnSwitchToProfileComplete,
                  weak_ptr_factory_.GetWeakPtr()),
       ProfileMetrics::SWITCH_PROFILE_MANAGER);
 }
 
 void UserManagerScreenHandler::HandleAttemptUnlock(
     const base::ListValue* args) {
   std::string email;
   CHECK(args->GetString(0, &email));
   GetScreenlockRouter(email)
@@ skipping 381 matching lines @@
 }
 
 void UserManagerScreenHandler::ReportAuthenticationResult(
     bool success,
     ProfileMetrics::ProfileAuth auth) {
   ProfileMetrics::LogProfileAuthResult(auth);
   email_address_.clear();
 
   if (success) {
     profiles::SwitchToProfile(
-        authenticating_profile_path_,
-        desktop_type_,
-        true,
+        authenticating_profile_path_, true,
         base::Bind(&UserManagerScreenHandler::OnSwitchToProfileComplete,
                    weak_ptr_factory_.GetWeakPtr()),
         ProfileMetrics::SWITCH_PROFILE_UNLOCK);
   } else {
     web_ui()->CallJavascriptFunction(
         "cr.ui.Oobe.showSignInError",
         base::FundamentalValue(0),
         base::StringValue(l10n_util::GetStringUTF8(
             auth == ProfileMetrics::AUTH_FAILED_OFFLINE ?
                 IDS_LOGIN_ERROR_AUTHENTICATING_OFFLINE :
@@ skipping 54 matching lines @@
     Profile* profile, Profile::CreateStatus profile_create_status) {
   Browser* browser = chrome::FindAnyBrowser(profile, false);
   if (browser && browser->window()) {
     OnBrowserWindowReady(browser);
   } else {
     registrar_.Add(this,
                    chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                    content::NotificationService::AllSources());
   }
 }