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

chrome/browser/ui/cocoa/profiles/user_manager_mac.mm

 // 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/cocoa/profiles/user_manager_mac.h"
 
 #include "base/callback.h"
 #include "base/mac/foundation_util.h"
 #include "chrome/app/chrome_command_ids.h"
 #import "chrome/browser/app_controller_mac.h"
@@ skipping 38 matching lines @@
 }
 
 // An open User Manager window. There can only be one open at a time. This
 // is reset to NULL when the window is closed.
 UserManagerMac* instance_ = nullptr;  // Weak.
 std::vector<base::Closure>* user_manager_shown_callbacks_for_testing_ = nullptr;
 BOOL instance_under_construction_ = NO;
 
 void CloseInstanceReauthDialog() {
   DCHECK(instance_);
-  instance_->CloseReauthDialog();
+  instance_->CloseDialog();
 }
 
 // The modal dialog host the User Manager uses to display the reauth dialog.
 class UserManagerModalHost : public web_modal::WebContentsModalDialogHost {
  public:
   UserManagerModalHost(gfx::NativeView host_view)
       : host_view_(host_view) {}
 
   gfx::Size GetMaximumDialogSize() override {
     return switches::UsePasswordSeparatedSigninFlow() ?
@@ skipping 100 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ReauthDialogDelegate);
 };
 
 }  // namespace
 
 // WindowController for the reauth dialog.
 @interface ReauthDialogWindowController
     : NSWindowController <NSWindowDelegate> {
  @private
   std::string emailAddress_;
+  GURL url_;
   content::WebContents* webContents_;
-  signin_metrics::Reason reason_;
   std::unique_ptr<ReauthDialogDelegate> webContentsDelegate_;
   std::unique_ptr<ConstrainedWindowMac> constrained_window_;
   std::unique_ptr<content::WebContents> reauthWebContents_;
 }
 - (id)initWithProfile:(Profile*)profile
                 email:(std::string)email
-               reason:(signin_metrics::Reason)reason
+                  url:(GURL)url
           webContents:(content::WebContents*)webContents;
 - (void)showURL:(const GURL&)url;
 - (void)close;
 @end
 
 @implementation ReauthDialogWindowController
 
 - (id)initWithProfile:(Profile*)profile
                 email:(std::string)email
-               reason:(signin_metrics::Reason)reason
+                  url:(GURL)url
           webContents:(content::WebContents*)webContents {
   webContents_ = webContents;
   emailAddress_ = email;
-  reason_ = reason;
+  url_ = url;
 
   NSRect frame = NSMakeRect(
       0, 0, UserManager::kReauthDialogWidth, UserManager::kReauthDialogHeight);
   base::scoped_nsobject<ConstrainedWindowCustomWindow> window(
       [[ConstrainedWindowCustomWindow alloc]
           initWithContentRect:frame
                     styleMask:NSTitledWindowMask | NSClosableWindowMask]);
   if ((self = [super initWithWindow:window])) {
     webContents_ = webContents;
 
@@ skipping 22 matching lines @@
   return self;
 }
 
 - (void)showURL:(const GURL&)url {
   reauthWebContents_->GetController().LoadURL(url, content::Referrer(),
                                               ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
                                               std::string());
 }
 
 - (void)show {
-  GURL url = signin::GetReauthURLWithEmail(
-      signin_metrics::AccessPoint::ACCESS_POINT_USER_MANAGER, reason_,
-      emailAddress_);
-  [self showURL:url];
+  [self showURL:url_];
 }
 
 - (void)closeButtonClicked:(NSButton*)button {
   [self close];
 }
 
 - (void)close {
   constrained_window_->CloseWebContentsModalDialog();
 }
 
@@ skipping 15 matching lines @@
   base::scoped_nsobject<ReauthDialogWindowController> reauth_window_controller_;
 }
 - (void)windowWillClose:(NSNotification*)notification;
 - (void)dealloc;
 - (id)initWithProfile:(Profile*)profile
          withObserver:(UserManagerMac*)userManagerObserver;
 - (void)showURL:(const GURL&)url;
 - (void)show;
 - (void)close;
 - (BOOL)isVisible;
-- (void)showReauthDialogWithProfile:(Profile*)profile
-                              email:(std::string)email
-                             reason:(signin_metrics::Reason)reason;
+- (void)showDialogWithProfile:(Profile*)profile
+                        email:(std::string)email
+                          url:(GURL)url;
 - (void)displayErrorMessage;
