Switch to standard integer types in components/, part 3 of 4.

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 <stdint.h>
+
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/macros.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/password_manager/content/common/credential_manager_messages.h"
 #include "components/password_manager/core/browser/credential_manager_password_form_manager.h"
 #include "components/password_manager/core/browser/mock_affiliated_match_helper.h"
 #include "components/password_manager/core/browser/password_manager.h"
@@ skipping 215 matching lines @@
   }
 
   void ExpectZeroClickSignInFailure() {
     EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
         .Times(testing::Exactly(0));
     EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_))
         .Times(testing::Exactly(0));
 
     RunAllPendingTasks();
 
-    const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
+    const uint32_t kMsgID = CredentialManagerMsg_SendCredential::ID;
     const IPC::Message* message =
         process()->sink().GetFirstMessageMatching(kMsgID);
     ASSERT_TRUE(message);
     CredentialManagerMsg_SendCredential::Param send_param;
     CredentialManagerMsg_SendCredential::Read(message, &send_param);
 
     EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY,
               base::get<1>(send_param).type);
   }
 
   void ExpectZeroClickSignInSuccess() {
     EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
         .Times(testing::Exactly(0));
     EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_))
         .Times(testing::Exactly(1));
 
     RunAllPendingTasks();
 
-    const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
+    const uint32_t kMsgID = CredentialManagerMsg_SendCredential::ID;
     const IPC::Message* message =
         process()->sink().GetFirstMessageMatching(kMsgID);
     ASSERT_TRUE(message);
     CredentialManagerMsg_SendCredential::Param send_param;
     CredentialManagerMsg_SendCredential::Read(message, &send_param);
 
     EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_PASSWORD,
               base::get<1>(send_param).type);
   }
 
@@ skipping 12 matching lines @@
 };
 
 TEST_F(CredentialManagerDispatcherTest, CredentialManagerOnStore) {
   CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_PASSWORD);
   EXPECT_CALL(*client_, PromptUserToSavePasswordPtr(
                             _, CredentialSourceType::CREDENTIAL_SOURCE_API))
       .Times(testing::Exactly(1));
 
   dispatcher()->OnStore(kRequestId, info);
 
-  const uint32 kMsgID = CredentialManagerMsg_AcknowledgeStore::ID;
+  const uint32_t kMsgID = CredentialManagerMsg_AcknowledgeStore::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
   process()->sink().ClearMessages();
 
   // Allow the PasswordFormManager to talk to the password store, determine
   // that the form is new, and set it as pending.
   RunAllPendingTasks();
 
   EXPECT_TRUE(client_->pending_manager()->HasCompletedMatching());
@@ skipping 16 matching lines @@
   // Calling 'OnStore' with a credential that matches |form_| should update
   // the password without prompting the user.
   CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_PASSWORD);
   info.password = base::ASCIIToUTF16("Totally new password.");
   dispatcher()->OnStore(kRequestId, info);
 
   EXPECT_CALL(*client_, PromptUserToSavePasswordPtr(
                             _, CredentialSourceType::CREDENTIAL_SOURCE_API))
       .Times(testing::Exactly(0));
 
-  const uint32 kMsgID = CredentialManagerMsg_AcknowledgeStore::ID;
+  const uint32_t kMsgID = CredentialManagerMsg_AcknowledgeStore::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
   process()->sink().ClearMessages();
 
   // Allow the PasswordFormManager to talk to the password store, determine
   // the form is a match for an existing form, and update the PasswordStore.
   RunAllPendingTasks();
 
   TestPasswordStore::PasswordMap passwords = store_->stored_passwords();
@@ skipping 32 matching lines @@
        CredentialManagerSignInWithSavingDisabledForCurrentPage) {
   CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_PASSWORD);
   EXPECT_CALL(*client_, IsSavingAndFillingEnabledForCurrentPage())
       .WillRepeatedly(testing::Return(false));
   EXPECT_CALL(*client_, PromptUserToSavePasswordPtr(
                             _, CredentialSourceType::CREDENTIAL_SOURCE_API))
       .Times(testing::Exactly(0));
 
   dispatcher()->OnStore(kRequestId, info);
 
-  const uint32 kMsgID = CredentialManagerMsg_AcknowledgeStore::ID;
+  const uint32_t kMsgID = CredentialManagerMsg_AcknowledgeStore::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
   process()->sink().ClearMessages();
 
   RunAllPendingTasks();
 
   EXPECT_FALSE(client_->pending_manager());
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequireUserMediation) {
   store_->AddLogin(form_);
   store_->AddLogin(cross_origin_form_);
   RunAllPendingTasks();
 
   TestPasswordStore::PasswordMap passwords = store_->stored_passwords();
   EXPECT_EQ(2U, passwords.size());
   EXPECT_EQ(1U, passwords[form_.signon_realm].size());
   EXPECT_EQ(1U, passwords[cross_origin_form_.signon_realm].size());
   EXPECT_FALSE(passwords[form_.signon_realm][0].skip_zero_click);
   EXPECT_FALSE(passwords[cross_origin_form_.signon_realm][0].skip_zero_click);
 
   dispatcher()->OnRequireUserMediation(kRequestId);
   RunAllPendingTasks();
 
-  const uint32 kMsgID =
+  const uint32_t kMsgID =
       CredentialManagerMsg_AcknowledgeRequireUserMediation::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
   process()->sink().ClearMessages();
 
   passwords = store_->stored_passwords();
   EXPECT_EQ(2U, passwords.size());
   EXPECT_EQ(1U, passwords[form_.signon_realm].size());
   EXPECT_EQ(1U, passwords[cross_origin_form_.signon_realm].size());
@@ skipping 44 matching lines @@
                             _, CredentialSourceType::CREDENTIAL_SOURCE_API))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
 
   dispatcher()->OnRequestCredential(kRequestId, false, federations);
 
   RunAllPendingTasks();
 
