Implement online reauth UI for Locked Profiles on Mac

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/mac/foundation_util.h"
 #include "chrome/app/chrome_command_ids.h"
 #import "chrome/browser/app_controller_mac.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profile_metrics.h"
 #include "chrome/browser/profiles/profiles_state.h"
+#include "chrome/browser/signin/signin_promo.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #import "chrome/browser/ui/cocoa/browser_window_utils.h"
 #include "chrome/browser/ui/cocoa/chrome_event_processing_window.h"
 #include "chrome/browser/ui/user_manager.h"
 #include "chrome/grit/chromium_strings.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 
 namespace {
-
 // Update the App Controller with a new Profile. Used when a Profile is locked
 // to set the Controller to the Guest profile so the old Profile's bookmarks,
 // etc... cannot be accessed.
 void ChangeAppControllerForProfile(Profile* profile,
                                    Profile::CreateStatus status) {
   if (status == Profile::CREATE_STATUS_INITIALIZED) {
     AppController* controller =
         base::mac::ObjCCast<AppController>([NSApp delegate]);
     [controller windowChangedToProfile:profile];
   }
 }
 
 }  // 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.
 UserManagerMac* instance_ = NULL;  // Weak.
 BOOL instance_under_construction_ = NO;
 
+void CloseInstanceReauthDialog() {
+  DCHECK(instance_);
+  instance_->CloseReauthDialog();
+}
+
 // Custom WebContentsDelegate that allows handling of hotkeys.
 class UserManagerWebContentsDelegate : public content::WebContentsDelegate {
  public:
   UserManagerWebContentsDelegate() {}
 
   // WebContentsDelegate implementation. Forwards all unhandled keyboard events
   // to the current window.
   void HandleKeyboardEvent(
       content::WebContents* source,
       const content::NativeWebKeyboardEvent& event) override {
@@ skipping 10 matching lines @@
          event.windowsKeyCode == ui::VKEY_V);
 
     // 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 profiles::ReauthDialogObserver,
+                             public UserManagerWebContentsDelegate {
+ public:
+   ReauthDialogDelegate(content::WebContents* web_contents, std::string email)
+      : profiles::ReauthDialogObserver(web_contents, email),
+        web_contents_(web_contents),
+        email_address_(email) {
+    Observe(web_contents);

[Roger Tawa OOO till Jul 10th, 2015/08/05 13:36:05]

Can you put this Observe() call into the ctor of ReauthDialogObserver?  That way
it is not duplicated in the mac and views impl.

If we do this, do we still need a |web_contents_| member variable in this class
and in the ReauthDialogObserver class?  WebContentsObserver already saves the
pointer and makes it available via the web_contents() method.  See comment in
profile_window.cc too.

[anthonyvd, 2015/08/05 18:20:44]

Done.

+  }
+
+  // profiles::ReauthDialogObserver:
+  void CloseReauthDialog() override {
+    CloseInstanceReauthDialog();
+  }
+
+ private:
+  content::WebContents* web_contents_;
+  std::string email_address_;
+
+  DISALLOW_COPY_AND_ASSIGN(ReauthDialogDelegate);
+};
+
+@interface ReauthDialogWindowController
+    : NSWindowController <NSWindowDelegate> {
+ @private
+  std::string emailAddress_;
+  scoped_ptr<content::WebContents> webContents_;
+  scoped_ptr<ReauthDialogDelegate> webContentsDelegate_;
+  NSModalSession modalSession_;
+}
+- (void)windowWillClose:(NSNotification*)notification;
+- (id)initWithProfile:(Profile*)profile email:(std::string)email;
+@end
+
+@implementation ReauthDialogWindowController
+- (void)windowWillClose:(NSNotification*)notification {
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+  [NSApp endModalSession:modalSession_];
+}
+
+- (id)initWithProfile:(Profile*)profile email:(std::string)email {
+  emailAddress_ = email;
+  // 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;
+  NSRect contentRect =
+      NSMakeRect((screenWidth - UserManager::kReauthDialogWidth) / 2,
+                 (screenHeight - UserManager::kReauthDialogHeight) / 2,
+                 UserManager::kReauthDialogWidth,
+                 UserManager::kReauthDialogHeight);
+  ChromeEventProcessingWindow* window = [[ChromeEventProcessingWindow alloc]
+      initWithContentRect:contentRect
+                styleMask:NSTitledWindowMask |
+                          NSClosableWindowMask |
+                          NSResizableWindowMask
+                  backing:NSBackingStoreBuffered
+                    defer:NO
+                   screen:mainScreen];
+  [window setTitle:l10n_util::GetNSString(IDS_PRODUCT_NAME)];
+  [window setMinSize:NSMakeSize(UserManager::kReauthDialogWidth,
+                                UserManager::kReauthDialogHeight)];
+
+  if ((self = [super initWithWindow:window])) {
+    // Initialize the web view.
+    webContents_.reset(content::WebContents::Create(
+        content::WebContents::CreateParams(profile)));
+    window.contentView = webContents_->GetNativeView();
+    webContentsDelegate_.reset(
+       new ReauthDialogDelegate(webContents_.get(), emailAddress_));
+    webContents_->SetDelegate(webContentsDelegate_.get());
+    DCHECK(window.contentView);
+
+    [[NSNotificationCenter defaultCenter]
+        addObserver:self
+           selector:@selector(windowWillClose:)
+               name:NSWindowWillCloseNotification
+             object:self.window];
+    [self show];
+  }
+  return self;
+}
+
+- (void)show {
+  GURL url = signin::GetReauthURLWithEmail(emailAddress_);
+  webContents_->GetController().LoadURL(url, content::Referrer(),
+                                        ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
+                                        std::string());
+  modalSession_ = [NSApp beginModalSessionForWindow:[self window]];
+  [NSApp runModalSession:modalSession_];
+}
+
+- (void)close {
+  [[self window] close];
+}
+@end
+
 // Window controller for the User Manager view.
 @interface UserManagerWindowController : NSWindowController <NSWindowDelegate> {
  @private
   scoped_ptr<content::WebContents> webContents_;
   scoped_ptr<UserManagerWebContentsDelegate> webContentsDelegate_;
   UserManagerMac* userManagerObserver_;  // Weak.
 }
 - (void)windowWillClose:(NSNotification*)notification;
 - (void)dealloc;
 - (id)initWithProfile:(Profile*)profile
@@ skipping 143 matching lines @@
 
 // static
 void UserManager::OnUserManagerShown() {
   if (instance_)
     instance_->LogTimeToOpen();
 }
 
 // static
 void UserManager::ShowReauthDialog(content::BrowserContext* browser_context,
                                    const std::string& email) {
-  // TODO(rogerta): See equivalent views implementation in user_manager_view.cc.
+  DCHECK(instance_);
+  instance_->ShowReauthDialog(browser_context, email);
+}
+
+void UserManagerMac::ShowReauthDialog(content::BrowserContext* browser_context,
+                                      const std::string& email) {
+  if (reauthWindow_) {
+    [reauthWindow_ close];
+  }
+
+  reauthWindow_.reset(
+      [[ReauthDialogWindowController alloc]
+          initWithProfile:Profile::FromBrowserContext(browser_context)
+                    email:email]);
+}
+
+void UserManagerMac::CloseReauthDialog() {
+  [reauthWindow_ close];
+  reauthWindow_.reset();
 }
 
 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() {
+  if (reauthWindow_) {
+    CloseReauthDialog();
+  }
   instance_ = NULL;
   delete this;
 }