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 36 matching lines @@
     [controller windowChangedToProfile:profile];
   }
 }
 
 // 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() {
+void CloseInstanceDialog() {
   DCHECK(instance_);
-  instance_->CloseReauthDialog();
+  instance_->CloseDialog();
 }
 
-// The modal dialog host the User Manager uses to display the reauth dialog.
+// The modal dialog host the User Manager uses to display the dialog.
 class UserManagerModalHost : public web_modal::WebContentsModalDialogHost {
  public:
   UserManagerModalHost(gfx::NativeView host_view)
       : host_view_(host_view) {}
 
   gfx::Size GetMaximumDialogSize() override {
-    return switches::UsePasswordSeparatedSigninFlow() ?
-        gfx::Size(UserManager::kReauthDialogWidth,
-                  UserManager::kReauthDialogHeight) :
-        gfx::Size(UserManager::kPasswordCombinedReauthDialogWidth,
-                  UserManager::kPasswordCombinedReauthDialogHeight);
+    return switches::UsePasswordSeparatedSigninFlow()
+               ? gfx::Size(UserManagerProfileDialog::kDialogWidth,
+                           UserManagerProfileDialog::kDialogHeight)
+               : gfx::Size(
+                     UserManagerProfileDialog::kPasswordCombinedDialogWidth,
+                     UserManagerProfileDialog::kPasswordCombinedDialogHeight);
   }
 
   ~UserManagerModalHost() override {}
 
   gfx::NativeView GetHostView() const override {
     return host_view_;
   }
 
   gfx::Point GetDialogPosition(const gfx::Size& size) override {
     return gfx::Point(0, 0);
   }
 
   void AddObserver(web_modal::ModalDialogHostObserver* observer) override {}
   void RemoveObserver(web_modal::ModalDialogHostObserver* observer) override {}
 
  private:
   gfx::NativeView host_view_;
 };
 
 // The modal manager delegate allowing the display of constrained windows for
-// the reauth dialog.
+// the dialog.
 class UserManagerModalManagerDelegate :
     public web_modal::WebContentsModalDialogManagerDelegate {
  public:
   UserManagerModalManagerDelegate(gfx::NativeView host_view) {
     modal_host_.reset(new UserManagerModalHost(host_view));
   }
 
   web_modal::WebContentsModalDialogHost* GetWebContentsModalDialogHost()
       override {
     return modal_host_.get();
@@ skipping 28 matching lines @@
     BOOL isTextEditingCommand = [BrowserWindowUtils isTextEditingEvent:event];
 
     // Only handle close window Chrome accelerators and text editing ones.
     if (chromeCommandId == IDC_CLOSE_WINDOW || chromeCommandId == IDC_EXIT ||
         isTextEditingCommand) {
       [[NSApp mainMenu] performKeyEquivalent:event.os_event];
     }
   }
 };
 
