Make the new Gaia password separated signin flow modal.

chrome/browser/ui/views/profiles/profile_chooser_view.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/ui/views/profiles/profile_chooser_view.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profile_metrics.h"
 #include "chrome/browser/profiles/profile_window.h"
 #include "chrome/browser/profiles/profiles_state.h"
 #include "chrome/browser/signin/chrome_signin_helper.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_error_controller_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/signin/signin_promo.h"
 #include "chrome/browser/signin/signin_ui_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/singleton_tabs.h"
 #include "chrome/browser/ui/user_manager.h"
+#include "chrome/browser/ui/views/profiles/signin_view_controller.h"
 #include "chrome/browser/ui/views/profiles/user_manager_view.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service_factory.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_error_controller.h"
 #include "components/signin/core/browser/signin_header_helper.h"
@@ skipping 32 matching lines @@
 #include "ui/views/layout/grid_layout.h"
 #include "ui/views/layout/layout_constants.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 
 // Helpers --------------------------------------------------------------------
 
 const int kFixedMenuWidth = 250;
 const int kButtonHeight = 32;
-const int kPasswordCombinedFixedGaiaViewHeight = 440;
 const int kPasswordCombinedFixedGaiaViewWidth = 360;
-const int kFixedGaiaViewHeight = 512;
 const int kFixedGaiaViewWidth = 448;
 const int kFixedAccountRemovalViewWidth = 280;
 const int kFixedSwitchUserViewWidth = 320;
 const int kLargeImageSide = 88;
 
 const int kVerticalSpacing = 16;
 
 const int kTitleViewNativeWidgetOffset = 8;
 
 bool IsProfileChooser(profiles::BubbleViewMode mode) {
@@ skipping 492 matching lines @@
       profile->IsChild()
           ? new ProfileBadge(gfx::VectorIconId::ACCOUNT_CHILD_INVERT, 26)
           : new ProfileBadge(gfx::VectorIconId::SUPERVISOR_ACCOUNT, 20);
 
   return gfx::ImageSkia(badge, badge->size());
 }
 
 // ProfileChooserView ---------------------------------------------------------
 
 // static
-ProfileChooserView* ProfileChooserView::profile_bubble_ = NULL;
+ProfileChooserView* ProfileChooserView::profile_bubble_ = nullptr;
 bool ProfileChooserView::close_on_deactivate_for_testing_ = true;
 
 // static
 void ProfileChooserView::ShowBubble(
     profiles::BubbleViewMode view_mode,
     profiles::TutorialMode tutorial_mode,
     const signin::ManageAccountsParams& manage_accounts_params,
     views::View* anchor_view,
     views::BubbleBorder::Arrow arrow,
     views::BubbleBorder::BubbleAlignment border_alignment,
     Browser* browser) {
   // Don't start creating the view if it would be an empty fast user switcher.
   // It has to happen here to prevent the view system from creating an empty
   // container.
   if (view_mode == profiles::BUBBLE_VIEW_MODE_FAST_PROFILE_CHOOSER &&
       !profiles::HasProfileSwitchTargets(browser->profile())) {
     return;
   }
 
   if (IsShowing()) {
     if (tutorial_mode != profiles::TUTORIAL_MODE_NONE) {
       profile_bubble_->tutorial_mode_ = tutorial_mode;
-      profile_bubble_->ShowView(view_mode, profile_bubble_->avatar_menu_.get());
+      profile_bubble_->ShowViewFromMode(view_mode);
     }
     return;
   }
 
   profile_bubble_ = new ProfileChooserView(anchor_view, arrow, browser,
       view_mode, tutorial_mode, manage_accounts_params.service_type);
   views::BubbleDelegateView::CreateBubble(profile_bubble_);
   profile_bubble_->set_close_on_deactivate(close_on_deactivate_for_testing_);
   profile_bubble_->SetAlignment(border_alignment);
   profile_bubble_->GetWidget()->Show();
@@ skipping 84 matching lines @@
       switches::IsEnableAccountConsistency() &&
       avatar_menu_->GetItemAt(avatar_menu_->GetActiveProfileIndex()).
           signed_in) {
     view_mode_ = profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT;
   }
 
   // The arrow keys can be used to tab between items.
   AddAccelerator(ui::Accelerator(ui::VKEY_DOWN, ui::EF_NONE));
   AddAccelerator(ui::Accelerator(ui::VKEY_UP, ui::EF_NONE));
 
