Revert of Reland: Switch components/password_manager code from IPC messages to Mojo.

ios/chrome/browser/passwords/credential_manager.mm

 // Copyright 2015 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.
 
 #import "ios/chrome/browser/passwords/credential_manager.h"
 
 #include <utility>
 
 #include "base/ios/ios_util.h"
 #import "base/ios/weak_nsobject.h"
@@ skipping 99 matching lines @@
 
 void CredentialManager::CredentialsRequested(
     int request_id,
     const GURL& source_url,
     bool zero_click_only,
     const std::vector<std::string>& federations,
     bool is_user_initiated) {
   // Invoked when the page invokes navigator.credentials.request(), this
   // function will attempt to retrieve a Credential from the PasswordStore that
   // meets the specified parameters and, if successful, send it back to the page
-  // via SendCredentialByID.
+  // via SendCredential.
   DCHECK_GE(request_id, 0);
   password_manager::PasswordStore* store = GetPasswordStore();
 
   // If there's an outstanding request, or the PasswordStore isn't loaded yet,
   // the request should fail outright and the JS Promise should be rejected
   // with an appropriate error.
   if (pending_request_ || !store) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&CredentialManager::RejectPromise,
                    weak_factory_.GetWeakPtr(), request_id,
                    pending_request_ ? ERROR_TYPE_PENDING_REQUEST
                                     : ERROR_TYPE_PASSWORD_STORE_UNAVAILABLE));
     return;
   }
 
   // If the page requested a zero-click credential -- one that can be returned
   // without first asking the user -- and if zero-click isn't currently
   // available, send back an empty credential.
   if (zero_click_only && !IsZeroClickAllowed()) {
     base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(&CredentialManager::SendCredentialByID,
+        FROM_HERE, base::Bind(&CredentialManager::SendCredential,
                               weak_factory_.GetWeakPtr(), request_id,
                               password_manager::CredentialInfo()));
     return;
   }
 
   // If the page origin is untrusted, the request should be rejected.
   GURL page_url;
   if (!GetUrlWithAbsoluteTrust(&page_url)) {
     RejectPromise(request_id, ERROR_TYPE_SECURITY_ERROR_UNTRUSTED_ORIGIN);
     return;
   }
 
   // Bundle up the arguments and forward them to the PasswordStore, which will
   // asynchronously return the resulting Credential by invoking
   // |SendCredential|.
   std::vector<GURL> federation_urls;
   for (const auto& federation : federations)
     federation_urls.push_back(GURL(federation));
   std::vector<std::string> realms;
   pending_request_.reset(
       new password_manager::CredentialManagerPendingRequestTask(
-          this, base::Bind(&CredentialManager::SendCredentialByID,
-                           base::Unretained(this), request_id),
-          zero_click_only, page_url, true, federation_urls, realms));
+          this, request_id, zero_click_only, page_url, true, federation_urls,
+          realms));
   store->GetAutofillableLogins(pending_request_.get());
 }
 
 void CredentialManager::SignedIn(int request_id,
                                  const GURL& source_url,
                                  const web::Credential& credential) {
   // Invoked when the page invokes navigator.credentials.notifySignedIn(), this
   // function stores the signed-in |credential| and sends a message back to the
   // page to resolve the Promise associated with |request_id|.
   DCHECK(credential.type != web::CredentialType::CREDENTIAL_TYPE_EMPTY);
@@ skipping 86 matching lines @@
 
 GURL CredentialManager::GetOrigin() const {
   web::URLVerificationTrustLevel trust_level =
       web::URLVerificationTrustLevel::kNone;
   const GURL page_url(web_state()->GetCurrentURL(&trust_level));
   DCHECK_EQ(trust_level, web::URLVerificationTrustLevel::kAbsolute);
   return page_url;
 }
 
 void CredentialManager::SendCredential(
-    const password_manager::SendCredentialCallback& send_callback,
-    const password_manager::CredentialInfo& credential) {
-  send_callback.Run(credential);
-}
-
-void CredentialManager::SendCredentialByID(
     int request_id,
     const password_manager::CredentialInfo& credential) {
   // Invoked when the asynchronous interaction with the PasswordStore completes,
   // this function forwards a |credential| back to the page via |js_manager_| by
   // resolving the JavaScript Promise associated with |request_id|.
   base::WeakPtr<CredentialManager> weak_this = weak_factory_.GetWeakPtr();
   [js_manager_
       resolvePromiseWithRequestID:request_id
                        credential:WebCredentialFromCredentialInfo(credential)
                 completionHandler:^(BOOL) {
                   if (weak_this)
                     weak_this->pending_request_.reset();
                 }];
 }
 
-void CredentialManager::SendPasswordForm(
-    const password_manager::SendCredentialCallback& send_callback,
-    const autofill::PasswordForm* form) {
+void CredentialManager::SendPasswordForm(int request_id,
+                                         const autofill::PasswordForm* form) {
   password_manager::CredentialInfo info;
   if (form) {
     password_manager::CredentialType type_to_return =
         form->federation_origin.unique()
             ? password_manager::CredentialType::CREDENTIAL_TYPE_PASSWORD
             : password_manager::CredentialType::CREDENTIAL_TYPE_FEDERATED;
     info = password_manager::CredentialInfo(*form, type_to_return);
     // TODO(vasilii): update |skip_zero_click| in the store (crbug.com/594110).
   }
-  SendCredential(send_callback, info);
+  SendCredential(request_id, info);
 }
 
 password_manager::PasswordManagerClient* CredentialManager::client() const {
   return client_;
 }
 
 autofill::PasswordForm CredentialManager::GetSynthesizedFormForOrigin() const {
   autofill::PasswordForm synthetic_form;
   synthetic_form.origin = web_state()->GetLastCommittedURL().GetOrigin();
   synthetic_form.signon_realm = synthetic_form.origin.spec();
@@ skipping 60 matching lines @@
 bool CredentialManager::GetUrlWithAbsoluteTrust(GURL* page_url) {
   web::URLVerificationTrustLevel trust_level =
       web::URLVerificationTrustLevel::kNone;
   const GURL possibly_untrusted_url(web_state()->GetCurrentURL(&trust_level));
   if (trust_level == web::URLVerificationTrustLevel::kAbsolute) {
     *page_url = possibly_untrusted_url;
     return true;
   }
   return false;
 }