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 42 matching lines @@
 UserManagerView* instance_ = nullptr;
 base::Closure* user_manager_shown_callback_for_testing_ = nullptr;
 bool instance_under_construction_ = false;
 }  // namespace
 
 // ReauthDelegate---------------------------------------------------------------
 
 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) {
+                               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() {}
 
 gfx::Size ReauthDelegate::GetPreferredSize() const {
   return switches::UsePasswordSeparatedSigninFlow() ?
       gfx::Size(UserManager::kReauthDialogWidth,
                 UserManager::kReauthDialogHeight) :
       gfx::Size(UserManager::kPasswordCombinedReauthDialogWidth,
@@ skipping 120 matching lines @@
   }
 }
 
 // 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);
+  // 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::HideReauthDialog() {
-  // This method should only be called if the user manager is already showing.
+void UserManager::HideDialog() {
   if (instance_ && instance_->GetWidget()->IsVisible())
-    instance_->HideReauthDialog();
+    instance_->HideDialog();
 }
 
 // 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())
     return;
   instance_->SetSigninProfilePath(profile_path);
-  ShowReauthDialog(browser_context, std::string(),
-                   signin_metrics::Reason::REASON_SIGNIN_PRIMARY_ACCOUNT);
+  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);
 }
 
 // static
 void UserManager::DisplayErrorMessage() {
   // This method should only be called if the user manager is already showing.
   DCHECK(instance_);
   instance_->DisplayErrorMessage();
 }
 
+void UserManager::ShowDialogAndDisplayErrorMessage(
+    content::BrowserContext* browser_context) {
+  DCHECK(instance_);
+  instance_->ShowDialog(browser_context, std::string(),
+                        GURL(chrome::kChromeUISigninErrorURL));
+}
+
 // static
 base::FilePath UserManager::GetSigninProfilePath() {
   return instance_->GetSigninProfilePath();
 }
 
 // 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 ReauthDelegate(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();
     DCHECK(!delegate_);
   }
 }
 
 void UserManagerView::OnReauthDialogDestroyed() {
   delegate_ = nullptr;
 }
 
@@ skipping 126 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_;
 }