-  ShowView(view_mode_, avatar_menu_.get());
+  ShowViewFromMode(view_mode_);
 }
 
 void ProfileChooserView::OnAvatarMenuChanged(
     AvatarMenu* avatar_menu) {
   if (IsProfileChooser(view_mode_) ||
       view_mode_ == profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT) {
     // Refresh the view with the new menu. We can't just update the local copy
     // as this may have been triggered by a sign out action, in which case
     // the view is being destroyed.
     ShowView(view_mode_, avatar_menu);
   }
 }
 
 void ProfileChooserView::OnRefreshTokenAvailable(
     const std::string& account_id) {
   if (view_mode_ == profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT ||
       view_mode_ == profiles::BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT ||
       view_mode_ == profiles::BUBBLE_VIEW_MODE_GAIA_REAUTH) {
     // The account management UI is only available through the
     // --enable-account-consistency flag.
-    ShowView(switches::IsEnableAccountConsistency() ?
+    ShowViewFromMode(switches::IsEnableAccountConsistency() ?
         profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT :
-        profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER, avatar_menu_.get());
+        profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER);
   }
 }
 
 void ProfileChooserView::OnRefreshTokenRevoked(const std::string& account_id) {
   // Refresh the account management view when an account is removed from the
   // profile.
   if (view_mode_ == profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT)
-    ShowView(profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT, avatar_menu_.get());
+    ShowViewFromMode(profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT);
 }
 
 void ProfileChooserView::ShowView(profiles::BubbleViewMode view_to_display,
                                   AvatarMenu* avatar_menu) {
   // The account management view should only be displayed if the active profile
   // is signed in.
   if (view_to_display == profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT) {
     DCHECK(switches::IsEnableAccountConsistency());
     const AvatarMenu::Item& active_item = avatar_menu->GetItemAt(
         avatar_menu->GetActiveProfileIndex());
@@ skipping 14 matching lines @@
   views::GridLayout* layout = nullptr;
   views::View* sub_view = nullptr;
   views::View* view_to_focus = nullptr;
   switch (view_mode_) {
     case profiles::BUBBLE_VIEW_MODE_GAIA_SIGNIN:
     case profiles::BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT:
     case profiles::BUBBLE_VIEW_MODE_GAIA_REAUTH: {
       const int width = switches::UsePasswordSeparatedSigninFlow()
           ? kFixedGaiaViewWidth : kPasswordCombinedFixedGaiaViewWidth;
       layout = CreateSingleColumnLayout(this, width);
+      DCHECK(!switches::UsePasswordSeparatedSigninFlow());
       sub_view = CreateGaiaSigninView(&view_to_focus);
       break;
     }
     case profiles::BUBBLE_VIEW_MODE_ACCOUNT_REMOVAL:
       layout = CreateSingleColumnLayout(this, kFixedAccountRemovalViewWidth);
       sub_view = CreateAccountRemovalView();
       break;
     case profiles::BUBBLE_VIEW_MODE_SWITCH_USER:
       layout = CreateSingleColumnLayout(this, kFixedSwitchUserViewWidth);
       sub_view = CreateSwitchUserView();
@@ skipping 13 matching lines @@
 
   layout->StartRow(1, 0);
   layout->AddView(sub_view);
   Layout();
   if (GetBubbleFrameView())
     SizeToContents();
   if (view_to_focus)
     view_to_focus->RequestFocus();
 }
 
+void ProfileChooserView::ShowViewFromMode(profiles::BubbleViewMode mode) {
+  if (SigninViewController::ShouldShowModalSigninForMode(mode)) {
+    BrowserWindow::AvatarBubbleMode converted_mode =
+        BrowserWindow::AVATAR_BUBBLE_MODE_DEFAULT;
+    if (mode == profiles::BUBBLE_VIEW_MODE_GAIA_SIGNIN) {
+      converted_mode = BrowserWindow::AVATAR_BUBBLE_MODE_SIGNIN;
+    } else if (mode == profiles::BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT) {
+      converted_mode = BrowserWindow::AVATAR_BUBBLE_MODE_ADD_ACCOUNT;
+    } else if (mode == profiles::BUBBLE_VIEW_MODE_GAIA_REAUTH) {
+      converted_mode = BrowserWindow::AVATAR_BUBBLE_MODE_REAUTH;
+    }
+
+    browser_->window()->ShowModalSigninWindow(converted_mode);
+  } else {
+    ShowView(mode, avatar_menu_.get());
+  }
+}
+
 void ProfileChooserView::WindowClosing() {
   DCHECK_EQ(profile_bubble_, this);
   profile_bubble_ = NULL;
 
   if (tutorial_mode_ == profiles::TUTORIAL_MODE_CONFIRM_SIGNIN) {
     LoginUIServiceFactory::GetForProfile(browser_->profile())->
         SyncConfirmationUIClosed(false /* configure_sync_first */);
   }
 }
 
@@ skipping 31 matching lines @@
     }
     PostActionPerformed(ProfileMetrics::PROFILE_DESKTOP_MENU_OPEN_USER_MANAGER);
   } else if (sender == go_incognito_button_) {
     DCHECK(ShouldShowGoIncognito());
     chrome::NewIncognitoWindow(browser_);
     PostActionPerformed(ProfileMetrics::PROFILE_DESKTOP_MENU_GO_INCOGNITO);
   } else if (sender == lock_button_) {
     profiles::LockProfile(browser_->profile());
     PostActionPerformed(ProfileMetrics::PROFILE_DESKTOP_MENU_LOCK);
   } else if (sender == auth_error_email_button_) {
-    ShowView(profiles::BUBBLE_VIEW_MODE_GAIA_REAUTH, avatar_menu_.get());
+    ShowViewFromMode(profiles::BUBBLE_VIEW_MODE_GAIA_REAUTH);
   } else if (sender == tutorial_sync_settings_ok_button_) {
     LoginUIServiceFactory::GetForProfile(browser_->profile())->
         SyncConfirmationUIClosed(false /* configure_sync_first */);
     DismissTutorial();
     ProfileMetrics::LogProfileNewAvatarMenuSignin(
         ProfileMetrics::PROFILE_AVATAR_MENU_SIGNIN_OK);
   } else if (sender == tutorial_close_button_) {
     DCHECK(tutorial_mode_ != profiles::TUTORIAL_MODE_NONE &&
            tutorial_mode_ != profiles::TUTORIAL_MODE_CONFIRM_SIGNIN);
     DismissTutorial();
   } else if (sender == tutorial_see_whats_new_button_) {
     ProfileMetrics::LogProfileNewAvatarMenuUpgrade(
         ProfileMetrics::PROFILE_AVATAR_MENU_UPGRADE_WHATS_NEW);
     UserManager::Show(base::FilePath(),
                       profiles::USER_MANAGER_TUTORIAL_OVERVIEW,
                       profiles::USER_MANAGER_SELECT_PROFILE_NO_ACTION);
   } else if (sender == remove_account_button_) {
     RemoveAccount();
   } else if (sender == account_removal_cancel_button_) {
     account_id_to_remove_.clear();
-    ShowView(profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT, avatar_menu_.get());
+    ShowViewFromMode(profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT);
   } else if (sender == gaia_signin_cancel_button_) {
     // The account management view is only available with the
     // --enable-account-consistency flag.
     bool account_management_available =
         SigninManagerFactory::GetForProfile(browser_->profile())->
             IsAuthenticated() &&
         switches::IsEnableAccountConsistency();
-    ShowView(account_management_available ?
+    ShowViewFromMode(account_management_available ?
         profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT :
-        profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER, avatar_menu_.get());
+        profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER);
   } else if (sender == current_profile_photo_) {
     avatar_menu_->EditProfile(avatar_menu_->GetActiveProfileIndex());
     PostActionPerformed(ProfileMetrics::PROFILE_DESKTOP_MENU_EDIT_IMAGE);
   } else if (sender == signin_current_profile_link_) {
-    ShowView(profiles::BUBBLE_VIEW_MODE_GAIA_SIGNIN, avatar_menu_.get());
+    ShowViewFromMode(profiles::BUBBLE_VIEW_MODE_GAIA_SIGNIN);
   } else if (sender == add_person_button_) {
     ProfileMetrics::LogProfileNewAvatarMenuNotYou(
         ProfileMetrics::PROFILE_AVATAR_MENU_NOT_YOU_ADD_PERSON);
     UserManager::Show(base::FilePath(),
                       profiles::USER_MANAGER_NO_TUTORIAL,
                       profiles::USER_MANAGER_SELECT_PROFILE_NO_ACTION);
   } else if (sender == disconnect_button_) {
     ProfileMetrics::LogProfileNewAvatarMenuNotYou(
         ProfileMetrics::PROFILE_AVATAR_MENU_NOT_YOU_DISCONNECT);
     chrome::ShowSettings(browser_);
   } else if (sender == switch_user_cancel_button_) {
-    ShowView(profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER, avatar_menu_.get());
+    ShowViewFromMode(profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER);
     ProfileMetrics::LogProfileNewAvatarMenuNotYou(
         ProfileMetrics::PROFILE_AVATAR_MENU_NOT_YOU_BACK);
   } else {
     // Either one of the "other profiles", or one of the profile accounts
     // buttons was pressed.
     ButtonIndexes::const_iterator profile_match =
         open_other_profile_indexes_map_.find(sender);
     if (profile_match != open_other_profile_indexes_map_.end()) {
       avatar_menu_->SwitchToProfile(
           profile_match->second,
           ui::DispositionFromEventFlags(event.flags()) == NEW_WINDOW,
           ProfileMetrics::SWITCH_PROFILE_ICON);
     } else {
       // This was a profile accounts button.
       AccountButtonIndexes::const_iterator account_match =
           delete_account_button_map_.find(sender);
       if (account_match != delete_account_button_map_.end()) {
         account_id_to_remove_ = account_match->second;
-        ShowView(profiles::BUBBLE_VIEW_MODE_ACCOUNT_REMOVAL,
-            avatar_menu_.get());
+        ShowViewFromMode(profiles::BUBBLE_VIEW_MODE_ACCOUNT_REMOVAL);
       } else {
         account_match = reauth_account_button_map_.find(sender);
         DCHECK(account_match != reauth_account_button_map_.end());
-        ShowView(profiles::BUBBLE_VIEW_MODE_GAIA_REAUTH, avatar_menu_.get());
+        ShowViewFromMode(profiles::BUBBLE_VIEW_MODE_GAIA_REAUTH);
       }
     }
   }
 }
 
 void ProfileChooserView::RemoveAccount() {
   DCHECK(!account_id_to_remove_.empty());
   ProfileOAuth2TokenService* oauth2_token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(browser_->profile());
   if (oauth2_token_service) {
     oauth2_token_service->RevokeCredentials(account_id_to_remove_);
     PostActionPerformed(ProfileMetrics::PROFILE_DESKTOP_MENU_REMOVE_ACCT);
   }
   account_id_to_remove_.clear();
 
-  ShowView(profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT, avatar_menu_.get());
+  ShowViewFromMode(profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT);
 }
 
 void ProfileChooserView::LinkClicked(views::Link* sender, int event_flags) {
   if (sender == manage_accounts_link_) {
     // This link can either mean show/hide the account management view,
     // depending on which view it is displayed. ShowView() will DCHECK if
     // the account management view is displayed for non signed-in users.
-    ShowView(
+    ShowViewFromMode(
         view_mode_ == profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT ?
             profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER :
-            profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT,
-        avatar_menu_.get());
+            profiles::BUBBLE_VIEW_MODE_ACCOUNT_MANAGEMENT);
   } else if (sender == add_account_link_) {
-    ShowView(profiles::BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT, avatar_menu_.get());
+    ShowViewFromMode(profiles::BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT);
     PostActionPerformed(ProfileMetrics::PROFILE_DESKTOP_MENU_ADD_ACCT);
   } else if (sender == tutorial_sync_settings_link_) {
     LoginUIServiceFactory::GetForProfile(browser_->profile())->
         SyncConfirmationUIClosed(true /* configure_sync_first */);
     tutorial_mode_ = profiles::TUTORIAL_MODE_NONE;
     ProfileMetrics::LogProfileNewAvatarMenuSignin(
         ProfileMetrics::PROFILE_AVATAR_MENU_SIGNIN_SETTINGS);
   } else if (sender == tutorial_not_you_link_) {
     ProfileMetrics::LogProfileNewAvatarMenuUpgrade(
         ProfileMetrics::PROFILE_AVATAR_MENU_UPGRADE_NOT_YOU);
-    ShowView(profiles::BUBBLE_VIEW_MODE_SWITCH_USER, avatar_menu_.get());
+    ShowViewFromMode(profiles::BUBBLE_VIEW_MODE_SWITCH_USER);
   } else {
     DCHECK(sender == tutorial_learn_more_link_);
     signin_ui_util::ShowSigninErrorLearnMorePage(browser_->profile());
   }
 }
 
 void ProfileChooserView::StyledLabelLinkClicked(views::StyledLabel* label,
                                                 const gfx::Range& range,
                                                 int event_flags) {
   chrome::ShowSettings(browser_);
@@ skipping 137 matching lines @@
         signin_ui_util::kUpgradeWelcomeTutorialShowMax + 1);
   }
 
   if (tutorial_mode_ == profiles::TUTORIAL_MODE_RIGHT_CLICK_SWITCHING) {
     PrefService* local_state = g_browser_process->local_state();
     local_state->SetBoolean(
         prefs::kProfileAvatarRightClickTutorialDismissed, true);
   }
 
   tutorial_mode_ = profiles::TUTORIAL_MODE_NONE;
