Display error message when user try to open a locked supervised user profile when force-sign-in is …

chrome/browser/ui/views/profiles/user_manager_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/user_manager_view.h"
 
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
@@ skipping 37 matching lines @@
 
 namespace {
 
 // An open User Manager window. There can only be one open at a time. This
 // is reset to NULL when the window is closed.
 UserManagerView* instance_ = nullptr;
 base::Closure* user_manager_shown_callback_for_testing_ = nullptr;
 bool instance_under_construction_ = false;
 }  // namespace
 
-// ReauthDelegate---------------------------------------------------------------
+// Delegate---------------------------------------------------------------
 
-ReauthDelegate::ReauthDelegate(UserManagerView* parent,
-                               views::WebView* web_view,
-                               const std::string& email_address,
-                               signin_metrics::Reason reason)
-    : parent_(parent),
-      web_view_(web_view),
-      email_address_(email_address) {
+UserManagerDialogDelegate::UserManagerDialogDelegate(
+    UserManagerView* parent,
+    views::WebView* web_view,
+    const std::string& email_address,
+    const GURL& url)
+    : parent_(parent), web_view_(web_view), email_address_(email_address) {
   AddChildView(web_view_);
   SetLayoutManager(new views::FillLayout());
 
   web_view_->GetWebContents()->SetDelegate(this);
-
-  // Load the re-auth URL, prepopulated with the user's email address.
-  // Add the index of the profile to the URL so that the inline login page
-  // knows which profile to load and update the credentials.
-  GURL url = signin::GetReauthURLWithEmail(
-      signin_metrics::AccessPoint::ACCESS_POINT_USER_MANAGER, reason,
-      email_address_);
   web_view_->LoadInitialURL(url);
 }
 
-ReauthDelegate::~ReauthDelegate() {}
+UserManagerDialogDelegate::~UserManagerDialogDelegate() {}
 
-gfx::Size ReauthDelegate::GetPreferredSize() const {
-  return switches::UsePasswordSeparatedSigninFlow() ?
-      gfx::Size(UserManager::kReauthDialogWidth,
-                UserManager::kReauthDialogHeight) :
-      gfx::Size(UserManager::kPasswordCombinedReauthDialogWidth,
-                UserManager::kPasswordCombinedReauthDialogHeight);
+gfx::Size UserManagerDialogDelegate::GetPreferredSize() const {
+  return switches::UsePasswordSeparatedSigninFlow()
+             ? gfx::Size(UserManagerDialog::kDialogWidth,
+                         UserManagerDialog::kDialogHeight)
+             : gfx::Size(UserManagerDialog::kPasswordCombinedDialogWidth,
+                         UserManagerDialog::kPasswordCombinedDialogHeight);
 }
 
-void ReauthDelegate::DisplayErrorMessage() {
+void UserManagerDialogDelegate::DisplayErrorMessage() {
   web_view_->LoadInitialURL(GURL(chrome::kChromeUISigninErrorURL));
 }
 
-bool ReauthDelegate::CanResize() const {
+bool UserManagerDialogDelegate::CanResize() const {
   return true;
 }
 
-bool ReauthDelegate::CanMaximize() const  {
+bool UserManagerDialogDelegate::CanMaximize() const {
   return true;
 }
 
-bool ReauthDelegate::CanMinimize() const  {
+bool UserManagerDialogDelegate::CanMinimize() const {
   return true;
 }
 
-bool ReauthDelegate::ShouldUseCustomFrame() const {
+bool UserManagerDialogDelegate::ShouldUseCustomFrame() const {
   return false;
 }
 
-ui::ModalType ReauthDelegate::GetModalType() const {
+ui::ModalType UserManagerDialogDelegate::GetModalType() const {
   return ui::MODAL_TYPE_WINDOW;
 }
 
-void ReauthDelegate::DeleteDelegate() {
-  OnReauthDialogDestroyed();
+void UserManagerDialogDelegate::DeleteDelegate() {
+  OnDialogDestroyed();
   delete this;
 }
 
-base::string16 ReauthDelegate::GetWindowTitle() const {
+base::string16 UserManagerDialogDelegate::GetWindowTitle() const {
   return l10n_util::GetStringUTF16(IDS_PROFILES_GAIA_SIGNIN_TITLE);
 }
 
-int ReauthDelegate::GetDialogButtons() const {
+int UserManagerDialogDelegate::GetDialogButtons() const {
   return ui::DIALOG_BUTTON_NONE;
 }
 
-views::View* ReauthDelegate::GetInitiallyFocusedView() {
+views::View* UserManagerDialogDelegate::GetInitiallyFocusedView() {
   return static_cast<views::View*>(web_view_);
 }
 
-void ReauthDelegate::CloseReauthDialog() {
-  OnReauthDialogDestroyed();
+void UserManagerDialogDelegate::CloseDialog() {
+  OnDialogDestroyed();
   GetWidget()->Close();
 }
 
-void ReauthDelegate::OnReauthDialogDestroyed() {
+void UserManagerDialogDelegate::OnDialogDestroyed() {
   if (parent_) {
-    parent_->OnReauthDialogDestroyed();
+    parent_->OnDialogDestroyed();
     parent_ = nullptr;
   }
 }
 
 // UserManager -----------------------------------------------------------------
 
 // static
 void UserManager::Show(
     const base::FilePath& profile_path_to_focus,
     profiles::UserManagerTutorialMode tutorial_mode,
@@ skipping 52 matching lines @@
       if (!user_manager_shown_callback_for_testing_->is_null())
         user_manager_shown_callback_for_testing_->Run();
 
       delete user_manager_shown_callback_for_testing_;
       user_manager_shown_callback_for_testing_ = nullptr;
     }
   }
 }
 
 // static
-void UserManager::ShowReauthDialog(content::BrowserContext* browser_context,
-                                   const std::string& email,
-                                   signin_metrics::Reason reason) {
-  // This method should only be called if the user manager is already showing.
-  if (!IsShowing())
-    return;
-  instance_->ShowReauthDialog(browser_context, email, reason);
-}
-
-// static
-void UserManager::HideReauthDialog() {
-  // This method should only be called if the user manager is already showing.
-  if (instance_ && instance_->GetWidget()->IsVisible())
-    instance_->HideReauthDialog();
-}
-
-// static
 void UserManager::AddOnUserManagerShownCallbackForTesting(
     const base::Closure& callback) {
   DCHECK(!user_manager_shown_callback_for_testing_);
   user_manager_shown_callback_for_testing_ = new base::Closure(callback);
 }
 
 // static
-void UserManager::ShowSigninDialog(content::BrowserContext* browser_context,
-                                   const base::FilePath& profile_path) {
-  if (!IsShowing())
+base::FilePath UserManager::GetSigninProfilePath() {
+  return instance_->GetSigninProfilePath();
+}
+
+// UserManagerDialog
+// -------------------------------------------------------------
+
+// static
+void UserManagerDialog::ShowReauthDialog(
+    content::BrowserContext* browser_context,
+    const std::string& email,
+    signin_metrics::Reason reason) {
+  // This method should only be called if the user manager is already showing.
+  if (!UserManager::IsShowing())
     return;
-  instance_->SetSigninProfilePath(profile_path);
-  ShowReauthDialog(browser_context, std::string(),
-                   signin_metrics::Reason::REASON_SIGNIN_PRIMARY_ACCOUNT);
+  // Load the re-auth URL, prepopulated with the user's email address.
+  // Add the index of the profile to the URL so that the inline login page
+  // knows which profile to load and update the credentials.
+  GURL url = signin::GetReauthURLWithEmail(
+      signin_metrics::AccessPoint::ACCESS_POINT_USER_MANAGER, reason, email);
+  instance_->ShowDialog(browser_context, email, url);
 }
 
 // static
-void UserManager::DisplayErrorMessage() {
+void UserManagerDialog::ShowSigninDialog(
+    content::BrowserContext* browser_context,
+    const base::FilePath& profile_path) {
+  if (!UserManager::IsShowing())
+    return;
+  instance_->SetSigninProfilePath(profile_path);
+  GURL url = signin::GetPromoURL(
+      signin_metrics::AccessPoint::ACCESS_POINT_USER_MANAGER,
+      signin_metrics::Reason::REASON_SIGNIN_PRIMARY_ACCOUNT, true, true);
+  instance_->ShowDialog(browser_context, std::string(), url);
+}
+
+void UserManagerDialog::ShowDialogAndDisplayErrorMessage(
+    content::BrowserContext* browser_context) {
+  if (!UserManager::IsShowing())
+    return;
+  instance_->ShowDialog(browser_context, std::string(),
+                        GURL(chrome::kChromeUISigninErrorURL));
+}
+
+// static
+void UserManagerDialog::DisplayErrorMessage() {
   // This method should only be called if the user manager is already showing.
   DCHECK(instance_);
   instance_->DisplayErrorMessage();
 }
 
 // static
-base::FilePath UserManager::GetSigninProfilePath() {
-  return instance_->GetSigninProfilePath();
+void UserManagerDialog::HideDialog() {
+  if (instance_ && instance_->GetWidget()->IsVisible())
+    instance_->HideDialog();
 }
 
 // UserManagerView -------------------------------------------------------------
 
 UserManagerView::UserManagerView()
     : web_view_(nullptr),
       delegate_(nullptr),
       user_manager_started_showing_(base::Time()) {
   keep_alive_.reset(new ScopedKeepAlive(KeepAliveOrigin::USER_MANAGER_VIEW,
                                         KeepAliveRestartOption::DISABLED));
 }
 
 UserManagerView::~UserManagerView() {
-  HideReauthDialog();
+  HideDialog();
 }
 
 // static
 void UserManagerView::OnSystemProfileCreated(
     std::unique_ptr<UserManagerView> instance,
     base::AutoReset<bool>* pending,
     Profile* system_profile,
     const std::string& url) {
   // If we are showing the User Manager after locking a profile, change the
   // active profile to Guest.
   profiles::SetActiveProfileToGuestIfLocked();
 
   DCHECK(!instance_);
   instance_ = instance.release();  // |instance_| takes over ownership.
   instance_->Init(system_profile, GURL(url));
 }
 
-void UserManagerView::ShowReauthDialog(content::BrowserContext* browser_context,
-                                       const std::string& email,
-                                       signin_metrics::Reason reason) {
-  HideReauthDialog();
+void UserManagerView::ShowDialog(content::BrowserContext* browser_context,
+                                 const std::string& email,
+                                 const GURL& url) {
+  HideDialog();
   // The dialog delegate will be deleted when the widget closes. The created
   // WebView's lifetime is managed by the delegate.
-  delegate_ = new ReauthDelegate(this,
-                                 new views::WebView(browser_context),
-                                 email,
-                                 reason);
+  delegate_ = new UserManagerDialogDelegate(
+      this, new views::WebView(browser_context), email, url);
   gfx::NativeView parent = instance_->GetWidget()->GetNativeView();
   views::DialogDelegate::CreateDialogWidget(delegate_, nullptr, parent);
   delegate_->GetWidget()->Show();
 }
 
-void UserManagerView::HideReauthDialog() {
+void UserManagerView::HideDialog() {
   if (delegate_) {
-    delegate_->CloseReauthDialog();
+    delegate_->CloseDialog();
     DCHECK(!delegate_);
   }
 }
 
-void UserManagerView::OnReauthDialogDestroyed() {
+void UserManagerView::OnDialogDestroyed() {
   delegate_ = nullptr;
 }
 
 void UserManagerView::Init(Profile* system_profile, const GURL& url) {
   web_view_ = new views::WebView(system_profile);
   web_view_->set_allow_accelerators(true);
   AddChildView(web_view_);
   SetLayoutManager(new views::FillLayout);
   AddAccelerator(ui::Accelerator(ui::VKEY_W, ui::EF_CONTROL_DOWN));
   AddAccelerator(ui::Accelerator(ui::VKEY_F4, ui::EF_ALT_DOWN));
@@ skipping 119 matching lines @@
     delegate_->DisplayErrorMessage();
 }
 
 void UserManagerView::SetSigninProfilePath(const base::FilePath& profile_path) {
   signin_profile_path_ = profile_path;
 }
 
 base::FilePath UserManagerView::GetSigninProfilePath() {
   return signin_profile_path_;
 }