Rename Origin.unique() to opaque().

components/password_manager/core/browser/credential_manager_pending_request_task.cc

 // 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.
 
 #include "components/password_manager/core/browser/credential_manager_pending_request_task.h"
 
 #include <algorithm>
 #include <iterator>
 #include <map>
 #include <utility>
@@ skipping 53 matching lines @@
 // Remove duplicates in |forms| before displaying them in the account chooser.
 void FilterDuplicates(
     std::vector<std::unique_ptr<autofill::PasswordForm>>* forms) {
   std::vector<std::unique_ptr<autofill::PasswordForm>> federated_forms;
   // The key is [username, signon_realm]. signon_realm is used only for PSL
   // matches because those entries have it in the UI.
   std::map<std::pair<base::string16, std::string>,
            std::unique_ptr<autofill::PasswordForm>>
       credentials;
   for (auto& form : *forms) {
-    if (!form->federation_origin.unique()) {
+    if (!form->federation_origin.opaque()) {
       federated_forms.push_back(std::move(form));
     } else {
       auto key = std::make_pair(
           form->username_value,
           form->is_public_suffix_match ? form->signon_realm : std::string());
       auto it = credentials.find(key);
       if (it == credentials.end() || IsBetterMatch(*form, *it->second))
         credentials[key] = std::move(form);
     }
   }
@@ skipping 69 matching lines @@
                                   mediation_);
     delegate_->SendCredential(send_callback_, CredentialInfo());
     return;
   }
 
   std::vector<std::unique_ptr<autofill::PasswordForm>> local_results;
   std::vector<std::unique_ptr<autofill::PasswordForm>> psl_results;
   for (auto& form : results) {
     // Ensure that the form we're looking at matches the password and
     // federation filters provided.
-    if (!((form->federation_origin.unique() && include_passwords_) ||
-          (!form->federation_origin.unique() &&
+    if (!((form->federation_origin.opaque() && include_passwords_) ||
+          (!form->federation_origin.opaque() &&
            federations_.count(form->federation_origin.Serialize())))) {
       continue;
     }
 
     // PasswordFrom and GURL have different definition of origin.
     // PasswordForm definition: scheme, host, port and path.
     // GURL definition: scheme, host, and port.
     // So we can't compare them directly.
     if (form->is_affiliation_based_match ||
         form->origin.GetOrigin() == origin_.GetOrigin()) {
@@ skipping 15 matching lines @@
   //
   // Moreover, we only return such a credential if the user has opted-in via the
   // first-run experience.
   const bool can_use_autosignin =
       mediation_ != CredentialMediationRequirement::kRequired &&
       local_results.size() == 1u && delegate_->IsZeroClickAllowed();
   if (can_use_autosignin && !local_results[0]->skip_zero_click &&
       !password_bubble_experiment::ShouldShowAutoSignInPromptFirstRunExperience(
           delegate_->client()->GetPrefs())) {
     CredentialInfo info(*local_results[0],
-                        local_results[0]->federation_origin.unique()
+                        local_results[0]->federation_origin.opaque()
                             ? CredentialType::CREDENTIAL_TYPE_PASSWORD
                             : CredentialType::CREDENTIAL_TYPE_FEDERATED);
     delegate_->client()->NotifyUserAutoSignin(std::move(local_results),
                                               origin_);
     base::RecordAction(base::UserMetricsAction("CredentialManager_Autosignin"));
     LogCredentialManagerGetResult(
         metrics_util::CREDENTIAL_MANAGER_GET_AUTOSIGNIN, mediation_);
     delegate_->SendCredential(send_callback_, info);
     return;
   }
@@ skipping 45 matching lines @@
           base::Bind(
               &CredentialManagerPendingRequestTaskDelegate::SendPasswordForm,
               base::Unretained(delegate_), send_callback_, mediation_))) {
     LogCredentialManagerGetResult(metrics_util::CREDENTIAL_MANAGER_GET_NONE,
                                   mediation_);
     delegate_->SendCredential(send_callback_, CredentialInfo());
   }
 }
 
 }  // namespace password_manager