Perform online reauth when password is changed for a locked profile.

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/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/lifetime/application_lifetime.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/profile_window.h"
 #include "chrome/browser/profiles/profiles_state.h"
+#include "chrome/browser/signin/signin_promo.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/user_manager.h"
 #include "chrome/browser/ui/views/auto_keep_alive.h"
+#include "chrome/browser/ui/views/browser_dialogs.h"
 #include "chrome/grit/chromium_strings.h"
+#include "chrome/grit/generated_resources.h"
+#include "components/guest_view/browser/guest_view_manager.h"
+#include "content/public/browser/navigation_details.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
+#include "google_apis/gaia/gaia_urls.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/controls/webview/webview.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/dialog_client_view.h"
+#include "ui/views/window/dialog_delegate.h"
 
 #if defined(OS_WIN)
 #include "chrome/browser/shell_integration.h"
 #include "ui/base/win/shell.h"
 #include "ui/views/win/hwnd_util.h"
 #endif
 
 #if defined(USE_ASH)
 #include "ash/shelf/shelf_util.h"
 #include "ash/wm/window_util.h"
 #include "grit/ash_resources.h"
 #endif
 
 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_ = NULL;
 bool instance_under_construction_ = false;
 
+class ReauthDelegate : public views::DialogDelegate,
+                       public content::WebContentsObserver {
+ public:
+  ReauthDelegate(content::BrowserContext* browser_context,
+                 const std::string& email_address,
+                 size_t profile_index);
+  ~ReauthDelegate() override {}
+
+ private:
+  // Overridden from views::DialogDelegate:
+  bool CanResize() const override;
+  bool CanMaximize() const override;
+  bool CanMinimize() const override;
+  bool UseNewStyleForThisDialog() const override;
+  ui::ModalType GetModalType() const override;
+  void DeleteDelegate() override;
+  views::Widget* GetWidget() override;
+  const views::Widget* GetWidget() const override;
+  views::View* GetContentsView() override;
+  base::string16 GetWindowTitle() const override;
+  int GetDialogButtons() const override;
+
+  // Overridden from content::WebContentsObserver:
+  void DidStopLoading() override;
+
+  content::BrowserContext* browser_context_;
+  views::WebView* web_view_;
+  std::string email_address_;
+  size_t profile_index_;
+};
+
+ReauthDelegate::ReauthDelegate(content::BrowserContext* browser_context,
+                               const std::string& email_address,
+                               size_t profile_index)
+    : browser_context_(browser_context),
+      web_view_(nullptr),
+      email_address_(email_address),
+      profile_index_(profile_index) {}
+
+bool ReauthDelegate::CanResize() const {
+  return true;
+}
+
+bool ReauthDelegate::CanMaximize() const  {
+  return true;
+}
+
+bool ReauthDelegate::CanMinimize() const  {
+  return true;
+}
+
+bool ReauthDelegate::UseNewStyleForThisDialog() const {
+  return false;
+}
+
+ui::ModalType ReauthDelegate::GetModalType() const {
+  return ui::MODAL_TYPE_WINDOW;
+}
+
+views::Widget* ReauthDelegate::GetWidget() {
+  return web_view_->GetWidget();
+}
+
+void ReauthDelegate::DeleteDelegate() {
+  delete web_view_;
+  delete this;
+}
+
+const views::Widget* ReauthDelegate::GetWidget() const {
+  return web_view_->GetWidget();
+}
+
+views::View* ReauthDelegate::GetContentsView() {
+  DCHECK(!web_view_);
+  web_view_ = new views::WebView(browser_context_);
+  web_view_->set_owned_by_client();
+
+  // Observe navigations of the web contents so that the dialog can close itself
+  // when the sign in process is done.
+  Observe(web_view_->GetWebContents());
+
+  // 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::GetReauthURL(profile_index_, email_address_);
+  web_view_->LoadInitialURL(url);
+  web_view_->SetPreferredSize(gfx::Size(360, 440));
+  return web_view_;
+}
+
+base::string16 ReauthDelegate::GetWindowTitle() const {
+  return l10n_util::GetStringUTF16(IDS_PROFILES_GAIA_SIGNIN_TITLE);
+}
+
+int ReauthDelegate::GetDialogButtons() const {
+  return ui::DIALOG_BUTTON_NONE;
+}
+
+bool AddToSet(std::set<content::WebContents*>* content_set,
+                             content::WebContents* web_contents) {
+  content_set->insert(web_contents);
+  return false;
+}
+
+void ReauthDelegate::DidStopLoading() {
+  // If the sign in process reaches the termination URL, close the dialog.
+  // Make sure to remove any parts of the URL that gaia might append during
+  // signin.
+  GURL url = web_contents()->GetURL();
+  url::Replacements<char> replacements;
+  replacements.ClearQuery();
+  replacements.ClearRef();
+  if (url.ReplaceComponents(replacements) ==
+        GaiaUrls::GetInstance()->signin_completed_continue_url()) {
+    GetWidget()->Close();
+    return;
+  }
+
+  // If still observing the top level web contents, try to find the embedded
+  // webview and observe it instead.  The webview may not be found in the

[bcwhite, 2015/07/21 13:28:39]

What URL will the embedded view have if not the ReauthURL?

[Roger Tawa OOO till Jul 10th, 2015/07/22 00:12:33]

ReauthDelegate first observes the WebContents of the |web_view_|, looking for
the embedded <webview> element.  Once found, ReauthDelegate then observers the
WebContents of the <webivew>.

The |web_view_| contains a URL of the form "chrome://chrome-signin/...".  The
<webview> element contains URLs of the form https://accounts.google.com/...,
URLs based on saml provider pages, and the eventually successful continue URL.

The term "web view" is overloaded in this case to mean different things, so it
gets a little confusing.

+  // initial page load since it loads asynchronously.
+  if (url.GetOrigin() !=
+        signin::GetReauthURL(profile_index_, email_address_).GetOrigin()) {
+    return;
+  }
+
+  std::set<content::WebContents*> content_set;
+  content::WebContents* web_contents = web_view_->GetWebContents();
+  guest_view::GuestViewManager* manager =
+      guest_view::GuestViewManager::FromBrowserContext(
+          web_view_->GetWebContents()->GetBrowserContext());
+  if (manager)
+    manager->ForEachGuest(web_contents, base::Bind(&AddToSet, &content_set));
+  if (content_set.size() > 0)

[bcwhite, 2015/07/21 13:28:39]

DCHECK(content_set.size() <= 1)?

[Roger Tawa OOO till Jul 10th, 2015/07/22 00:12:32]

The style guide says not to DCHECK if the code handles the cases with an if.

[bcwhite, 2015/07/22 13:42:21]

Different conditions.  The DCHECK was to validate that there was only one
sub-view.  If there were two, the "content_set.begin()" could get the wrong one.

[Roger Tawa OOO till Jul 10th, 2015/07/22 15:29:54]

Done.

+    Observe(*content_set.begin());
+}
+
 } // namespace
 
 // UserManager -----------------------------------------------------------------
 