-  ShowView(profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER, avatar_menu_.get());
+  ShowViewFromMode(profiles::BUBBLE_VIEW_MODE_PROFILE_CHOOSER);
 }
 
 views::View* ProfileChooserView::CreateTutorialViewIfNeeded(
     const AvatarMenu::Item& item) {
   if (tutorial_mode_ == profiles::TUTORIAL_MODE_CONFIRM_SIGNIN)
     return CreateSigninConfirmationView();
 
   if (tutorial_mode_ == profiles::TUTORIAL_MODE_SHOW_ERROR)
     return CreateSigninErrorView();
 
@@ skipping 450 matching lines @@
     email_button->set_notify_enter_exit_on_child(true);
     email_button->AddChildView(delete_button);
 
     // Save the original email address, as the button text could be elided.
     delete_account_button_map_[delete_button] = account_id;
   }
 }
 
 views::View* ProfileChooserView::CreateGaiaSigninView(
     views::View** signin_content_view) {
-  GURL url;
+  views::WebView* web_view = SigninViewController::CreateGaiaWebView(
+      this, view_mode_, browser_->profile());
+
   int message_id;
-
   switch (view_mode_) {
     case profiles::BUBBLE_VIEW_MODE_GAIA_SIGNIN:
-      url = signin::GetPromoURL(signin_metrics::SOURCE_AVATAR_BUBBLE_SIGN_IN,
-                                false /* auto_close */,
-                                true /* is_constrained */);
       message_id = IDS_PROFILES_GAIA_SIGNIN_TITLE;
       break;
     case profiles::BUBBLE_VIEW_MODE_GAIA_ADD_ACCOUNT:
-      url = signin::GetPromoURL(
-          signin_metrics::SOURCE_AVATAR_BUBBLE_ADD_ACCOUNT,
-          false /* auto_close */,
-          true /* is_constrained */);
       message_id = IDS_PROFILES_GAIA_ADD_ACCOUNT_TITLE;
       break;
     case profiles::BUBBLE_VIEW_MODE_GAIA_REAUTH: {
-      DCHECK(HasAuthError(browser_->profile()));
-      url = signin::GetReauthURL(browser_->profile(),
-                                 GetAuthErrorAccountId(browser_->profile()));
       message_id = IDS_PROFILES_GAIA_REAUTH_TITLE;
       break;
     }
     default:
       NOTREACHED() << "Called with invalid mode=" << view_mode_;
       return NULL;
   }
 
-  // Adds Gaia signin webview.
-  const gfx::Size pref_size = switches::UsePasswordSeparatedSigninFlow()
-      ? gfx::Size(kFixedGaiaViewWidth, kFixedGaiaViewHeight)
-      : gfx::Size(kPasswordCombinedFixedGaiaViewWidth,
-                  kPasswordCombinedFixedGaiaViewHeight);
-  Profile* profile = browser_->profile();
-  views::WebView* web_view = new views::WebView(profile);
-  web_view->LoadInitialURL(url);
-  web_view->GetWebContents()->SetDelegate(this);
-  web_view->SetPreferredSize(pref_size);
-  content::RenderWidgetHostView* rwhv =
-      web_view->GetWebContents()->GetRenderWidgetHostView();
-  if (rwhv)
-    rwhv->SetBackgroundColor(profiles::kAvatarBubbleGaiaBackgroundColor);
-
   if (signin_content_view)
     *signin_content_view = web_view;
 
-  if (switches::UsePasswordSeparatedSigninFlow()) {
-    gaia_signin_cancel_button_ = CreateBackButton(this);
-    HostView* host = new HostView();
-    host->Initialize(gaia_signin_cancel_button_, web_view);
-    return host;
-  }
-
   TitleCard* title_card = new TitleCard(l10n_util::GetStringUTF16(message_id),
                                         this,
                                         &gaia_signin_cancel_button_);
   return TitleCard::AddPaddedTitleCard(
       web_view, title_card, kPasswordCombinedFixedGaiaViewWidth);
 }
 
 views::View* ProfileChooserView::CreateAccountRemovalView() {
   views::View* view = new views::View();
   views::GridLayout* layout = CreateSingleColumnLayout(
@@ skipping 190 matching lines @@
       IncognitoModePrefs::GetAvailability(browser_->profile()->GetPrefs()) !=
           IncognitoModePrefs::DISABLED;
   return incognito_available && !browser_->profile()->IsGuestSession();
 }
 
 void ProfileChooserView::PostActionPerformed(
     ProfileMetrics::ProfileDesktopMenu action_performed) {
   ProfileMetrics::LogProfileDesktopMenu(action_performed, gaia_service_type_);
   gaia_service_type_ = signin::GAIA_SERVICE_TYPE_NONE;
 }