-class ReauthDialogDelegate : public UserManager::BaseReauthDialogDelegate,
-                             public ConstrainedWindowMacDelegate {
+class UserManagerProfileDialogDelegate
+    : public UserManagerProfileDialog::BaseDialogDelegate,
+      public ConstrainedWindowMacDelegate {
  public:
-  ReauthDialogDelegate() {
+  UserManagerProfileDialogDelegate() {
     hotKeysWebContentsDelegate_.reset(new UserManagerWebContentsDelegate());
   }
 
-  // UserManager::BaseReauthDialogDelegate:
-  void CloseReauthDialog() override {
-    CloseInstanceReauthDialog();
-  }
+  // UserManagerProfileDialog::BaseDialogDelegate:
+  void CloseDialog() override { CloseInstanceDialog(); }
 
   // WebContentsDelegate::HandleKeyboardEvent:
   void HandleKeyboardEvent(
       content::WebContents* source,
       const content::NativeWebKeyboardEvent& event) override {
     hotKeysWebContentsDelegate_->HandleKeyboardEvent(source, event);
   }
 
   // ConstrainedWindowMacDelegate:
   void OnConstrainedWindowClosed(ConstrainedWindowMac* window) override {
-    CloseReauthDialog();
+    CloseDialog();
   }
 
  private:
   std::unique_ptr<UserManagerWebContentsDelegate> hotKeysWebContentsDelegate_;
 
-  DISALLOW_COPY_AND_ASSIGN(ReauthDialogDelegate);
+  DISALLOW_COPY_AND_ASSIGN(UserManagerProfileDialogDelegate);
 };
 
 }  // namespace
 
-// WindowController for the reauth dialog.
-@interface ReauthDialogWindowController
-    : NSWindowController <NSWindowDelegate> {
+// WindowController for the dialog.
+@interface DialogWindowController : NSWindowController<NSWindowDelegate> {
  @private
   std::string emailAddress_;
+  GURL url_;
   content::WebContents* webContents_;
-  signin_metrics::Reason reason_;
-  std::unique_ptr<ReauthDialogDelegate> webContentsDelegate_;
+  std::unique_ptr<UserManagerProfileDialogDelegate> webContentsDelegate_;
   std::unique_ptr<ConstrainedWindowMac> constrained_window_;
-  std::unique_ptr<content::WebContents> reauthWebContents_;
+  std::unique_ptr<content::WebContents> dialogWebContents_;
 }
 - (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
+@implementation DialogWindowController
 
 - (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);
+  NSRect frame = NSMakeRect(0, 0, UserManagerProfileDialog::kDialogWidth,
+                            UserManagerProfileDialog::kDialogHeight);
   base::scoped_nsobject<ConstrainedWindowCustomWindow> window(
       [[ConstrainedWindowCustomWindow alloc]
           initWithContentRect:frame
                     styleMask:NSTitledWindowMask | NSClosableWindowMask]);
   if ((self = [super initWithWindow:window])) {
     webContents_ = webContents;
 
-    reauthWebContents_.reset(content::WebContents::Create(
+    dialogWebContents_.reset(content::WebContents::Create(
         content::WebContents::CreateParams(profile)));
-    window.get().contentView = reauthWebContents_->GetNativeView();
-    webContentsDelegate_.reset(new ReauthDialogDelegate());
-    reauthWebContents_->SetDelegate(webContentsDelegate_.get());
+    window.get().contentView = dialogWebContents_->GetNativeView();
+    webContentsDelegate_.reset(new UserManagerProfileDialogDelegate());
+    dialogWebContents_->SetDelegate(webContentsDelegate_.get());
 
     base::scoped_nsobject<CustomConstrainedWindowSheet> sheet(
        [[CustomConstrainedWindowSheet alloc]
            initWithCustomWindow:[self window]]);
     constrained_window_ =
         CreateAndShowWebModalDialogMac(
             webContentsDelegate_.get(), webContents_, sheet);
 
     // The close button needs to call CloseWebContentsModalDialog() on the
     // constrained window isntead of just [window close] so grab a reference to
     // it in the title bar and change its action.
     auto closeButton = [window standardWindowButton:NSWindowCloseButton];
     [closeButton setTarget:self];
     [closeButton setAction:@selector(closeButtonClicked:)];
     [self show];
   }
 
   return self;
 }
 
 - (void)showURL:(const GURL&)url {
-  reauthWebContents_->GetController().LoadURL(url, content::Referrer(),
+  dialogWebContents_->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();
 }
 
 - (void)dealloc {
   constrained_window_->CloseWebContentsModalDialog();
 
   [super dealloc];
 }
 
 @end
 
 // Window controller for the User Manager view.
 @interface UserManagerWindowController : NSWindowController <NSWindowDelegate> {
  @private
   std::unique_ptr<content::WebContents> webContents_;
   std::unique_ptr<UserManagerWebContentsDelegate> webContentsDelegate_;
   UserManagerMac* userManagerObserver_;  // Weak.
   std::unique_ptr<UserManagerModalManagerDelegate> modal_manager_delegate_;
-  base::scoped_nsobject<ReauthDialogWindowController> reauth_window_controller_;
+  base::scoped_nsobject<DialogWindowController> dialog_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 {
-  reauth_window_controller_.reset([[ReauthDialogWindowController alloc]
+- (void)showDialogWithProfile:(Profile*)profile
+                        email:(std::string)email
+                          url:(GURL)url {
+  dialog_window_controller_.reset([[DialogWindowController alloc]
       initWithProfile:profile
                 email:email
-               reason:reason
+                  url:url
           webContents:webContents_.get()]);
 }
 
 - (void)displayErrorMessage {
-  [reauth_window_controller_ showURL:GURL(chrome::kChromeUISigninErrorURL)];
+  [dialog_window_controller_ showURL:GURL(chrome::kChromeUISigninErrorURL)];
 }
 
-- (void)closeReauthDialog {
-  [reauth_window_controller_ close];
+- (void)closeDialog {
+  [dialog_window_controller_ close];
 }
 
 @end
 
 
 // static
 void UserManager::Show(
     const base::FilePath& profile_path_to_focus,
     profiles::UserManagerTutorialMode tutorial_mode,
     profiles::UserManagerAction user_manager_action) {
@@ skipping 45 matching lines @@
           callback.Run();
       }
       // Delete the callback list after calling.
       delete user_manager_shown_callbacks_for_testing_;
       user_manager_shown_callbacks_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 (!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);
+base::FilePath UserManager::GetSigninProfilePath() {
+  return instance_->GetSigninProfilePath();
 }
 
 // static
-void UserManager::DisplayErrorMessage() {
+void UserManagerProfileDialog::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;
+  GURL url = signin::GetReauthURLWithEmail(
+      signin_metrics::AccessPoint::ACCESS_POINT_USER_MANAGER, reason, email);
+  instance_->ShowDialog(browser_context, email, url);
+}
+
+// static
+void UserManagerProfileDialog::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);
+}
+
+// static
+void UserManagerProfileDialog::ShowDialogAndDisplayErrorMessage(
+    content::BrowserContext* browser_context) {
+  if (!UserManager::IsShowing())
+    return;
+  instance_->ShowDialog(browser_context, std::string(),
+                        GURL(chrome::kChromeUISigninErrorURL));
+}
+
+// static
+void UserManagerProfileDialog::DisplayErrorMessage() {
   DCHECK(instance_);
   instance_->DisplayErrorMessage();
 }
 
 // static
-base::FilePath UserManager::GetSigninProfilePath() {
-  return instance_->GetSigninProfilePath();
+void UserManagerProfileDialog::HideDialog() {
+  // This method should only be called if the user manager is already showing.
+  if (!UserManager::IsShowing())
+    return;
+
+  instance_->CloseDialog();
 }
 
-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_;
 }