+// static
 void UserManager::Show(
     const base::FilePath& profile_path_to_focus,
     profiles::UserManagerTutorialMode tutorial_mode,
     profiles::UserManagerProfileSelected profile_open_action) {
   DCHECK(profile_path_to_focus != ProfileManager::GetGuestProfilePath());
 
   ProfileMetrics::LogProfileOpenMethod(ProfileMetrics::OPEN_USER_MANAGER);
   if (instance_) {
     // If we are showing the User Manager after locking a profile, change the
     // active profile to Guest.
@@ skipping 21 matching lines @@
   profiles::CreateSystemProfileForUserManager(
       profile_path_to_focus,
       tutorial_mode,
       profile_open_action,
       base::Bind(&UserManagerView::OnSystemProfileCreated,
                  base::Passed(make_scoped_ptr(user_manager)),
                  base::Owned(new base::AutoReset<bool>(
                      &instance_under_construction_, true))));
 }
 
+// static
 void UserManager::Hide() {
   if (instance_)
     instance_->GetWidget()->Close();
 }
 
+// static
 bool UserManager::IsShowing() {
   return instance_ ? instance_->GetWidget()->IsActive() : false;
 }
 
+// static
 void UserManager::OnUserManagerShown() {
   if (instance_)
     instance_->LogTimeToOpen();
 }
 
+// static
+void UserManager::ShowReauthDialog(content::BrowserContext* browser_context,
+                                   const std::string& email,
+                                   size_t profile_index) {
+  // This method should only be called if the user manager is already showing.
+  if (!IsShowing())
+    return;
+
+  views::DialogDelegate* delegate =
+      new ReauthDelegate(browser_context, email, profile_index);
+  gfx::NativeView parent = instance_->GetWidget()->GetNativeView();
+  views::DialogDelegate::CreateDialogWidget(delegate, NULL, parent);
+  delegate->GetWidget()->Show();
+}
+
 // UserManagerView -------------------------------------------------------------
 
 UserManagerView::UserManagerView()
     : web_view_(NULL),
       keep_alive_(new AutoKeepAlive(NULL)),
       user_manager_started_showing_(base::Time()) {
 }
 
 UserManagerView::~UserManagerView() {
 }
@@ skipping 133 matching lines @@
   // Now that the window is closed, we can allow a new one to be opened.
   // (WindowClosing comes in asynchronously from the call to Close() and we
   // may have already opened a new instance).
   if (instance_ == this)
     instance_ = NULL;
 }
 
 bool UserManagerView::UseNewStyleForThisDialog() const {
   return false;
 }