| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/browser/ui/sync/one_click_signin_helper.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 #include <functional> | |
| 9 #include <utility> | |
| 10 #include <vector> | |
| 11 | |
| 12 #include "base/bind.h" | |
| 13 #include "base/callback_forward.h" | |
| 14 #include "base/callback_helpers.h" | |
| 15 #include "base/compiler_specific.h" | |
| 16 #include "base/memory/scoped_ptr.h" | |
| 17 #include "base/message_loop/message_loop_proxy.h" | |
| 18 #include "base/metrics/field_trial.h" | |
| 19 #include "base/metrics/histogram.h" | |
| 20 #include "base/prefs/pref_service.h" | |
| 21 #include "base/prefs/scoped_user_pref_update.h" | |
| 22 #include "base/strings/string_split.h" | |
| 23 #include "base/strings/string_util.h" | |
| 24 #include "base/strings/utf_string_conversions.h" | |
| 25 #include "base/supports_user_data.h" | |
| 26 #include "base/values.h" | |
| 27 #include "chrome/browser/browser_process.h" | |
| 28 #include "chrome/browser/chrome_notification_types.h" | |
| 29 #include "chrome/browser/defaults.h" | |
| 30 #include "chrome/browser/history/history_service.h" | |
| 31 #include "chrome/browser/history/history_service_factory.h" | |
| 32 #include "chrome/browser/password_manager/chrome_password_manager_client.h" | |
| 33 #include "chrome/browser/profiles/profile.h" | |
| 34 #include "chrome/browser/profiles/profile_info_cache.h" | |
| 35 #include "chrome/browser/profiles/profile_io_data.h" | |
| 36 #include "chrome/browser/profiles/profile_manager.h" | |
| 37 #include "chrome/browser/search/search.h" | |
| 38 #include "chrome/browser/signin/chrome_signin_client.h" | |
| 39 #include "chrome/browser/signin/chrome_signin_client_factory.h" | |
| 40 #include "chrome/browser/signin/signin_error_controller_factory.h" | |
| 41 #include "chrome/browser/signin/signin_manager_factory.h" | |
| 42 #include "chrome/browser/signin/signin_names_io_thread.h" | |
| 43 #include "chrome/browser/sync/profile_sync_service.h" | |
| 44 #include "chrome/browser/sync/profile_sync_service_factory.h" | |
| 45 #include "chrome/browser/tab_contents/tab_util.h" | |
| 46 #include "chrome/browser/ui/browser_finder.h" | |
| 47 #include "chrome/browser/ui/browser_list.h" | |
| 48 #include "chrome/browser/ui/browser_tabstrip.h" | |
| 49 #include "chrome/browser/ui/browser_window.h" | |
| 50 #include "chrome/browser/ui/chrome_pages.h" | |
| 51 #include "chrome/browser/ui/sync/one_click_signin_sync_observer.h" | |
| 52 #include "chrome/browser/ui/sync/one_click_signin_sync_starter.h" | |
| 53 #include "chrome/browser/ui/tab_modal_confirm_dialog.h" | |
| 54 #include "chrome/browser/ui/tab_modal_confirm_dialog_delegate.h" | |
| 55 #include "chrome/browser/ui/tabs/tab_strip_model.h" | |
| 56 #include "chrome/browser/ui/webui/signin/login_ui_service_factory.h" | |
| 57 #include "chrome/common/chrome_version_info.h" | |
| 58 #include "chrome/common/net/url_util.h" | |
| 59 #include "chrome/common/pref_names.h" | |
| 60 #include "chrome/common/url_constants.h" | |
| 61 #include "chrome/grit/chromium_strings.h" | |
| 62 #include "chrome/grit/generated_resources.h" | |
| 63 #include "components/autofill/core/common/password_form.h" | |
| 64 #include "components/google/core/browser/google_util.h" | |
| 65 #include "components/password_manager/core/browser/password_manager.h" | |
| 66 #include "components/signin/core/browser/signin_client.h" | |
| 67 #include "components/signin/core/browser/signin_error_controller.h" | |
| 68 #include "components/signin/core/browser/signin_manager.h" | |
| 69 #include "components/signin/core/browser/signin_manager_cookie_helper.h" | |
| 70 #include "components/signin/core/browser/signin_metrics.h" | |
| 71 #include "components/signin/core/common/profile_management_switches.h" | |
| 72 #include "components/sync_driver/sync_prefs.h" | |
| 73 #include "content/public/browser/browser_thread.h" | |
| 74 #include "content/public/browser/navigation_entry.h" | |
| 75 #include "content/public/browser/page_navigator.h" | |
| 76 #include "content/public/browser/render_frame_host.h" | |
| 77 #include "content/public/browser/render_process_host.h" | |
| 78 #include "content/public/browser/web_contents.h" | |
| 79 #include "content/public/browser/web_contents_delegate.h" | |
| 80 #include "content/public/common/frame_navigate_params.h" | |
| 81 #include "google_apis/gaia/gaia_auth_util.h" | |
| 82 #include "google_apis/gaia/gaia_urls.h" | |
| 83 #include "grit/components_strings.h" | |
| 84 #include "ipc/ipc_message_macros.h" | |
| 85 #include "net/base/url_util.h" | |
| 86 #include "net/cookies/cookie_monster.h" | |
| 87 #include "net/url_request/url_request.h" | |
| 88 #include "ui/base/l10n/l10n_util.h" | |
| 89 #include "ui/base/page_transition_types.h" | |
| 90 #include "url/gurl.h" | |
| 91 | |
| 92 | |
| 93 namespace { | |
| 94 | |
| 95 // ConfirmEmailDialogDelegate ------------------------------------------------- | |
| 96 | |
| 97 class ConfirmEmailDialogDelegate : public TabModalConfirmDialogDelegate { | |
| 98 public: | |
| 99 enum Action { | |
| 100 CREATE_NEW_USER, | |
| 101 START_SYNC, | |
| 102 CLOSE | |
| 103 }; | |
| 104 | |
| 105 // Callback indicating action performed by the user. | |
| 106 typedef base::Callback<void(Action)> Callback; | |
| 107 | |
| 108 // Ask the user for confirmation before starting to sync. | |
| 109 static void AskForConfirmation(content::WebContents* contents, | |
| 110 const std::string& last_email, | |
| 111 const std::string& email, | |
| 112 Callback callback); | |
| 113 | |
| 114 private: | |
| 115 ConfirmEmailDialogDelegate(content::WebContents* contents, | |
| 116 const std::string& last_email, | |
| 117 const std::string& email, | |
| 118 Callback callback); | |
| 119 ~ConfirmEmailDialogDelegate() override; | |
| 120 | |
| 121 // TabModalConfirmDialogDelegate: | |
| 122 base::string16 GetTitle() override; | |
| 123 base::string16 GetDialogMessage() override; | |
| 124 base::string16 GetAcceptButtonTitle() override; | |
| 125 base::string16 GetCancelButtonTitle() override; | |
| 126 base::string16 GetLinkText() const override; | |
| 127 void OnAccepted() override; | |
| 128 void OnCanceled() override; | |
| 129 void OnClosed() override; | |
| 130 void OnLinkClicked(WindowOpenDisposition disposition) override; | |
| 131 | |
| 132 std::string last_email_; | |
| 133 std::string email_; | |
| 134 Callback callback_; | |
| 135 | |
| 136 // Web contents from which the "Learn more" link should be opened. | |
| 137 content::WebContents* web_contents_; | |
| 138 | |
| 139 DISALLOW_COPY_AND_ASSIGN(ConfirmEmailDialogDelegate); | |
| 140 }; | |
| 141 | |
| 142 // static | |
| 143 void ConfirmEmailDialogDelegate::AskForConfirmation( | |
| 144 content::WebContents* contents, | |
| 145 const std::string& last_email, | |
| 146 const std::string& email, | |
| 147 Callback callback) { | |
| 148 TabModalConfirmDialog::Create( | |
| 149 new ConfirmEmailDialogDelegate(contents, last_email, email, | |
| 150 callback), contents); | |
| 151 } | |
| 152 | |
| 153 ConfirmEmailDialogDelegate::ConfirmEmailDialogDelegate( | |
| 154 content::WebContents* contents, | |
| 155 const std::string& last_email, | |
| 156 const std::string& email, | |
| 157 Callback callback) | |
| 158 : TabModalConfirmDialogDelegate(contents), | |
| 159 last_email_(last_email), | |
| 160 email_(email), | |
| 161 callback_(callback), | |
| 162 web_contents_(contents) { | |
| 163 } | |
| 164 | |
| 165 ConfirmEmailDialogDelegate::~ConfirmEmailDialogDelegate() { | |
| 166 } | |
| 167 | |
| 168 base::string16 ConfirmEmailDialogDelegate::GetTitle() { | |
| 169 return l10n_util::GetStringUTF16( | |
| 170 IDS_ONE_CLICK_SIGNIN_CONFIRM_EMAIL_DIALOG_TITLE); | |
| 171 } | |
| 172 | |
| 173 base::string16 ConfirmEmailDialogDelegate::GetDialogMessage() { | |
| 174 return l10n_util::GetStringFUTF16( | |
| 175 IDS_ONE_CLICK_SIGNIN_CONFIRM_EMAIL_DIALOG_MESSAGE, | |
| 176 base::UTF8ToUTF16(last_email_), base::UTF8ToUTF16(email_)); | |
| 177 } | |
| 178 | |
| 179 base::string16 ConfirmEmailDialogDelegate::GetAcceptButtonTitle() { | |
| 180 return l10n_util::GetStringUTF16( | |
| 181 IDS_ONE_CLICK_SIGNIN_CONFIRM_EMAIL_DIALOG_OK_BUTTON); | |
| 182 } | |
| 183 | |
| 184 base::string16 ConfirmEmailDialogDelegate::GetCancelButtonTitle() { | |
| 185 return l10n_util::GetStringUTF16( | |
| 186 IDS_ONE_CLICK_SIGNIN_CONFIRM_EMAIL_DIALOG_CANCEL_BUTTON); | |
| 187 } | |
| 188 | |
| 189 base::string16 ConfirmEmailDialogDelegate::GetLinkText() const { | |
| 190 return l10n_util::GetStringUTF16(IDS_LEARN_MORE); | |
| 191 } | |
| 192 | |
| 193 void ConfirmEmailDialogDelegate::OnAccepted() { | |
| 194 base::ResetAndReturn(&callback_).Run(CREATE_NEW_USER); | |
| 195 } | |
| 196 | |
| 197 void ConfirmEmailDialogDelegate::OnCanceled() { | |
| 198 base::ResetAndReturn(&callback_).Run(START_SYNC); | |
| 199 } | |
| 200 | |
| 201 void ConfirmEmailDialogDelegate::OnClosed() { | |
| 202 base::ResetAndReturn(&callback_).Run(CLOSE); | |
| 203 } | |
| 204 | |
| 205 void ConfirmEmailDialogDelegate::OnLinkClicked( | |
| 206 WindowOpenDisposition disposition) { | |
| 207 content::OpenURLParams params( | |
| 208 GURL(chrome::kChromeSyncMergeTroubleshootingURL), | |
| 209 content::Referrer(), | |
| 210 NEW_POPUP, | |
| 211 ui::PAGE_TRANSITION_AUTO_TOPLEVEL, | |
| 212 false); | |
| 213 // It is guaranteed that |web_contents_| is valid here because when it's | |
| 214 // deleted, the dialog is immediately closed and no further action can be | |
| 215 // performed. | |
| 216 web_contents_->OpenURL(params); | |
| 217 } | |
| 218 | |
| 219 | |
| 220 // Helpers -------------------------------------------------------------------- | |
| 221 | |
| 222 // Add a specific email to the list of emails rejected for one-click | |
| 223 // sign-in, for this profile. | |
| 224 void AddEmailToOneClickRejectedList(Profile* profile, | |
| 225 const std::string& email) { | |
| 226 ListPrefUpdate updater(profile->GetPrefs(), | |
| 227 prefs::kReverseAutologinRejectedEmailList); | |
| 228 updater->AppendIfNotPresent(new base::StringValue(email)); | |
| 229 } | |
| 230 | |
| 231 // Start syncing with the given user information. | |
| 232 void StartSync(const OneClickSigninHelper::StartSyncArgs& args, | |
| 233 OneClickSigninSyncStarter::StartSyncMode start_mode) { | |
| 234 if (start_mode == OneClickSigninSyncStarter::UNDO_SYNC) { | |
| 235 OneClickSigninHelper::LogHistogramValue(signin_metrics::HISTOGRAM_UNDO); | |
| 236 return; | |
| 237 } | |
| 238 | |
| 239 // The wrapper deletes itself once it's done. | |
| 240 OneClickSigninHelper::SyncStarterWrapper* wrapper = | |
| 241 new OneClickSigninHelper::SyncStarterWrapper(args, start_mode); | |
| 242 wrapper->Start(); | |
| 243 | |
| 244 int action = signin_metrics::HISTOGRAM_MAX; | |
| 245 switch (args.auto_accept) { | |
| 246 case OneClickSigninHelper::AUTO_ACCEPT_EXPLICIT: | |
| 247 break; | |
| 248 case OneClickSigninHelper::AUTO_ACCEPT_ACCEPTED: | |
| 249 action = | |
| 250 start_mode == OneClickSigninSyncStarter::SYNC_WITH_DEFAULT_SETTINGS ? | |
| 251 signin_metrics::HISTOGRAM_AUTO_WITH_DEFAULTS : | |
| 252 signin_metrics::HISTOGRAM_AUTO_WITH_ADVANCED; | |
| 253 break; | |
| 254 case OneClickSigninHelper::AUTO_ACCEPT_CONFIGURE: | |
| 255 DCHECK(start_mode == OneClickSigninSyncStarter::CONFIGURE_SYNC_FIRST); | |
| 256 action = signin_metrics::HISTOGRAM_AUTO_WITH_ADVANCED; | |
| 257 break; | |
| 258 default: | |
| 259 NOTREACHED() << "Invalid auto_accept: " << args.auto_accept; | |
| 260 break; | |
| 261 } | |
| 262 if (action != signin_metrics::HISTOGRAM_MAX) | |
| 263 OneClickSigninHelper::LogHistogramValue(action); | |
| 264 } | |
| 265 | |
| 266 void StartExplicitSync(const OneClickSigninHelper::StartSyncArgs& args, | |
| 267 content::WebContents* contents, | |
| 268 OneClickSigninSyncStarter::StartSyncMode start_mode, | |
| 269 ConfirmEmailDialogDelegate::Action action) { | |
| 270 if (action == ConfirmEmailDialogDelegate::START_SYNC) { | |
| 271 StartSync(args, start_mode); | |
| 272 } else { | |
| 273 // Perform a redirection to the NTP/Apps page to hide the blank page when | |
| 274 // the action is CLOSE or CREATE_NEW_USER. The redirection is useful when | |
| 275 // the action is CREATE_NEW_USER because the "Create new user" page might | |
| 276 // be opened in a different tab that is already showing settings. | |
| 277 args.callback.Run(OneClickSigninSyncStarter::SYNC_SETUP_FAILURE); | |
| 278 if (action == ConfirmEmailDialogDelegate::CREATE_NEW_USER) { | |
| 279 chrome::ShowSettingsSubPage(args.browser, | |
| 280 std::string(chrome::kCreateProfileSubPage)); | |
| 281 } | |
| 282 } | |
| 283 } | |
| 284 | |
| 285 void ClearPendingEmailOnIOThread(content::ResourceContext* context) { | |
| 286 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context); | |
| 287 DCHECK(io_data); | |
| 288 io_data->set_reverse_autologin_pending_email(std::string()); | |
| 289 } | |
| 290 | |
| 291 // Determines the source of the sign in and the continue URL. It's either one | |
| 292 // of the known sign-in access points (first run, NTP, Apps page, menu, or | |
| 293 // settings) or it's an implicit sign in via another Google property. In the | |
| 294 // former case, "service" is also checked to make sure its "chromiumsync". | |
| 295 signin_metrics::Source GetSigninSource(const GURL& url, GURL* continue_url) { | |
| 296 DCHECK(url.is_valid()); | |
| 297 std::string value; | |
| 298 net::GetValueForKeyInQuery(url, "service", &value); | |
| 299 bool possibly_an_explicit_signin = value == "chromiumsync"; | |
| 300 | |
| 301 // Find the final continue URL for this sign in. In some cases, Gaia can | |
| 302 // continue to itself, with the original continue URL buried under a couple | |
| 303 // of layers of indirection. Peel those layers away. The final destination | |
| 304 // can also be "IsGaiaSignonRealm" so stop if we get to the end (but be sure | |
| 305 // we always extract at least one "continue" value). | |
| 306 GURL local_continue_url = signin::GetNextPageURLForPromoURL(url); | |
| 307 while (gaia::IsGaiaSignonRealm(local_continue_url.GetOrigin())) { | |
| 308 GURL next_continue_url = | |
| 309 signin::GetNextPageURLForPromoURL(local_continue_url); | |
| 310 if (!next_continue_url.is_valid()) | |
| 311 break; | |
| 312 local_continue_url = next_continue_url; | |
| 313 } | |
| 314 | |
| 315 if (continue_url && local_continue_url.is_valid()) { | |
| 316 DCHECK(!continue_url->is_valid() || *continue_url == local_continue_url); | |
| 317 *continue_url = local_continue_url; | |
| 318 } | |
| 319 | |
| 320 return possibly_an_explicit_signin ? | |
| 321 signin::GetSourceForPromoURL(local_continue_url) : | |
| 322 signin_metrics::SOURCE_UNKNOWN; | |
| 323 } | |
| 324 | |
| 325 // Returns true if |url| is a valid URL that can occur during the sign in | |
| 326 // process. Valid URLs are of the form: | |
| 327 // | |
| 328 // https://accounts.google.{TLD}/... | |
| 329 // https://accounts.youtube.com/... | |
| 330 // https://accounts.blogger.com/... | |
| 331 // | |
| 332 // All special headers used by one click sign in occur on | |
| 333 // https://accounts.google.com URLs. However, the sign in process may redirect | |
| 334 // to intermediate Gaia URLs that do not end with .com. For example, an account | |
| 335 // that uses SMS 2-factor outside the US may redirect to country specific URLs. | |
| 336 // | |
| 337 // The sign in process may also redirect to youtube and blogger account URLs | |
| 338 // so that Gaia acts as a single signon service. | |
| 339 bool IsValidGaiaSigninRedirectOrResponseURL(const GURL& url) { | |
| 340 std::string hostname = url.host(); | |
| 341 if (google_util::IsGoogleHostname(hostname, google_util::ALLOW_SUBDOMAIN)) { | |
| 342 // Also using IsGaiaSignonRealm() to handle overriding with command line. | |
| 343 return gaia::IsGaiaSignonRealm(url.GetOrigin()) || | |
| 344 StartsWithASCII(hostname, "accounts.", false); | |
| 345 } | |
| 346 | |
| 347 GURL origin = url.GetOrigin(); | |
| 348 if (origin == GURL("https://accounts.youtube.com") || | |
| 349 origin == GURL("https://accounts.blogger.com")) | |
| 350 return true; | |
| 351 | |
| 352 return false; | |
| 353 } | |
| 354 | |
| 355 // Tells when we are in the process of showing either the signin to chrome page | |
| 356 // or the one click sign in to chrome page. | |
| 357 // NOTE: This should only be used for logging purposes since it relies on hard | |
| 358 // coded URLs that could change. | |
| 359 bool AreWeShowingSignin(GURL url, | |
| 360 signin_metrics::Source source, | |
| 361 std::string email) { | |
| 362 GURL::Replacements replacements; | |
| 363 replacements.ClearQuery(); | |
| 364 GURL clean_login_url = | |
| 365 GaiaUrls::GetInstance()->service_login_url().ReplaceComponents( | |
| 366 replacements); | |
| 367 | |
| 368 return (url.ReplaceComponents(replacements) == clean_login_url && | |
| 369 source != signin_metrics::SOURCE_UNKNOWN) || | |
| 370 (IsValidGaiaSigninRedirectOrResponseURL(url) && | |
| 371 url.spec().find("ChromeLoginPrompt") != std::string::npos && | |
| 372 !email.empty()); | |
| 373 } | |
| 374 | |
| 375 // If profile is valid then get signin scoped device id from signin client. | |
| 376 // Otherwise returns empty string. | |
| 377 std::string GetSigninScopedDeviceId(Profile* profile) { | |
| 378 std::string signin_scoped_device_id; | |
| 379 SigninClient* signin_client = | |
| 380 profile ? ChromeSigninClientFactory::GetForProfile(profile) : NULL; | |
| 381 if (signin_client) { | |
| 382 signin_scoped_device_id = signin_client->GetSigninScopedDeviceId(); | |
| 383 } | |
| 384 return signin_scoped_device_id; | |
| 385 } | |
| 386 | |
| 387 // CurrentHistoryCleaner ------------------------------------------------------ | |
| 388 | |
| 389 // Watch a webcontents and remove URL from the history once loading is complete. | |
| 390 // We have to delay the cleaning until the new URL has finished loading because | |
| 391 // we're not allowed to remove the last-loaded URL from the history. Objects | |
| 392 // of this type automatically self-destruct once they're finished their work. | |
| 393 class CurrentHistoryCleaner : public content::WebContentsObserver { | |
| 394 public: | |
| 395 explicit CurrentHistoryCleaner(content::WebContents* contents); | |
| 396 ~CurrentHistoryCleaner() override; | |
| 397 | |
| 398 // content::WebContentsObserver: | |
| 399 void WebContentsDestroyed() override; | |
| 400 void DidCommitProvisionalLoadForFrame( | |
| 401 content::RenderFrameHost* render_frame_host, | |
| 402 const GURL& url, | |
| 403 ui::PageTransition transition_type) override; | |
| 404 | |
| 405 private: | |
| 406 scoped_ptr<content::WebContents> contents_; | |
| 407 int history_index_to_remove_; | |
| 408 | |
| 409 DISALLOW_COPY_AND_ASSIGN(CurrentHistoryCleaner); | |
| 410 }; | |
| 411 | |
| 412 CurrentHistoryCleaner::CurrentHistoryCleaner(content::WebContents* contents) | |
| 413 : WebContentsObserver(contents) { | |
| 414 history_index_to_remove_ = | |
| 415 web_contents()->GetController().GetLastCommittedEntryIndex(); | |
| 416 } | |
| 417 | |
| 418 CurrentHistoryCleaner::~CurrentHistoryCleaner() { | |
| 419 } | |
| 420 | |
| 421 void CurrentHistoryCleaner::DidCommitProvisionalLoadForFrame( | |
| 422 content::RenderFrameHost* render_frame_host, | |
| 423 const GURL& url, | |
| 424 ui::PageTransition transition_type) { | |
| 425 // Return early if this is not top-level navigation. | |
| 426 if (render_frame_host->GetParent()) | |
| 427 return; | |
| 428 } | |
| 429 | |
| 430 void CurrentHistoryCleaner::WebContentsDestroyed() { | |
| 431 delete this; // Failure. | |
| 432 } | |
| 433 | |
| 434 } // namespace | |
| 435 | |
| 436 | |
| 437 // StartSyncArgs -------------------------------------------------------------- | |
| 438 | |
| 439 OneClickSigninHelper::StartSyncArgs::StartSyncArgs() | |
| 440 : profile(NULL), | |
| 441 browser(NULL), | |
| 442 auto_accept(AUTO_ACCEPT_NONE), | |
| 443 web_contents(NULL), | |
| 444 confirmation_required(OneClickSigninSyncStarter::NO_CONFIRMATION), | |
| 445 source(signin_metrics::SOURCE_UNKNOWN) {} | |
| 446 | |
| 447 OneClickSigninHelper::StartSyncArgs::StartSyncArgs( | |
| 448 Profile* profile, | |
| 449 Browser* browser, | |
| 450 OneClickSigninHelper::AutoAccept auto_accept, | |
| 451 const std::string& session_index, | |
| 452 const std::string& email, | |
| 453 const std::string& password, | |
| 454 const std::string& refresh_token, | |
| 455 content::WebContents* web_contents, | |
| 456 bool untrusted_confirmation_required, | |
| 457 signin_metrics::Source source, | |
| 458 OneClickSigninSyncStarter::Callback callback) | |
| 459 : profile(profile), | |
| 460 browser(browser), | |
| 461 auto_accept(auto_accept), | |
| 462 session_index(session_index), | |
| 463 email(email), | |
| 464 password(password), | |
| 465 refresh_token(refresh_token), | |
| 466 web_contents(web_contents), | |
| 467 source(source), | |
| 468 callback(callback) { | |
| 469 DCHECK(session_index.empty() != refresh_token.empty()); | |
| 470 if (untrusted_confirmation_required) { | |
| 471 confirmation_required = OneClickSigninSyncStarter::CONFIRM_UNTRUSTED_SIGNIN; | |
| 472 } else if (source == signin_metrics::SOURCE_SETTINGS) { | |
| 473 // Do not display a status confirmation for re-auth. | |
| 474 confirmation_required = OneClickSigninSyncStarter::NO_CONFIRMATION; | |
| 475 } else { | |
| 476 confirmation_required = OneClickSigninSyncStarter::CONFIRM_AFTER_SIGNIN; | |
| 477 } | |
| 478 } | |
| 479 | |
| 480 OneClickSigninHelper::StartSyncArgs::~StartSyncArgs() {} | |
| 481 | |
| 482 // SyncStarterWrapper --------------------------------------------------------- | |
| 483 | |
| 484 OneClickSigninHelper::SyncStarterWrapper::SyncStarterWrapper( | |
| 485 const OneClickSigninHelper::StartSyncArgs& args, | |
| 486 OneClickSigninSyncStarter::StartSyncMode start_mode) | |
| 487 : args_(args), start_mode_(start_mode), weak_pointer_factory_(this) { | |
| 488 BrowserList::AddObserver(this); | |
| 489 | |
| 490 // Cache the parent desktop for the browser, so we can reuse that same | |
| 491 // desktop for any UI we want to display. | |
| 492 desktop_type_ = args_.browser ? args_.browser->host_desktop_type() | |
| 493 : chrome::GetActiveDesktop(); | |
| 494 } | |
| 495 | |
| 496 OneClickSigninHelper::SyncStarterWrapper::~SyncStarterWrapper() { | |
| 497 BrowserList::RemoveObserver(this); | |
| 498 } | |
| 499 | |
| 500 void OneClickSigninHelper::SyncStarterWrapper::Start() { | |
| 501 if (args_.refresh_token.empty()) { | |
| 502 if (args_.password.empty()) { | |
| 503 VerifyGaiaCookiesBeforeSignIn(); | |
| 504 } else { | |
| 505 StartSigninOAuthHelper(); | |
| 506 } | |
| 507 } else { | |
| 508 OnSigninOAuthInformationAvailable(args_.email, args_.email, | |
| 509 args_.refresh_token); | |
| 510 } | |
| 511 } | |
| 512 | |
| 513 void | |
| 514 OneClickSigninHelper::SyncStarterWrapper::OnSigninOAuthInformationAvailable( | |
| 515 const std::string& email, | |
| 516 const std::string& display_email, | |
| 517 const std::string& refresh_token) { | |
| 518 if (!gaia::AreEmailsSame(display_email, args_.email)) { | |
| 519 DisplayErrorBubble( | |
| 520 GoogleServiceAuthError( | |
| 521 GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS).ToString()); | |
| 522 } else { | |
| 523 StartOneClickSigninSyncStarter(email, refresh_token); | |
| 524 } | |
| 525 | |
| 526 base::MessageLoop::current()->DeleteSoon(FROM_HERE, this); | |
| 527 } | |
| 528 | |
| 529 void OneClickSigninHelper::SyncStarterWrapper::OnSigninOAuthInformationFailure( | |
| 530 const GoogleServiceAuthError& error) { | |
| 531 DisplayErrorBubble(error.ToString()); | |
| 532 base::MessageLoop::current()->DeleteSoon(FROM_HERE, this); | |
| 533 } | |
| 534 | |
| 535 void OneClickSigninHelper::SyncStarterWrapper::OnBrowserRemoved( | |
| 536 Browser* browser) { | |
| 537 if (args_.browser == browser) | |
| 538 args_.browser = NULL; | |
| 539 } | |
| 540 | |
| 541 void OneClickSigninHelper::SyncStarterWrapper::VerifyGaiaCookiesBeforeSignIn() { | |
| 542 scoped_refptr<SigninManagerCookieHelper> cookie_helper( | |
| 543 new SigninManagerCookieHelper( | |
| 544 args_.profile->GetRequestContext(), | |
| 545 content::BrowserThread::GetMessageLoopProxyForThread( | |
| 546 content::BrowserThread::UI), | |
| 547 content::BrowserThread::GetMessageLoopProxyForThread( | |
| 548 content::BrowserThread::IO))); | |
| 549 cookie_helper->StartFetchingGaiaCookiesOnUIThread( | |
| 550 base::Bind(&SyncStarterWrapper::OnGaiaCookiesFetched, | |
| 551 weak_pointer_factory_.GetWeakPtr(), | |
| 552 args_.session_index)); | |
| 553 } | |
| 554 | |
| 555 void OneClickSigninHelper::SyncStarterWrapper::OnGaiaCookiesFetched( | |
| 556 const std::string session_index, const net::CookieList& cookie_list) { | |
| 557 net::CookieList::const_iterator it; | |
| 558 bool success = false; | |
| 559 for (it = cookie_list.begin(); it != cookie_list.end(); ++it) { | |
| 560 // Make sure the LSID cookie is set on the GAIA host, instead of a super- | |
| 561 // domain. | |
| 562 if (it->Name() == "LSID") { | |
| 563 if (it->IsHostCookie() && it->IsHttpOnly() && it->IsSecure()) { | |
| 564 // Found a valid LSID cookie. Continue loop to make sure we don't have | |
| 565 // invalid LSID cookies on any super-domain. | |
| 566 success = true; | |
| 567 } else { | |
| 568 success = false; | |
| 569 break; | |
| 570 } | |
| 571 } | |
| 572 } | |
| 573 | |
| 574 if (success) { | |
| 575 StartSigninOAuthHelper(); | |
| 576 } else { | |
| 577 DisplayErrorBubble( | |
| 578 GoogleServiceAuthError( | |
| 579 GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS).ToString()); | |
| 580 base::MessageLoop::current()->DeleteSoon(FROM_HERE, this); | |
| 581 } | |
| 582 } | |
| 583 | |
| 584 void OneClickSigninHelper::SyncStarterWrapper::DisplayErrorBubble( | |
| 585 const std::string& error_message) { | |
| 586 args_.browser = OneClickSigninSyncStarter::EnsureBrowser( | |
| 587 args_.browser, args_.profile, desktop_type_); | |
| 588 LoginUIServiceFactory::GetForProfile(args_.profile)->DisplayLoginResult( | |
| 589 args_.browser, base::UTF8ToUTF16(error_message)); | |
| 590 } | |
| 591 | |
| 592 void OneClickSigninHelper::SyncStarterWrapper::StartSigninOAuthHelper() { | |
| 593 std::string signin_scoped_device_id = GetSigninScopedDeviceId(args_.profile); | |
| 594 signin_oauth_helper_.reset( | |
| 595 new SigninOAuthHelper(args_.profile->GetRequestContext(), | |
| 596 args_.session_index, | |
| 597 signin_scoped_device_id, | |
| 598 this)); | |
| 599 } | |
| 600 | |
| 601 void | |
| 602 OneClickSigninHelper::SyncStarterWrapper::StartOneClickSigninSyncStarter( | |
| 603 const std::string& email, | |
| 604 const std::string& refresh_token) { | |
| 605 // The starter deletes itself once it's done. | |
| 606 new OneClickSigninSyncStarter(args_.profile, args_.browser, | |
| 607 email, args_.password, | |
| 608 refresh_token, start_mode_, | |
| 609 args_.web_contents, | |
| 610 args_.confirmation_required, | |
| 611 GURL(), | |
| 612 args_.callback); | |
| 613 } | |
| 614 | |
| 615 | |
| 616 // OneClickSigninHelper ------------------------------------------------------- | |
| 617 | |
| 618 DEFINE_WEB_CONTENTS_USER_DATA_KEY(OneClickSigninHelper); | |
| 619 | |
| 620 // static | |
| 621 const int OneClickSigninHelper::kMaxNavigationsSince = 10; | |
| 622 | |
| 623 OneClickSigninHelper::OneClickSigninHelper(content::WebContents* web_contents) | |
| 624 : content::WebContentsObserver(web_contents), | |
| 625 showing_signin_(false), | |
| 626 auto_accept_(AUTO_ACCEPT_NONE), | |
| 627 source_(signin_metrics::SOURCE_UNKNOWN), | |
| 628 switched_to_advanced_(false), | |
| 629 untrusted_navigations_since_signin_visit_(0), | |
| 630 untrusted_confirmation_required_(false), | |
| 631 do_not_clear_pending_email_(false), | |
| 632 do_not_start_sync_for_testing_(false), | |
| 633 weak_pointer_factory_(this) { | |
| 634 ChromePasswordManagerClient* client = | |
| 635 ChromePasswordManagerClient::FromWebContents(web_contents); | |
| 636 // May be NULL during testing. | |
| 637 if (client) { | |
| 638 client->GetPasswordManager()->AddSubmissionCallback( | |
| 639 base::Bind(&OneClickSigninHelper::PasswordSubmitted, | |
| 640 weak_pointer_factory_.GetWeakPtr())); | |
| 641 } | |
| 642 } | |
| 643 | |
| 644 OneClickSigninHelper::~OneClickSigninHelper() {} | |
| 645 | |
| 646 // static | |
| 647 void OneClickSigninHelper::LogHistogramValue(int action) { | |
| 648 UMA_HISTOGRAM_ENUMERATION("Signin.AllAccessPointActions", action, | |
| 649 signin_metrics::HISTOGRAM_MAX); | |
| 650 } | |
| 651 | |
| 652 // static | |
| 653 bool OneClickSigninHelper::CanOffer(content::WebContents* web_contents, | |
| 654 CanOfferFor can_offer_for, | |
| 655 const std::string& email, | |
| 656 std::string* error_message) { | |
| 657 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | |
| 658 VLOG(1) << "OneClickSigninHelper::CanOffer"; | |
| 659 | |
| 660 if (error_message) | |
| 661 error_message->clear(); | |
| 662 | |
| 663 if (!web_contents) | |
| 664 return false; | |
| 665 | |
| 666 if (web_contents->GetBrowserContext()->IsOffTheRecord()) | |
| 667 return false; | |
| 668 | |
| 669 Profile* profile = | |
| 670 Profile::FromBrowserContext(web_contents->GetBrowserContext()); | |
| 671 if (!profile) | |
| 672 return false; | |
| 673 | |
| 674 SigninManager* manager = | |
| 675 SigninManagerFactory::GetForProfile(profile); | |
| 676 if (manager && !manager->IsSigninAllowed()) | |
| 677 return false; | |
| 678 | |
| 679 if (can_offer_for == CAN_OFFER_FOR_INTERSTITAL_ONLY && | |
| 680 !profile->GetPrefs()->GetBoolean(prefs::kReverseAutologinEnabled)) | |
| 681 return false; | |
| 682 | |
| 683 if (!ChromeSigninClient::ProfileAllowsSigninCookies(profile)) | |
| 684 return false; | |
| 685 | |
| 686 if (!email.empty()) { | |
| 687 if (!manager) | |
| 688 return false; | |
| 689 | |
| 690 // Make sure this username is not prohibited by policy. | |
| 691 if (!manager->IsAllowedUsername(email)) { | |
| 692 if (error_message) { | |
| 693 error_message->assign( | |
| 694 l10n_util::GetStringUTF8(IDS_SYNC_LOGIN_NAME_PROHIBITED)); | |
| 695 } | |
| 696 return false; | |
| 697 } | |
| 698 | |
| 699 if (can_offer_for != CAN_OFFER_FOR_SECONDARY_ACCOUNT) { | |
| 700 // If the signin manager already has an authenticated name, then this is a | |
| 701 // re-auth scenario. Make sure the email just signed in corresponds to | |
| 702 // the one sign in manager expects. | |
| 703 std::string current_email = manager->GetAuthenticatedUsername(); | |
| 704 const bool same_email = gaia::AreEmailsSame(current_email, email); | |
| 705 if (!current_email.empty() && !same_email) { | |
| 706 UMA_HISTOGRAM_ENUMERATION("Signin.Reauth", | |
| 707 signin_metrics::HISTOGRAM_ACCOUNT_MISSMATCH, | |
| 708 signin_metrics::HISTOGRAM_MAX); | |
| 709 if (error_message) { | |
| 710 error_message->assign( | |
| 711 l10n_util::GetStringFUTF8(IDS_SYNC_WRONG_EMAIL, | |
| 712 base::UTF8ToUTF16(current_email))); | |
| 713 } | |
| 714 return false; | |
| 715 } | |
| 716 | |
| 717 // If some profile, not just the current one, is already connected to this | |
| 718 // account, don't show the infobar. | |
| 719 if (g_browser_process && !same_email) { | |
| 720 ProfileManager* manager = g_browser_process->profile_manager(); | |
| 721 if (manager) { | |
| 722 ProfileInfoCache& cache = manager->GetProfileInfoCache(); | |
| 723 for (size_t i = 0; i < cache.GetNumberOfProfiles(); ++i) { | |
| 724 std::string current_email = | |
| 725 base::UTF16ToUTF8(cache.GetUserNameOfProfileAtIndex(i)); | |
| 726 if (gaia::AreEmailsSame(email, current_email)) { | |
| 727 if (error_message) { | |
| 728 error_message->assign( | |
| 729 l10n_util::GetStringUTF8(IDS_SYNC_USER_NAME_IN_USE_ERROR)); | |
| 730 } | |
| 731 return false; | |
| 732 } | |
| 733 } | |
| 734 } | |
| 735 } | |
| 736 } | |
| 737 | |
| 738 // If email was already rejected by this profile for one-click sign-in. | |
| 739 if (can_offer_for == CAN_OFFER_FOR_INTERSTITAL_ONLY) { | |
| 740 const base::ListValue* rejected_emails = profile->GetPrefs()->GetList( | |
| 741 prefs::kReverseAutologinRejectedEmailList); | |
| 742 if (!rejected_emails->empty()) { | |
| 743 base::ListValue::const_iterator iter = rejected_emails->Find( | |
| 744 base::StringValue(email)); | |
| 745 if (iter != rejected_emails->end()) | |
| 746 return false; | |
| 747 } | |
| 748 } | |
| 749 } | |
| 750 | |
| 751 VLOG(1) << "OneClickSigninHelper::CanOffer: yes we can"; | |
| 752 return true; | |
| 753 } | |
| 754 | |
| 755 // static | |
| 756 OneClickSigninHelper::Offer OneClickSigninHelper::CanOfferOnIOThread( | |
| 757 net::URLRequest* request, | |
| 758 ProfileIOData* io_data) { | |
| 759 return CanOfferOnIOThreadImpl(request->url(), request, io_data); | |
| 760 } | |
| 761 | |
| 762 // static | |
| 763 OneClickSigninHelper::Offer OneClickSigninHelper::CanOfferOnIOThreadImpl( | |
| 764 const GURL& url, | |
| 765 base::SupportsUserData* request, | |
| 766 ProfileIOData* io_data) { | |
| 767 if (!gaia::IsGaiaSignonRealm(url.GetOrigin())) | |
| 768 return IGNORE_REQUEST; | |
| 769 | |
| 770 if (!io_data) | |
| 771 return DONT_OFFER; | |
| 772 | |
| 773 // Check for incognito before other parts of the io_data, since those | |
| 774 // members may not be initalized. | |
| 775 if (io_data->IsOffTheRecord()) | |
| 776 return DONT_OFFER; | |
| 777 | |
| 778 if (!io_data->signin_allowed()->GetValue()) | |
| 779 return DONT_OFFER; | |
| 780 | |
| 781 if (!io_data->reverse_autologin_enabled()->GetValue()) | |
| 782 return DONT_OFFER; | |
| 783 | |
| 784 if (!io_data->google_services_username()->GetValue().empty()) | |
| 785 return DONT_OFFER; | |
| 786 | |
| 787 if (!ChromeSigninClient::SettingsAllowSigninCookies( | |
| 788 io_data->GetCookieSettings())) | |
| 789 return DONT_OFFER; | |
| 790 | |
| 791 // The checks below depend on chrome already knowing what account the user | |
| 792 // signed in with. This happens only after receiving the response containing | |
| 793 // the Google-Accounts-SignIn header. Until then, if there is even a chance | |
| 794 // that we want to connect the profile, chrome needs to tell Gaia that | |
| 795 // it should offer the interstitial. Therefore missing one click data on | |
| 796 // the request means can offer is true. | |
| 797 const std::string& pending_email = io_data->reverse_autologin_pending_email(); | |
| 798 if (!pending_email.empty()) { | |
| 799 if (!SigninManager::IsUsernameAllowedByPolicy(pending_email, | |
| 800 io_data->google_services_username_pattern()->GetValue())) { | |
| 801 return DONT_OFFER; | |
| 802 } | |
| 803 | |
| 804 std::vector<std::string> rejected_emails = | |
| 805 io_data->one_click_signin_rejected_email_list()->GetValue(); | |
| 806 if (std::count_if(rejected_emails.begin(), rejected_emails.end(), | |
| 807 std::bind2nd(std::equal_to<std::string>(), | |
| 808 pending_email)) > 0) { | |
| 809 return DONT_OFFER; | |
| 810 } | |
| 811 | |
| 812 if (io_data->signin_names()->GetEmails().count( | |
| 813 base::UTF8ToUTF16(pending_email)) > 0) { | |
| 814 return DONT_OFFER; | |
| 815 } | |
| 816 } | |
| 817 | |
| 818 return CAN_OFFER; | |
| 819 } | |
| 820 | |
| 821 // static | |
| 822 void OneClickSigninHelper::ShowInfoBarIfPossible(net::URLRequest* request, | |
| 823 ProfileIOData* io_data, | |
| 824 int child_id, | |
| 825 int route_id) { | |
| 826 std::string google_chrome_signin_value; | |
| 827 std::string google_accounts_signin_value; | |
| 828 request->GetResponseHeaderByName("Google-Chrome-SignIn", | |
| 829 &google_chrome_signin_value); | |
| 830 request->GetResponseHeaderByName("Google-Accounts-SignIn", | |
| 831 &google_accounts_signin_value); | |
| 832 | |
| 833 if (!google_accounts_signin_value.empty() || | |
| 834 !google_chrome_signin_value.empty()) { | |
| 835 VLOG(1) << "OneClickSigninHelper::ShowInfoBarIfPossible:" | |
| 836 << " g-a-s='" << google_accounts_signin_value << "'" | |
| 837 << " g-c-s='" << google_chrome_signin_value << "'"; | |
| 838 } | |
| 839 | |
| 840 if (!gaia::IsGaiaSignonRealm(request->url().GetOrigin())) | |
| 841 return; | |
| 842 | |
| 843 // Parse Google-Accounts-SignIn. | |
| 844 base::StringPairs pairs; | |
| 845 base::SplitStringIntoKeyValuePairs(google_accounts_signin_value, '=', ',', | |
| 846 &pairs); | |
| 847 std::string session_index; | |
| 848 std::string email; | |
| 849 for (size_t i = 0; i < pairs.size(); ++i) { | |
| 850 const std::pair<std::string, std::string>& pair = pairs[i]; | |
| 851 const std::string& key = pair.first; | |
| 852 const std::string& value = pair.second; | |
| 853 if (key == "email") { | |
| 854 base::TrimString(value, "\"", &email); | |
| 855 } else if (key == "sessionindex") { | |
| 856 session_index = value; | |
| 857 } | |
| 858 } | |
| 859 | |
| 860 // Later in the chain of this request, we'll need to check the email address | |
| 861 // in the IO thread (see CanOfferOnIOThread). So save the email address as | |
| 862 // user data on the request (only for web-based flow). | |
| 863 if (!email.empty()) | |
| 864 io_data->set_reverse_autologin_pending_email(email); | |
| 865 | |
| 866 if (!email.empty() || !session_index.empty()) { | |
| 867 VLOG(1) << "OneClickSigninHelper::ShowInfoBarIfPossible:" | |
| 868 << " email=" << email | |
| 869 << " sessionindex=" << session_index; | |
| 870 } | |
| 871 | |
| 872 // Parse Google-Chrome-SignIn. | |
| 873 AutoAccept auto_accept = AUTO_ACCEPT_NONE; | |
| 874 signin_metrics::Source source = signin_metrics::SOURCE_UNKNOWN; | |
| 875 GURL continue_url; | |
| 876 std::vector<std::string> tokens; | |
| 877 base::SplitString(google_chrome_signin_value, ',', &tokens); | |
| 878 for (size_t i = 0; i < tokens.size(); ++i) { | |
| 879 const std::string& token = tokens[i]; | |
| 880 if (token == "accepted") { | |
| 881 auto_accept = AUTO_ACCEPT_ACCEPTED; | |
| 882 } else if (token == "configure") { | |
| 883 auto_accept = AUTO_ACCEPT_CONFIGURE; | |
| 884 } else if (token == "rejected-for-profile") { | |
| 885 auto_accept = AUTO_ACCEPT_REJECTED_FOR_PROFILE; | |
| 886 } | |
| 887 } | |
| 888 | |
| 889 // If this is an explicit sign in (i.e., first run, NTP, Apps page, menu, | |
| 890 // settings) then force the auto accept type to explicit. | |
| 891 source = GetSigninSource(request->url(), &continue_url); | |
| 892 if (source != signin_metrics::SOURCE_UNKNOWN) | |
| 893 auto_accept = AUTO_ACCEPT_EXPLICIT; | |
| 894 | |
| 895 if (auto_accept != AUTO_ACCEPT_NONE) { | |
| 896 VLOG(1) << "OneClickSigninHelper::ShowInfoBarIfPossible:" | |
| 897 << " auto_accept=" << auto_accept; | |
| 898 } | |
| 899 | |
| 900 // If |session_index|, |email|, |auto_accept|, and |continue_url| all have | |
| 901 // their default value, don't bother posting a task to the UI thread. | |
| 902 // It will be a noop anyway. | |
| 903 // | |
| 904 // The two headers above may (but not always) come in different http requests | |
| 905 // so a post to the UI thread is still needed if |auto_accept| is not its | |
| 906 // default value, but |email| and |session_index| are. | |
| 907 if (session_index.empty() && email.empty() && | |
| 908 auto_accept == AUTO_ACCEPT_NONE && !continue_url.is_valid()) { | |
| 909 return; | |
| 910 } | |
| 911 | |
| 912 content::BrowserThread::PostTask( | |
| 913 content::BrowserThread::UI, FROM_HERE, | |
| 914 base::Bind(&OneClickSigninHelper::ShowInfoBarUIThread, session_index, | |
| 915 email, auto_accept, source, continue_url, child_id, route_id)); | |
| 916 } | |
| 917 | |
| 918 // static | |
| 919 void OneClickSigninHelper::LogConfirmHistogramValue(int action) { | |
| 920 UMA_HISTOGRAM_ENUMERATION("Signin.OneClickConfirmation", action, | |
| 921 signin_metrics::HISTOGRAM_CONFIRM_MAX); | |
| 922 } | |
| 923 // static | |
| 924 void OneClickSigninHelper::ShowInfoBarUIThread( | |
| 925 const std::string& session_index, | |
| 926 const std::string& email, | |
| 927 AutoAccept auto_accept, | |
| 928 signin_metrics::Source source, | |
| 929 const GURL& continue_url, | |
| 930 int child_id, | |
| 931 int route_id) { | |
| 932 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | |
| 933 | |
| 934 content::WebContents* web_contents = tab_util::GetWebContentsByID(child_id, | |
| 935 route_id); | |
| 936 if (!web_contents) | |
| 937 return; | |
| 938 | |
| 939 // TODO(mathp): The appearance of this infobar should be tested using a | |
| 940 // browser_test. | |
| 941 OneClickSigninHelper* helper = | |
| 942 OneClickSigninHelper::FromWebContents(web_contents); | |
| 943 if (!helper) | |
| 944 return; | |
| 945 | |
| 946 if (auto_accept != AUTO_ACCEPT_NONE) | |
| 947 helper->auto_accept_ = auto_accept; | |
| 948 | |
| 949 if (source != signin_metrics::SOURCE_UNKNOWN && | |
| 950 helper->source_ == signin_metrics::SOURCE_UNKNOWN) { | |
| 951 helper->source_ = source; | |
| 952 } | |
| 953 | |
| 954 // Save the email in the one-click signin manager. The manager may | |
| 955 // not exist if the contents is incognito or if the profile is already | |
| 956 // connected to a Google account. | |
| 957 if (!session_index.empty()) | |
| 958 helper->session_index_ = session_index; | |
| 959 | |
| 960 if (!email.empty()) | |
| 961 helper->email_ = email; | |
| 962 | |
| 963 CanOfferFor can_offer_for = | |
| 964 (auto_accept != AUTO_ACCEPT_EXPLICIT && | |
| 965 helper->auto_accept_ != AUTO_ACCEPT_EXPLICIT) ? | |
| 966 CAN_OFFER_FOR_INTERSTITAL_ONLY : CAN_OFFER_FOR_ALL; | |
| 967 | |
| 968 std::string error_message; | |
| 969 | |
| 970 if (!web_contents || !CanOffer(web_contents, can_offer_for, email, | |
| 971 &error_message)) { | |
| 972 VLOG(1) << "OneClickSigninHelper::ShowInfoBarUIThread: not offering"; | |
| 973 // TODO(rogerta): Can we just display our error now instead of keeping it | |
| 974 // around and doing it later? | |
| 975 if (helper && helper->error_message_.empty() && !error_message.empty()) | |
| 976 helper->error_message_ = error_message; | |
| 977 | |
| 978 return; | |
| 979 } | |
| 980 | |
| 981 // Only allow the dedicated signin process to sign the user into | |
| 982 // Chrome without intervention, because it doesn't load any untrusted | |
| 983 // pages. If at any point an untrusted page is detected, chrome will | |
| 984 // show a modal dialog asking the user to confirm. | |
| 985 Profile* profile = | |
| 986 Profile::FromBrowserContext(web_contents->GetBrowserContext()); | |
| 987 SigninClient* signin_client = | |
| 988 profile ? ChromeSigninClientFactory::GetForProfile(profile) : NULL; | |
| 989 helper->untrusted_confirmation_required_ |= | |
| 990 (signin_client && !signin_client->IsSigninProcess(child_id)); | |
| 991 | |
| 992 if (continue_url.is_valid()) { | |
| 993 // Set |original_continue_url_| if it is currently empty. |continue_url| | |
| 994 // could be modified by gaia pages, thus we need to record the original | |
| 995 // continue url to navigate back to the right page when sync setup is | |
| 996 // complete. | |
| 997 if (helper->original_continue_url_.is_empty()) | |
| 998 helper->original_continue_url_ = continue_url; | |
| 999 helper->continue_url_ = continue_url; | |
| 1000 } | |
| 1001 } | |
| 1002 | |
| 1003 // static | |
| 1004 void OneClickSigninHelper::RemoveSigninRedirectURLHistoryItem( | |
| 1005 content::WebContents* web_contents) { | |
| 1006 } | |
| 1007 | |
| 1008 // static | |
| 1009 bool OneClickSigninHelper::HandleCrossAccountError( | |
| 1010 Profile* profile, | |
| 1011 const std::string& session_index, | |
| 1012 const std::string& email, | |
| 1013 const std::string& password, | |
| 1014 const std::string& refresh_token, | |
| 1015 OneClickSigninHelper::AutoAccept auto_accept, | |
| 1016 signin_metrics::Source source, | |
| 1017 OneClickSigninSyncStarter::StartSyncMode start_mode, | |
| 1018 OneClickSigninSyncStarter::Callback sync_callback) { | |
| 1019 std::string last_email = | |
| 1020 profile->GetPrefs()->GetString(prefs::kGoogleServicesLastUsername); | |
| 1021 | |
| 1022 if (!last_email.empty() && !gaia::AreEmailsSame(last_email, email)) { | |
| 1023 // If the new email address is different from the email address that | |
| 1024 // just signed in, show a confirmation dialog on top of the current active | |
| 1025 // tab. | |
| 1026 | |
| 1027 // No need to display a second confirmation so pass false below. | |
| 1028 // TODO(atwilson): Move this into OneClickSigninSyncStarter. | |
| 1029 // The tab modal dialog always executes its callback before |contents| | |
| 1030 // is deleted. | |
| 1031 Browser* browser = chrome::FindLastActiveWithProfile( | |
| 1032 profile, chrome::GetActiveDesktop()); | |
| 1033 content::WebContents* contents = | |
| 1034 browser->tab_strip_model()->GetActiveWebContents(); | |
| 1035 | |
| 1036 ConfirmEmailDialogDelegate::AskForConfirmation( | |
| 1037 contents, | |
| 1038 last_email, | |
| 1039 email, | |
| 1040 base::Bind( | |
| 1041 &StartExplicitSync, | |
| 1042 StartSyncArgs(profile, browser, auto_accept, | |
| 1043 session_index, email, password, | |
| 1044 refresh_token, | |
| 1045 contents, false /* confirmation_required */, source, | |
| 1046 sync_callback), | |
| 1047 contents, | |
| 1048 start_mode)); | |
| 1049 return true; | |
| 1050 } | |
| 1051 | |
| 1052 return false; | |
| 1053 } | |
| 1054 | |
| 1055 // static | |
| 1056 void OneClickSigninHelper::RedirectToNtpOrAppsPage( | |
| 1057 content::WebContents* contents, signin_metrics::Source source) { | |
| 1058 // Do nothing if a navigation is pending, since this call can be triggered | |
| 1059 // from DidStartLoading. This avoids deleting the pending entry while we are | |
| 1060 // still navigating to it. See crbug/346632. | |
| 1061 if (contents->GetController().GetPendingEntry()) | |
| 1062 return; | |
| 1063 | |
| 1064 VLOG(1) << "RedirectToNtpOrAppsPage"; | |
| 1065 // Redirect to NTP/Apps page and display a confirmation bubble | |
| 1066 GURL url(source == signin_metrics::SOURCE_APPS_PAGE_LINK ? | |
| 1067 chrome::kChromeUIAppsURL : chrome::kChromeUINewTabURL); | |
| 1068 content::OpenURLParams params(url, | |
| 1069 content::Referrer(), | |
| 1070 CURRENT_TAB, | |
| 1071 ui::PAGE_TRANSITION_AUTO_TOPLEVEL, | |
| 1072 false); | |
| 1073 contents->OpenURL(params); | |
| 1074 } | |
| 1075 | |
| 1076 // static | |
| 1077 void OneClickSigninHelper::RedirectToNtpOrAppsPageIfNecessary( | |
| 1078 content::WebContents* contents, signin_metrics::Source source) { | |
| 1079 if (source != signin_metrics::SOURCE_SETTINGS) { | |
| 1080 RedirectToNtpOrAppsPage(contents, source); | |
| 1081 } | |
| 1082 } | |
| 1083 | |
| 1084 void OneClickSigninHelper::RedirectToSignin() { | |
| 1085 VLOG(1) << "OneClickSigninHelper::RedirectToSignin"; | |
| 1086 | |
| 1087 // Extract the existing sounce=X value. Default to "2" if missing. | |
| 1088 signin_metrics::Source source = signin::GetSourceForPromoURL(continue_url_); | |
| 1089 if (source == signin_metrics::SOURCE_UNKNOWN) | |
| 1090 source = signin_metrics::SOURCE_MENU; | |
| 1091 GURL page = signin::GetPromoURL(source, false); | |
| 1092 | |
| 1093 content::WebContents* contents = web_contents(); | |
| 1094 contents->GetController().LoadURL(page, | |
| 1095 content::Referrer(), | |
| 1096 ui::PAGE_TRANSITION_AUTO_TOPLEVEL, | |
| 1097 std::string()); | |
| 1098 } | |
| 1099 | |
| 1100 void OneClickSigninHelper::CleanTransientState() { | |
| 1101 VLOG(1) << "OneClickSigninHelper::CleanTransientState"; | |
| 1102 showing_signin_ = false; | |
| 1103 email_.clear(); | |
| 1104 password_.clear(); | |
| 1105 auto_accept_ = AUTO_ACCEPT_NONE; | |
| 1106 source_ = signin_metrics::SOURCE_UNKNOWN; | |
| 1107 switched_to_advanced_ = false; | |
| 1108 continue_url_ = GURL(); | |
| 1109 untrusted_navigations_since_signin_visit_ = 0; | |
| 1110 untrusted_confirmation_required_ = false; | |
| 1111 error_message_.clear(); | |
| 1112 | |
| 1113 // Post to IO thread to clear pending email. | |
| 1114 if (!do_not_clear_pending_email_) { | |
| 1115 Profile* profile = | |
| 1116 Profile::FromBrowserContext(web_contents()->GetBrowserContext()); | |
| 1117 content::BrowserThread::PostTask( | |
| 1118 content::BrowserThread::IO, FROM_HERE, | |
| 1119 base::Bind(&ClearPendingEmailOnIOThread, | |
| 1120 base::Unretained(profile->GetResourceContext()))); | |
| 1121 } | |
| 1122 } | |
| 1123 | |
| 1124 void OneClickSigninHelper::PasswordSubmitted( | |
| 1125 const autofill::PasswordForm& form) { | |
| 1126 // We only need to scrape the password for Gaia logins. | |
| 1127 if (gaia::IsGaiaSignonRealm(GURL(form.signon_realm))) { | |
| 1128 VLOG(1) << "OneClickSigninHelper::DidNavigateAnyFrame: got password"; | |
| 1129 password_ = base::UTF16ToUTF8(form.password_value); | |
| 1130 } | |
| 1131 } | |
| 1132 | |
| 1133 void OneClickSigninHelper::SetDoNotClearPendingEmailForTesting() { | |
| 1134 do_not_clear_pending_email_ = true; | |
| 1135 } | |
| 1136 | |
| 1137 void OneClickSigninHelper::set_do_not_start_sync_for_testing() { | |
| 1138 do_not_start_sync_for_testing_ = true; | |
| 1139 } | |
| 1140 | |
| 1141 void OneClickSigninHelper::DidStartNavigationToPendingEntry( | |
| 1142 const GURL& url, | |
| 1143 content::NavigationController::ReloadType reload_type) { | |
| 1144 VLOG(1) << "OneClickSigninHelper::DidStartNavigationToPendingEntry: url=" << | |
| 1145 url.spec(); | |
| 1146 // If the tab navigates to a new page, and this page is not a valid Gaia | |
| 1147 // sign in redirect or reponse, or the expected continue URL, make sure to | |
| 1148 // clear the internal state. This is needed to detect navigations in the | |
| 1149 // middle of the sign in process that may redirect back to the sign in | |
| 1150 // process (see crbug.com/181163 for details). | |
| 1151 GURL::Replacements replacements; | |
| 1152 replacements.ClearQuery(); | |
| 1153 | |
| 1154 if (!IsValidGaiaSigninRedirectOrResponseURL(url) && | |
| 1155 continue_url_.is_valid() && | |
| 1156 url.ReplaceComponents(replacements) != | |
| 1157 continue_url_.ReplaceComponents(replacements)) { | |
| 1158 if (++untrusted_navigations_since_signin_visit_ > kMaxNavigationsSince) | |
| 1159 CleanTransientState(); | |
| 1160 } | |
| 1161 } | |
| 1162 | |
| 1163 void OneClickSigninHelper::DidNavigateMainFrame( | |
| 1164 const content::LoadCommittedDetails& details, | |
| 1165 const content::FrameNavigateParams& params) { | |
| 1166 if (!SigninManager::IsWebBasedSigninFlowURL(params.url)) { | |
| 1167 // Make sure the renderer process is no longer considered the trusted | |
| 1168 // sign-in process when a navigation to a non-sign-in URL occurs. | |
| 1169 Profile* profile = | |
| 1170 Profile::FromBrowserContext(web_contents()->GetBrowserContext()); | |
| 1171 SigninClient* signin_client = | |
| 1172 profile ? ChromeSigninClientFactory::GetForProfile(profile) : NULL; | |
| 1173 int process_id = web_contents()->GetRenderProcessHost()->GetID(); | |
| 1174 if (signin_client && signin_client->IsSigninProcess(process_id)) | |
| 1175 signin_client->ClearSigninProcess(); | |
| 1176 | |
| 1177 // If the navigation to a non-sign-in URL hasn't been triggered by the web | |
| 1178 // contents, the sign in flow has been aborted and the state must be | |
| 1179 // cleaned (crbug.com/269421). | |
| 1180 if (!ui::PageTransitionIsWebTriggerable(params.transition) && | |
| 1181 auto_accept_ != AUTO_ACCEPT_NONE) { | |
| 1182 CleanTransientState(); | |
| 1183 } | |
| 1184 } | |
| 1185 } | |
| 1186 | |
| 1187 void OneClickSigninHelper::DidStopLoading( | |
| 1188 content::RenderViewHost* render_view_host) { | |
| 1189 // If the user left the sign in process, clear all members. | |
| 1190 // TODO(rogerta): might need to allow some youtube URLs. | |
| 1191 content::WebContents* contents = web_contents(); | |
| 1192 const GURL url = contents->GetLastCommittedURL(); | |
| 1193 Profile* profile = | |
| 1194 Profile::FromBrowserContext(contents->GetBrowserContext()); | |
| 1195 VLOG(1) << "OneClickSigninHelper::DidStopLoading: url=" << url.spec(); | |
| 1196 | |
| 1197 if (url.scheme() == content::kChromeUIScheme) { | |
| 1198 // Suppresses OneClickSigninHelper on webUI pages to avoid inteference with | |
| 1199 // inline signin flows. | |
| 1200 VLOG(1) << "OneClickSigninHelper::DidStopLoading: suppressed for url=" | |
| 1201 << url.spec(); | |
| 1202 CleanTransientState(); | |
| 1203 return; | |
| 1204 } | |
| 1205 | |
| 1206 // If an error has already occured during the sign in flow, make sure to | |
| 1207 // display it to the user and abort the process. Do this only for | |
| 1208 // explicit sign ins. | |
| 1209 // TODO(rogerta): Could we move this code back up to ShowInfoBarUIThread()? | |
| 1210 if (!error_message_.empty() && auto_accept_ == AUTO_ACCEPT_EXPLICIT) { | |
| 1211 VLOG(1) << "OneClickSigninHelper::DidStopLoading: error=" << error_message_; | |
| 1212 RemoveSigninRedirectURLHistoryItem(contents); | |
| 1213 // After we redirect to NTP, our browser pointer gets corrupted because the | |
| 1214 // WebContents have changed, so grab the browser pointer | |
| 1215 // before the navigation. | |
| 1216 Browser* browser = chrome::FindBrowserWithWebContents(contents); | |
| 1217 | |
| 1218 // Redirect to the landing page and display an error popup. | |
| 1219 RedirectToNtpOrAppsPage(web_contents(), source_); | |
| 1220 LoginUIServiceFactory::GetForProfile(profile)-> | |
| 1221 DisplayLoginResult(browser, base::UTF8ToUTF16(error_message_)); | |
| 1222 CleanTransientState(); | |
| 1223 return; | |
| 1224 } | |
| 1225 | |
| 1226 if (AreWeShowingSignin(url, source_, email_)) { | |
| 1227 if (!showing_signin_) | |
| 1228 LogHistogramValue(signin_metrics::HISTOGRAM_SHOWN); | |
| 1229 showing_signin_ = true; | |
| 1230 } | |
| 1231 | |
| 1232 // When Gaia finally redirects to the continue URL, Gaia will add some | |
| 1233 // extra query parameters. So ignore the parameters when checking to see | |
| 1234 // if the user has continued. Sometimes locales will redirect to a country- | |
| 1235 // specific TLD so just make sure it's a valid domain instead of comparing | |
| 1236 // for an exact match. | |
| 1237 GURL::Replacements replacements; | |
| 1238 replacements.ClearQuery(); | |
| 1239 bool google_domain_url = google_util::IsGoogleDomainUrl( | |
| 1240 url, | |
| 1241 google_util::ALLOW_SUBDOMAIN, | |
| 1242 google_util::DISALLOW_NON_STANDARD_PORTS); | |
| 1243 const bool continue_url_match = | |
| 1244 google_domain_url && | |
| 1245 url.ReplaceComponents(replacements).path() == | |
| 1246 continue_url_.ReplaceComponents(replacements).path(); | |
| 1247 const bool original_continue_url_match = | |
| 1248 google_domain_url && | |
| 1249 url.ReplaceComponents(replacements).path() == | |
| 1250 original_continue_url_.ReplaceComponents(replacements).path(); | |
| 1251 | |
| 1252 if (continue_url_match) | |
| 1253 RemoveSigninRedirectURLHistoryItem(contents); | |
| 1254 | |
| 1255 // If there is no valid email yet, there is nothing to do. As of M26, the | |
| 1256 // password is allowed to be empty, since its no longer required to setup | |
| 1257 // sync. | |
| 1258 if (email_.empty()) { | |
| 1259 VLOG(1) << "OneClickSigninHelper::DidStopLoading: nothing to do"; | |
| 1260 // Original-url check done because some user actions cans get us to a page | |
| 1261 // via a POST instead of a GET (and thus to immediate "cuntinue url") but | |
| 1262 // we still want redirects from the "blank.html" landing page to work for | |
| 1263 // non-security related redirects like NTP. | |
| 1264 // https://code.google.com/p/chromium/issues/detail?id=321938 | |
| 1265 if (original_continue_url_match) { | |
| 1266 if (auto_accept_ == AUTO_ACCEPT_EXPLICIT) | |
| 1267 RedirectToSignin(); | |
| 1268 std::string unused_value; | |
| 1269 if (net::GetValueForKeyInQuery(url, "ntp", &unused_value)) { | |
| 1270 signin::SetUserSkippedPromo(profile); | |
| 1271 RedirectToNtpOrAppsPage(web_contents(), source_); | |
| 1272 } | |
| 1273 } else { | |
| 1274 if (!IsValidGaiaSigninRedirectOrResponseURL(url) && | |
| 1275 ++untrusted_navigations_since_signin_visit_ > kMaxNavigationsSince) { | |
| 1276 CleanTransientState(); | |
| 1277 } | |
| 1278 } | |
| 1279 | |
| 1280 return; | |
| 1281 } | |
| 1282 | |
| 1283 if (!continue_url_match && IsValidGaiaSigninRedirectOrResponseURL(url)) | |
| 1284 return; | |
| 1285 | |
| 1286 // During an explicit sign in, if the user has not yet reached the final | |
| 1287 // continue URL, wait for it to arrive. Note that Gaia will add some extra | |
| 1288 // query parameters to the continue URL. Ignore them when checking to | |
| 1289 // see if the user has continued. | |
| 1290 // | |
| 1291 // If this is not an explicit sign in, we don't need to check if we landed | |
| 1292 // on the right continue URL. This is important because the continue URL | |
| 1293 // may itself lead to a redirect, which means this function will never see | |
| 1294 // the continue URL go by. | |
| 1295 if (auto_accept_ == AUTO_ACCEPT_EXPLICIT) { | |
| 1296 DCHECK(source_ != signin_metrics::SOURCE_UNKNOWN); | |
| 1297 if (!continue_url_match) { | |
| 1298 VLOG(1) << "OneClickSigninHelper::DidStopLoading: invalid url='" | |
| 1299 << url.spec() | |
| 1300 << "' expected continue url=" << continue_url_; | |
| 1301 CleanTransientState(); | |
| 1302 return; | |
| 1303 } | |
| 1304 | |
| 1305 // In explicit sign ins, the user may have changed the box | |
| 1306 // "Let me choose what to sync". This is reflected as a change in the | |
| 1307 // source of the continue URL. Make one last check of the current URL | |
| 1308 // to see if there is a valid source. If so, it overrides the | |
| 1309 // current source. | |
| 1310 // | |
| 1311 // If the source was changed to SOURCE_SETTINGS, we want | |
| 1312 // OneClickSigninSyncStarter to reuse the current tab to display the | |
| 1313 // advanced configuration. | |
| 1314 signin_metrics::Source source = signin::GetSourceForPromoURL(url); | |
| 1315 if (source != source_) { | |
| 1316 source_ = source; | |
| 1317 switched_to_advanced_ = source == signin_metrics::SOURCE_SETTINGS; | |
| 1318 } | |
| 1319 } | |
| 1320 | |
| 1321 Browser* browser = chrome::FindBrowserWithWebContents(contents); | |
| 1322 | |
| 1323 VLOG(1) << "OneClickSigninHelper::DidStopLoading: signin is go." | |
| 1324 << " auto_accept=" << auto_accept_ | |
| 1325 << " source=" << source_; | |
| 1326 | |
| 1327 switch (auto_accept_) { | |
| 1328 case AUTO_ACCEPT_NONE: | |
| 1329 if (showing_signin_) | |
| 1330 LogHistogramValue(signin_metrics::HISTOGRAM_DISMISSED); | |
| 1331 break; | |
| 1332 case AUTO_ACCEPT_ACCEPTED: | |
| 1333 LogHistogramValue(signin_metrics::HISTOGRAM_ACCEPTED); | |
| 1334 LogHistogramValue(signin_metrics::HISTOGRAM_WITH_DEFAULTS); | |
| 1335 SigninManager::DisableOneClickSignIn(profile->GetPrefs()); | |
| 1336 // Start syncing with the default settings - prompt the user to sign in | |
| 1337 // first. | |
| 1338 if (!do_not_start_sync_for_testing_) { | |
| 1339 StartSync( | |
| 1340 StartSyncArgs(profile, browser, auto_accept_, | |
| 1341 session_index_, email_, password_, "", | |
| 1342 NULL /* don't force sync setup in same tab */, | |
| 1343 true /* confirmation_required */, source_, | |
| 1344 OneClickSigninSyncStarter::Callback()), | |
| 1345 OneClickSigninSyncStarter::SYNC_WITH_DEFAULT_SETTINGS); | |
| 1346 } | |
| 1347 break; | |
| 1348 case AUTO_ACCEPT_CONFIGURE: | |
| 1349 LogHistogramValue(signin_metrics::HISTOGRAM_ACCEPTED); | |
| 1350 LogHistogramValue(signin_metrics::HISTOGRAM_WITH_ADVANCED); | |
| 1351 SigninManager::DisableOneClickSignIn(profile->GetPrefs()); | |
| 1352 // Display the extra confirmation (even in the SAML case) in case this | |
| 1353 // was an untrusted renderer. | |
| 1354 if (!do_not_start_sync_for_testing_) { | |
| 1355 StartSync( | |
| 1356 StartSyncArgs(profile, browser, auto_accept_, | |
| 1357 session_index_, email_, password_, "", | |
| 1358 NULL /* don't force sync setup in same tab */, | |
| 1359 true /* confirmation_required */, source_, | |
| 1360 OneClickSigninSyncStarter::Callback()), | |
| 1361 OneClickSigninSyncStarter::CONFIGURE_SYNC_FIRST); | |
| 1362 } | |
| 1363 break; | |
| 1364 case AUTO_ACCEPT_EXPLICIT: { | |
| 1365 signin_metrics::Source original_source = | |
| 1366 signin::GetSourceForPromoURL(original_continue_url_); | |
| 1367 if (switched_to_advanced_) { | |
| 1368 LogHistogramValue(signin_metrics::HISTOGRAM_WITH_ADVANCED); | |
| 1369 LogHistogramValue(signin_metrics::HISTOGRAM_ACCEPTED); | |
| 1370 } else { | |
| 1371 LogHistogramValue(signin_metrics::HISTOGRAM_ACCEPTED); | |
| 1372 LogHistogramValue(signin_metrics::HISTOGRAM_WITH_DEFAULTS); | |
| 1373 } | |
| 1374 | |
| 1375 // - If sign in was initiated from the NTP or the hotdog menu, sync with | |
| 1376 // default settings. | |
| 1377 // - If sign in was initiated from the settings page for first time sync | |
| 1378 // set up, show the advanced sync settings dialog. | |
| 1379 // - If sign in was initiated from the settings page due to a re-auth when | |
| 1380 // sync was already setup, simply navigate back to the settings page. | |
| 1381 ProfileSyncService* sync_service = | |
| 1382 ProfileSyncServiceFactory::GetForProfile(profile); | |
| 1383 SigninErrorController* error_controller = | |
| 1384 SigninErrorControllerFactory::GetForProfile(profile); | |
| 1385 | |
| 1386 OneClickSigninSyncStarter::StartSyncMode start_mode = | |
| 1387 source_ == signin_metrics::SOURCE_SETTINGS ? | |
| 1388 (error_controller->HasError() && | |
| 1389 sync_service && sync_service->HasSyncSetupCompleted()) ? | |
| 1390 OneClickSigninSyncStarter::SHOW_SETTINGS_WITHOUT_CONFIGURE : | |
| 1391 OneClickSigninSyncStarter::CONFIGURE_SYNC_FIRST : | |
| 1392 OneClickSigninSyncStarter::SYNC_WITH_DEFAULT_SETTINGS; | |
| 1393 | |
| 1394 if (!HandleCrossAccountError(profile, session_index_, email_, password_, | |
| 1395 "", auto_accept_, source_, start_mode, | |
| 1396 OneClickSigninSyncStarter::Callback())) { | |
| 1397 if (!do_not_start_sync_for_testing_) { | |
| 1398 StartSync( | |
| 1399 StartSyncArgs(profile, browser, auto_accept_, | |
| 1400 session_index_, email_, password_, "", | |
| 1401 contents, | |
| 1402 untrusted_confirmation_required_, source_, | |
| 1403 OneClickSigninSyncStarter::Callback()), | |
| 1404 start_mode); | |
| 1405 } | |
| 1406 | |
| 1407 // If this explicit sign in is not from settings page/webstore, show | |
| 1408 // the NTP/Apps page after sign in completes. In the case of the | |
| 1409 // settings page, it will get auto-closed after sync setup. In the case | |
| 1410 // of webstore, it will redirect back to webstore. | |
| 1411 RedirectToNtpOrAppsPageIfNecessary(web_contents(), source_); | |
| 1412 } | |
| 1413 | |
| 1414 // Observe the sync service if the settings tab requested a gaia sign in, | |
| 1415 // so that when sign in and sync setup are successful, we can redirect to | |
| 1416 // the correct URL, or auto-close the gaia sign in tab. | |
| 1417 if (original_source == signin_metrics::SOURCE_SETTINGS) { | |
| 1418 // The observer deletes itself once it's done. | |
| 1419 new OneClickSigninSyncObserver(contents, original_continue_url_); | |
| 1420 } | |
| 1421 break; | |
| 1422 } | |
| 1423 case AUTO_ACCEPT_REJECTED_FOR_PROFILE: | |
| 1424 AddEmailToOneClickRejectedList(profile, email_); | |
| 1425 LogHistogramValue(signin_metrics::HISTOGRAM_REJECTED); | |
| 1426 break; | |
| 1427 default: | |
| 1428 NOTREACHED() << "Invalid auto_accept=" << auto_accept_; | |
| 1429 break; | |
| 1430 } | |
| 1431 | |
| 1432 CleanTransientState(); | |
| 1433 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 914363003:
Remove OneClickSigninHelper since it is no longer used. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@ocl