-- (void)closeReauthDialog;
+- (void)closeDialog;
 @end
 
 @implementation UserManagerWindowController
 
 - (id)initWithProfile:(Profile*)profile
          withObserver:(UserManagerMac*)userManagerObserver {
   // Center the window on the screen that currently has focus.
   NSScreen* mainScreen = [NSScreen mainScreen];
   CGFloat screenHeight = [mainScreen frame].size.height;
   CGFloat screenWidth = [mainScreen frame].size.width;
@@ skipping 84 matching lines @@
 -(BOOL)isVisible {
   return [[self window] isVisible];
 }
 
 - (void)windowWillClose:(NSNotification*)notification {
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   DCHECK(userManagerObserver_);
   userManagerObserver_->WindowWasClosed();
 }
 
-- (void)showReauthDialogWithProfile:(Profile*)profile
-                              email:(std::string)email
-                             reason:(signin_metrics::Reason)reason {
+- (void)showDialogWithProfile:(Profile*)profile
+                        email:(std::string)email
+                          url:(GURL)url {
   reauth_window_controller_.reset([[ReauthDialogWindowController alloc]
       initWithProfile:profile
                 email:email
-               reason:reason
+                  url:url
           webContents:webContents_.get()]);
 }
 
 - (void)displayErrorMessage {
   [reauth_window_controller_ showURL:GURL(chrome::kChromeUISigninErrorURL)];
 }
 
-- (void)closeReauthDialog {
+- (void)closeDialog {
   [reauth_window_controller_ close];
 }
 
 @end
 
 
 // static
 void UserManager::Show(
     const base::FilePath& profile_path_to_focus,
     profiles::UserManagerTutorialMode tutorial_mode,
@@ skipping 52 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;
+  GURL url = signin::GetReauthURLWithEmail(
+      signin_metrics::AccessPoint::ACCESS_POINT_USER_MANAGER, reason, email);
+  instance_->ShowDialog(browser_context, email, url);
+}
+
+// static
+void UserManager::HideDialog() {
+  // This method should only be called if the user manager is already showing.
+  if (!IsShowing())
+    return;
 
-  instance_->ShowReauthDialog(browser_context, email, reason);
+  instance_->CloseDialog();
 }
 
 // static
-void UserManager::HideReauthDialog() {
-  // This method should only be called if the user manager is already showing.
-  if (!IsShowing())
-    return;
-
-  instance_->CloseReauthDialog();
-}
-
-// static
 void UserManager::AddOnUserManagerShownCallbackForTesting(
     const base::Closure& callback) {
   if (!user_manager_shown_callbacks_for_testing_)
     user_manager_shown_callbacks_for_testing_ = new std::vector<base::Closure>;
   user_manager_shown_callbacks_for_testing_->push_back(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() {
   DCHECK(instance_);
   instance_->DisplayErrorMessage();
 }
 
 // static
+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();
 }
 
-void UserManagerMac::ShowReauthDialog(content::BrowserContext* browser_context,
-                                      const std::string& email,
-                                      signin_metrics::Reason reason) {
+void UserManagerMac::ShowDialog(content::BrowserContext* browser_context,
+                                const std::string& email,
+                                const GURL& url) {
   [window_controller_
-      showReauthDialogWithProfile:Profile::FromBrowserContext(browser_context)
-                            email:email
-                           reason:reason];
+      showDialogWithProfile:Profile::FromBrowserContext(browser_context)
+                      email:email
+                        url:url];
 }
 
-void UserManagerMac::CloseReauthDialog() {
-  [window_controller_ closeReauthDialog];
+void UserManagerMac::CloseDialog() {
+  [window_controller_ closeDialog];
 }
 
 UserManagerMac::UserManagerMac(Profile* profile) {
   window_controller_.reset([[UserManagerWindowController alloc]
       initWithProfile:profile withObserver:this]);
 }
 
 UserManagerMac::~UserManagerMac() {
 }
 
@@ skipping 11 matching lines @@
 void UserManagerMac::LogTimeToOpen() {
   if (user_manager_started_showing_ == base::Time())
     return;
 
   ProfileMetrics::LogTimeToOpenUserManager(
       base::Time::Now() - user_manager_started_showing_);
   user_manager_started_showing_ = base::Time();
 }
 
 void UserManagerMac::WindowWasClosed() {
-  CloseReauthDialog();
+  CloseDialog();
   instance_ = NULL;
   delete this;
 }
 
 void UserManagerMac::DisplayErrorMessage() {
   [window_controller_ displayErrorMessage];
 }
 
 void UserManagerMac::SetSigninProfilePath(const base::FilePath& profile_path) {
   signin_profile_path_ = profile_path;
 }
 
 base::FilePath UserManagerMac::GetSigninProfilePath() {
   return signin_profile_path_;
 }