Refactor CredentialManagerImpl::RequireUserMediation method.

components/password_manager/content/browser/credential_manager_impl.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 "components/password_manager/content/browser/credential_manager_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/metrics/user_metrics.h"
@@ skipping 100 matching lines @@
       std::move(form_manager_), CredentialSourceType::CREDENTIAL_SOURCE_API,
       false);
 }
 
 void CredentialManagerImpl::RequireUserMediation(
     const RequireUserMediationCallback& callback) {
   if (password_manager_util::IsLoggingActive(client_)) {
     CredentialManagerLogger(client_->GetLogManager())
         .LogRequireUserMediation(web_contents()->GetLastCommittedURL());
   }
+  // Send acknowledge response back.
+  callback.Run();
+
   PasswordStore* store = GetPasswordStore();
   if (!store || !client_->IsSavingAndFillingEnabledForCurrentPage() ||
-      !client_->OnCredentialManagerUsed()) {
-    callback.Run();
+      !client_->OnCredentialManagerUsed())
     return;
-  }
 
-  if (store->affiliated_match_helper()) {
-    store->affiliated_match_helper()->GetAffiliatedAndroidRealms(
-        GetSynthesizedFormForOrigin(),
-        base::Bind(&CredentialManagerImpl::ScheduleRequireMediationTask,
-                   weak_factory_.GetWeakPtr(), callback));
-  } else {
-    std::vector<std::string> no_affiliated_realms;
-    ScheduleRequireMediationTask(callback, no_affiliated_realms);
-  }
-}
-
-void CredentialManagerImpl::ScheduleRequireMediationTask(
-    const RequireUserMediationCallback& callback,
-    const std::vector<std::string>& android_realms) {
-  DCHECK(GetPasswordStore());
   if (!pending_require_user_mediation_) {
     pending_require_user_mediation_.reset(
-        new CredentialManagerPendingRequireUserMediationTask(
-            this, web_contents()->GetLastCommittedURL().GetOrigin(),
-            android_realms));
-
-    // This will result in a callback to
-    // CredentialManagerPendingRequireUserMediationTask::
-    // OnGetPasswordStoreResults().
-    GetPasswordStore()->GetAutofillableLogins(
-        pending_require_user_mediation_.get());
-  } else {
-    pending_require_user_mediation_->AddOrigin(
-        web_contents()->GetLastCommittedURL().GetOrigin());
+        new CredentialManagerPendingRequireUserMediationTask(this));
   }
-
-  // Send acknowledge response back.
-  callback.Run();
+  pending_require_user_mediation_->AddOrigin(GetSynthesizedFormForOrigin());
 }
 
 void CredentialManagerImpl::Get(bool zero_click_only,
                                 bool include_passwords,
                                 const std::vector<GURL>& federations,
                                 const GetCallback& callback) {
   using metrics_util::LogCredentialManagerGetResult;
   metrics_util::CredentialManagerGetMediation mediation_status =
       zero_click_only ? metrics_util::CREDENTIAL_MANAGER_GET_UNMEDIATED
                       : metrics_util::CREDENTIAL_MANAGER_GET_MEDIATED;
@@ skipping 142 matching lines @@
   digest.signon_realm = digest.origin.spec();
   return digest;
 }
 
 void CredentialManagerImpl::DoneRequiringUserMediation() {
   DCHECK(pending_require_user_mediation_);
   pending_require_user_mediation_.reset();
 }
 
 }  // namespace password_manager