-  const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
+  const uint32_t kMsgID = CredentialManagerMsg_SendCredential::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
   CredentialManagerMsg_SendCredential::Param param;
   CredentialManagerMsg_SendCredential::Read(message, &param);
   EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, base::get<1>(param).type);
   process()->sink().ClearMessages();
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialWithCrossOriginPasswordStore) {
   store_->AddLogin(cross_origin_form_);
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToSavePasswordPtr(
                             _, CredentialSourceType::CREDENTIAL_SOURCE_API))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
 
   dispatcher()->OnRequestCredential(kRequestId, false, federations);
 
   RunAllPendingTasks();
 
-  const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
+  const uint32_t kMsgID = CredentialManagerMsg_SendCredential::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
   CredentialManagerMsg_SendCredential::Param param;
   CredentialManagerMsg_SendCredential::Read(message, &param);
   EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, base::get<1>(param).type);
   process()->sink().ClearMessages();
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialWithFullPasswordStore) {
   client_->set_zero_click_enabled(false);
   store_->AddLogin(form_);
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
       .Times(testing::Exactly(1));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
 
   dispatcher()->OnRequestCredential(kRequestId, false, federations);
 
   RunAllPendingTasks();
 
-  const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
+  const uint32_t kMsgID = CredentialManagerMsg_SendCredential::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
 }
 
 TEST_F(
     CredentialManagerDispatcherTest,
     CredentialManagerOnRequestCredentialWithZeroClickOnlyEmptyPasswordStore) {
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
 
   dispatcher()->OnRequestCredential(kRequestId, true, federations);
 
   RunAllPendingTasks();
 
-  const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
+  const uint32_t 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_EMPTY,
             base::get<1>(send_param).type);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
@@ skipping 26 matching lines @@
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
 
   dispatcher()->OnRequestCredential(kRequestId, true, federations);
 
   RunAllPendingTasks();
 
-  const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
+  const uint32_t 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);
 
   // With two items in the password store, we shouldn't get credentials back.
   EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY,
             base::get<1>(send_param).type);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        OnRequestCredentialWithZeroClickOnlyAndSkipZeroClickPasswordStore) {
   form_.skip_zero_click = true;
   store_->AddLogin(form_);
   store_->AddLogin(origin_path_form_);
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
 
   dispatcher()->OnRequestCredential(kRequestId, true, federations);
 
   RunAllPendingTasks();
 
-  const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
+  const uint32_t 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);
 
   // With two items in the password store, we shouldn't get credentials back,
   // even though only one item has |skip_zero_click| set |false|.
   EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY,
             base::get<1>(send_param).type);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        OnRequestCredentialWithZeroClickOnlyCrossOriginPasswordStore) {
   store_->AddLogin(cross_origin_form_);
 
   form_.skip_zero_click = true;
   store_->AddLogin(form_);
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
 
   dispatcher()->OnRequestCredential(kRequestId, true, federations);
 
   RunAllPendingTasks();
 
-  const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
+  const uint32_t 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 only have cross-origin zero-click credentials; they should not be
   // returned.
   EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY,
             base::get<1>(send_param).type);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialWhileRequestPending) {
   client_->set_zero_click_enabled(false);
   store_->AddLogin(form_);
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
 
   dispatcher()->OnRequestCredential(kRequestId, false, federations);
   dispatcher()->OnRequestCredential(kRequestId, false, federations);
 
   // Check that the second request triggered a rejection.
-  uint32 kMsgID = CredentialManagerMsg_RejectCredentialRequest::ID;
+  uint32_t kMsgID = CredentialManagerMsg_RejectCredentialRequest::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
 
   CredentialManagerMsg_RejectCredentialRequest::Param reject_param;
   CredentialManagerMsg_RejectCredentialRequest::Read(message, &reject_param);
   EXPECT_EQ(blink::WebCredentialManagerPendingRequestError,
             base::get<1>(reject_param));
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
       .Times(testing::Exactly(1));
@@ skipping 65 matching lines @@
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
       .Times(testing::Exactly(0));
   EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
 
   dispatcher()->OnRequestCredential(kRequestId, true, federations);
 
   RunAllPendingTasks();
 
-  const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
+  const uint32_t 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);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        ZeroClickWithAffiliatedFormInPasswordStore) {
@@ skipping 82 matching lines @@
 TEST_F(CredentialManagerDispatcherTest, GetSynthesizedFormForOrigin) {
   autofill::PasswordForm synthesized =
       dispatcher_->GetSynthesizedFormForOrigin();
   EXPECT_EQ(kTestWebOrigin, synthesized.origin.spec());
   EXPECT_EQ(kTestWebOrigin, synthesized.signon_realm);
   EXPECT_EQ(autofill::PasswordForm::SCHEME_HTML, synthesized.scheme);
   EXPECT_TRUE(synthesized.ssl_valid);
 }
 
 }  // namespace password_manager