Credential Management: Rename 'LocalCredential' to 'PasswordCredential' (2/3)

components/password_manager/content/browser/credential_manager_dispatcher_unittest.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_dispatcher.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/testing_pref_service.h"
@@ skipping 65 matching lines @@
   bool PromptUserToChooseCredentials(
       ScopedVector<autofill::PasswordForm> local_forms,
       ScopedVector<autofill::PasswordForm> federated_forms,
       const GURL& origin,
       base::Callback<void(const password_manager::CredentialInfo&)> callback) {
     EXPECT_FALSE(local_forms.empty() && federated_forms.empty());
     password_manager::CredentialInfo info(
         local_forms.empty() ? *federated_forms[0] : *local_forms[0],
         local_forms.empty()
             ? password_manager::CredentialType::CREDENTIAL_TYPE_FEDERATED
-            : password_manager::CredentialType::CREDENTIAL_TYPE_LOCAL);
+            : password_manager::CredentialType::CREDENTIAL_TYPE_PASSWORD);
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback, info));
     PromptUserToChooseCredentialsPtr(local_forms.get(), federated_forms.get(),
                                      origin, callback);
     return true;
   }
 
   void NotifyUserAutoSignin(
       ScopedVector<autofill::PasswordForm> local_forms) override {
     EXPECT_FALSE(local_forms.empty());
@@ skipping 112 matching lines @@
   autofill::PasswordForm origin_path_form_;
   autofill::PasswordForm cross_origin_form_;
   scoped_refptr<TestPasswordStore> store_;
   scoped_ptr<MockPasswordManagerClient> client_;
   StubPasswordManagerDriver stub_driver_;
   scoped_ptr<CredentialManagerDispatcher> dispatcher_;
 };
 
 TEST_F(CredentialManagerDispatcherTest, CredentialManagerOnNotifyFailedSignIn) {
   CredentialInfo info;
-  info.type = CredentialType::CREDENTIAL_TYPE_LOCAL;
+  info.type = CredentialType::CREDENTIAL_TYPE_PASSWORD;
   dispatcher()->OnNotifyFailedSignIn(kRequestId, info);
 
   const uint32 kMsgID = CredentialManagerMsg_AcknowledgeFailedSignIn::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
   process()->sink().ClearMessages();
 }
 
 TEST_F(CredentialManagerDispatcherTest, CredentialManagerOnNotifySignedIn) {
-  CredentialInfo info(form_,
-                      password_manager::CredentialType::CREDENTIAL_TYPE_LOCAL);
+  CredentialInfo info(
+      form_, password_manager::CredentialType::CREDENTIAL_TYPE_PASSWORD);
   EXPECT_CALL(
       *client_,
       PromptUserToSavePasswordPtr(
           _, password_manager::CredentialSourceType::CREDENTIAL_SOURCE_API))
       .Times(testing::Exactly(1));
 
   dispatcher()->OnNotifySignedIn(kRequestId, info);
 
   const uint32 kMsgID = CredentialManagerMsg_AcknowledgeSignedIn::ID;
   const IPC::Message* message =
@@ skipping 12 matching lines @@
   EXPECT_EQ(form_.username_value, new_form.username_value);
   EXPECT_EQ(form_.display_name, new_form.display_name);
   EXPECT_EQ(form_.password_value, new_form.password_value);
   EXPECT_EQ(form_.origin, new_form.origin);
   EXPECT_EQ(form_.signon_realm, new_form.signon_realm);
   EXPECT_EQ(autofill::PasswordForm::SCHEME_HTML, new_form.scheme);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerSignInWithSavingDisabledForCurrentPage) {
-  CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_LOCAL);
+  CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_PASSWORD);
   EXPECT_CALL(*client_, IsSavingEnabledForCurrentPage())
       .WillRepeatedly(testing::Return(false));
   EXPECT_CALL(
       *client_,
       PromptUserToSavePasswordPtr(
           _, password_manager::CredentialSourceType::CREDENTIAL_SOURCE_API))
       .Times(testing::Exactly(0));
 
   dispatcher()->OnNotifySignedIn(kRequestId, info);
 
@@ skipping 145 matching lines @@
   dispatcher()->OnRequestCredential(kRequestId, true, federations);
 
   RunAllPendingTasks();
 
   const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
   CredentialManagerMsg_SendCredential::Param send_param;
   CredentialManagerMsg_SendCredential::Read(message, &send_param);
-  EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_LOCAL,
+  EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_PASSWORD,
             base::get<1>(send_param).type);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialWithZeroClickOnlyTwoPasswordStore) {
   store_->AddLogin(form_);
   store_->AddLogin(origin_path_form_);
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
@@ skipping 33 matching lines @@
 
   const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
   CredentialManagerMsg_SendCredential::Param send_param;
   CredentialManagerMsg_SendCredential::Read(message, &send_param);
 
   // We should get |origin_path_form_| back, as |form_| is marked as skipping
   // zero-click.
-  EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_LOCAL,
+  EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_PASSWORD,
             base::get<1>(send_param).type);
   EXPECT_EQ(origin_path_form_.username_value, base::get<1>(send_param).id);
   EXPECT_EQ(origin_path_form_.display_name, base::get<1>(send_param).name);
   EXPECT_EQ(origin_path_form_.password_value,
             base::get<1>(send_param).password);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        OnRequestCredentialWithZeroClickOnlyCrossOriginPasswordStore) {
   store_->AddLogin(cross_origin_form_);
@@ skipping 126 matching lines @@
   const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   ASSERT_TRUE(message);
   CredentialManagerMsg_SendCredential::Param param;
   CredentialManagerMsg_SendCredential::Read(message, &param);
   EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, base::get<1>(param).type);
 }
 
 }  // namespace password_manager