Remove HostDesktopType from profiles

chrome/browser/ui/sync/one_click_signin_sync_starter.cc

 // Copyright (c) 2012 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/sync/one_click_signin_sync_starter.h"
 
 #include <stddef.h>
 
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 72 matching lines @@
     const std::string& refresh_token,
     StartSyncMode start_mode,
     content::WebContents* web_contents,
     ConfirmationRequired confirmation_required,
     const GURL& current_url,
     const GURL& continue_url,
     Callback sync_setup_completed_callback)
     : content::WebContentsObserver(web_contents),
       profile_(NULL),
       start_mode_(start_mode),
-      desktop_type_(chrome::HOST_DESKTOP_TYPE_NATIVE),
       confirmation_required_(confirmation_required),
       current_url_(current_url),
       continue_url_(continue_url),
       sync_setup_completed_callback_(sync_setup_completed_callback),
       weak_pointer_factory_(this) {
   DCHECK(profile);
   DCHECK(web_contents || continue_url.is_empty());
   BrowserList::AddObserver(this);
   Initialize(profile, browser);
 
@@ skipping 20 matching lines @@
   DCHECK(profile);
 
   if (profile_)
     LoginUIServiceFactory::GetForProfile(profile_)->RemoveObserver(this);
 
   profile_ = profile;
   browser_ = browser;
 
   LoginUIServiceFactory::GetForProfile(profile_)->AddObserver(this);
 
-  // Cache the parent desktop for the browser, so we can reuse that same
-  // desktop for any UI we want to display.
-  if (browser) {
-    desktop_type_ = browser->host_desktop_type();
-  } else {
-    desktop_type_ = chrome::GetActiveDesktop();
-  }
-
   signin_tracker_ = SigninTrackerFactory::CreateForProfile(profile_, this);
 
   // Let the sync service know that setup is in progress so it doesn't start
   // syncing until the user has finished any configuration.
   ProfileSyncService* profile_sync_service = GetProfileSyncService();
   if (profile_sync_service)
     profile_sync_service->SetSetupInProgress(true);
 
   // Make sure the syncing is requested, otherwise the SigninManager
   // will not be able to complete successfully.
@@ skipping 74 matching lines @@
 
   DVLOG(1) << "Policy registration succeeded: dm_token=" << dm_token;
 
   // Stash away a copy of our CloudPolicyClient (should not already have one).
   DCHECK(dm_token_.empty());
   DCHECK(client_id_.empty());
   dm_token_ = dm_token;
   client_id_ = client_id;
 
   // Allow user to create a new profile before continuing with sign-in.
-  browser_ = EnsureBrowser(browser_, profile_, desktop_type_);
+  browser_ = EnsureBrowser(browser_, profile_);
   content::WebContents* web_contents =
       browser_->tab_strip_model()->GetActiveWebContents();
   if (!web_contents) {
     CancelSigninAndDelete();
     return;
   }
 
   content::RecordAction(
       base::UserMetricsAction("Signin_Show_EnterpriseAccountPrompt"));
   TabDialogs::FromWebContents(web_contents)->ShowProfileSigninConfirmation(
@@ skipping 33 matching lines @@
   DCHECK(!dm_token_.empty());
   DCHECK(!client_id_.empty());
   // Create a new profile and have it call back when done so we can inject our
   // signin credentials.
   size_t icon_index = g_browser_process->profile_manager()->
       GetProfileInfoCache().ChooseAvatarIconIndexForNewProfile();
   ProfileManager::CreateMultiProfileAsync(
       base::UTF8ToUTF16(signin->GetUsernameForAuthInProgress()),
       profiles::GetDefaultAvatarIconUrl(icon_index),
       base::Bind(&OneClickSigninSyncStarter::CompleteInitForNewProfile,
-                 weak_pointer_factory_.GetWeakPtr(), desktop_type_),
+                 weak_pointer_factory_.GetWeakPtr()),
       std::string());
 }
 
 void OneClickSigninSyncStarter::CompleteInitForNewProfile(
-    chrome::HostDesktopType desktop_type,
     Profile* new_profile,
     Profile::CreateStatus status) {
   DCHECK_NE(profile_, new_profile);
 
   // TODO(atwilson): On error, unregister the client to release the DMToken
   // and surface a better error for the user.
   switch (status) {
     case Profile::CREATE_STATUS_LOCAL_FAIL: {
       NOTREACHED() << "Error creating new profile";
       CancelSigninAndDelete();
@@ skipping 30 matching lines @@
 
       // Load policy for the just-created profile - once policy has finished
       // loading the signin process will complete.
       LoadPolicyWithCachedCredentials();
 
       // Open the profile's first window, after all initialization.
       profiles::FindOrCreateNewWindowForProfile(
         new_profile,
         chrome::startup::IS_PROCESS_STARTUP,
         chrome::startup::IS_FIRST_RUN,
-        desktop_type,
         false);
       break;
     }
     case Profile::CREATE_STATUS_REMOTE_FAIL:
     case Profile::CREATE_STATUS_CANCELED:
     case Profile::MAX_CREATE_STATUS: {
       NOTREACHED() << "Invalid profile creation status";
       CancelSigninAndDelete();
       return;
     }
   }
 }
 #endif
 
 void OneClickSigninSyncStarter::CancelSigninAndDelete() {
   SigninManagerFactory::GetForProfile(profile_)
       ->SignOut(signin_metrics::ABORT_SIGNIN,
                 signin_metrics::SignoutDelete::IGNORE_METRIC);
   // The statement above results in a call to SigninFailed() which will free
   // this object, so do not refer to the OneClickSigninSyncStarter object
   // after this point.
 }
 
 void OneClickSigninSyncStarter::ConfirmAndSignin() {
   SigninManager* signin = SigninManagerFactory::GetForProfile(profile_);
   if (confirmation_required_ == CONFIRM_UNTRUSTED_SIGNIN) {
-    browser_ = EnsureBrowser(browser_, profile_, desktop_type_);
+    browser_ = EnsureBrowser(browser_, profile_);
     content::RecordAction(
         base::UserMetricsAction("Signin_Show_UntrustedSigninPrompt"));
     // Display a confirmation dialog to the user.
     browser_->window()->ShowOneClickSigninBubble(
         BrowserWindow::ONE_CLICK_SIGNIN_BUBBLE_TYPE_SAML_MODAL_DIALOG,
         base::UTF8ToUTF16(signin->GetUsernameForAuthInProgress()),
         base::string16(),  // No error message to display.
         base::Bind(&OneClickSigninSyncStarter::UntrustedSigninConfirmed,
                    weak_pointer_factory_.GetWeakPtr()));
     LoginUIServiceFactory::GetForProfile(profile_)->UntrustedLoginUIShown();
@@ skipping 135 matching lines @@
   if (web_contents() && !continue_url_.is_empty() &&
       start_mode_ != CONFIGURE_SYNC_FIRST) {
     LoadContinueUrl();
   }
 
   delete this;
 }
 
 void OneClickSigninSyncStarter::DisplayFinalConfirmationBubble(
     const base::string16& custom_message) {
-  browser_ = EnsureBrowser(browser_, profile_, desktop_type_);
+  browser_ = EnsureBrowser(browser_, profile_);
   LoginUIServiceFactory::GetForProfile(browser_->profile())->
       DisplayLoginResult(browser_, custom_message);
 }
 
 void OneClickSigninSyncStarter::DisplayModalSyncConfirmationWindow() {
-  browser_ = EnsureBrowser(browser_, profile_, desktop_type_);
+  browser_ = EnsureBrowser(browser_, profile_);
   browser_->ShowModalSyncConfirmationWindow();
 }
 
 // static
-Browser* OneClickSigninSyncStarter::EnsureBrowser(
-    Browser* browser,
-    Profile* profile,
-    chrome::HostDesktopType desktop_type) {
+Browser* OneClickSigninSyncStarter::EnsureBrowser(Browser* browser,
+                                                  Profile* profile) {
   if (!browser) {
     // The user just created a new profile or has closed the browser that
     // we used previously. Grab the most recently active browser or else
     // create a new one.
     browser = chrome::FindLastActiveWithProfile(profile);
     if (!browser) {
       browser = new Browser(Browser::CreateParams(profile));
       chrome::AddTabAt(browser, GURL(), -1, true);
     }
     browser->window()->Show();
   }
   return browser;
 }
 
 void OneClickSigninSyncStarter::ShowSettingsPage(bool configure_sync) {
   // Give the user a chance to configure things. We don't clear the
   // ProfileSyncService::setup_in_progress flag because we don't want sync
   // to start up until after the configure UI is displayed (the configure UI
   // will clear the flag when the user is done setting up sync).
   ProfileSyncService* profile_sync_service = GetProfileSyncService();
   LoginUIService* login_ui = LoginUIServiceFactory::GetForProfile(profile_);
   if (login_ui->current_login_ui()) {
     login_ui->current_login_ui()->FocusUI();
   } else {
-    browser_ = EnsureBrowser(browser_, profile_, desktop_type_);
+    browser_ = EnsureBrowser(browser_, profile_);
 
     // If the sign in tab is showing the native signin page or the blank page
     // for web-based flow, and is not about to be closed, use it to show the
     // settings UI.
     bool use_same_tab = false;
     if (web_contents()) {
       GURL current_url = web_contents()->GetLastCommittedURL();
       std::string constrained_key;
       net::GetValueForKeyInQuery(current_url, "constrained", &constrained_key);
       bool is_constrained = (constrained_key == "1");
@@ skipping 75 matching lines @@
                                             false /* user_gesture */);
 }
 
 void OneClickSigninSyncStarter::LoadContinueUrl() {
   web_contents()->GetController().LoadURL(
       continue_url_,
       content::Referrer(),
       ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
       std::string());
 }