OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/autofill/android/personal_data_manager_android.h" | 5 #include "chrome/browser/autofill/android/personal_data_manager_android.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <algorithm> | 8 #include <algorithm> |
9 #include <memory> | 9 #include <memory> |
10 #include <utility> | 10 #include <utility> |
(...skipping 248 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
259 Java_FullCardRequestDelegate_onFullCardError(env, jdelegate_); | 259 Java_FullCardRequestDelegate_onFullCardError(env, jdelegate_); |
260 delete this; | 260 delete this; |
261 } | 261 } |
262 | 262 |
263 std::unique_ptr<CreditCard> card_; | 263 std::unique_ptr<CreditCard> card_; |
264 ScopedJavaGlobalRef<jobject> jdelegate_; | 264 ScopedJavaGlobalRef<jobject> jdelegate_; |
265 | 265 |
266 DISALLOW_COPY_AND_ASSIGN(FullCardRequester); | 266 DISALLOW_COPY_AND_ASSIGN(FullCardRequester); |
267 }; | 267 }; |
268 | 268 |
269 // Self-deleting requester of address normalization. | |
270 class AddressNormalizationRequester | 269 class AddressNormalizationRequester |
271 : public PersonalDataManagerAndroid::Delegate, | 270 : public PersonalDataManagerAndroid::Delegate, |
272 public base::SupportsWeakPtr<AddressNormalizationRequester> { | 271 public base::SupportsWeakPtr<AddressNormalizationRequester> { |
273 public: | 272 public: |
274 AddressNormalizationRequester( | 273 AddressNormalizationRequester( |
275 JNIEnv* env, | 274 JNIEnv* env, |
276 const base::android::JavaParamRef<jobject>& jdelegate, | 275 const base::android::JavaParamRef<jobject>& jdelegate, |
277 const std::string& region_code, | 276 const std::string& region_code, |
278 const std::string& guid, | 277 const std::string& guid, |
279 base::WeakPtr<PersonalDataManagerAndroid> personal_data_manager_android) { | 278 base::WeakPtr<PersonalDataManagerAndroid> personal_data_manager_android) { |
280 jdelegate_.Reset(env, jdelegate); | 279 jdelegate_.Reset(env, jdelegate); |
281 region_code_ = region_code; | 280 region_code_ = region_code; |
282 guid_ = guid; | 281 guid_ = guid; |
283 personal_data_manager_android_ = personal_data_manager_android; | 282 personal_data_manager_android_ = personal_data_manager_android; |
284 env_ = env; | 283 env_ = env; |
285 } | 284 } |
286 | 285 |
287 private: | 286 private: |
288 virtual ~AddressNormalizationRequester() {} | 287 ~AddressNormalizationRequester() override {} |
289 | 288 |
290 void OnRulesSuccessfullyLoaded() override { | 289 void OnRulesSuccessfullyLoaded() override { |
291 if (personal_data_manager_android_) { | 290 if (personal_data_manager_android_) { |
292 JNIEnv* env = base::android::AttachCurrentThread(); | 291 JNIEnv* env = base::android::AttachCurrentThread(); |
293 Java_NormalizedAddressRequestDelegate_onAddressNormalized( | 292 Java_NormalizedAddressRequestDelegate_onAddressNormalized( |
294 env, jdelegate_, personal_data_manager_android_->NormalizeAddress( | 293 env, jdelegate_, personal_data_manager_android_->NormalizeAddress( |
295 guid_, region_code_, env)); | 294 guid_, region_code_, env)); |
296 } | 295 } |
297 | |
298 delete this; | |
299 } | 296 } |
300 | 297 |
301 ScopedJavaGlobalRef<jobject> jdelegate_; | 298 ScopedJavaGlobalRef<jobject> jdelegate_; |
302 std::string guid_; | 299 std::string guid_; |
303 std::string region_code_; | 300 std::string region_code_; |
304 base::WeakPtr<PersonalDataManagerAndroid> personal_data_manager_android_; | 301 base::WeakPtr<PersonalDataManagerAndroid> personal_data_manager_android_; |
305 JNIEnv* env_; | 302 JNIEnv* env_; |
306 | 303 |
307 DISALLOW_COPY_AND_ASSIGN(AddressNormalizationRequester); | 304 DISALLOW_COPY_AND_ASSIGN(AddressNormalizationRequester); |
308 }; | 305 }; |
(...skipping 264 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
573 const JavaParamRef<jobject>& unused_obj, | 570 const JavaParamRef<jobject>& unused_obj, |
574 const JavaParamRef<jstring>& jguid, | 571 const JavaParamRef<jstring>& jguid, |
575 jint count, | 572 jint count, |
576 jint date) { | 573 jint date) { |
577 DCHECK(count >= 0 && date >= 0); | 574 DCHECK(count >= 0 && date >= 0); |
578 | 575 |
579 AutofillProfile* profile = personal_data_manager_->GetProfileByGUID( | 576 AutofillProfile* profile = personal_data_manager_->GetProfileByGUID( |
580 ConvertJavaStringToUTF8(env, jguid)); | 577 ConvertJavaStringToUTF8(env, jguid)); |
581 profile->set_use_count(static_cast<size_t>(count)); | 578 profile->set_use_count(static_cast<size_t>(count)); |
582 profile->set_use_date(base::Time::FromTimeT(date)); | 579 profile->set_use_date(base::Time::FromTimeT(date)); |
| 580 |
583 personal_data_manager_->NotifyPersonalDataChangedForTest(); | 581 personal_data_manager_->NotifyPersonalDataChangedForTest(); |
584 } | 582 } |
585 | 583 |
586 jint PersonalDataManagerAndroid::GetProfileUseCountForTesting( | 584 jint PersonalDataManagerAndroid::GetProfileUseCountForTesting( |
587 JNIEnv* env, | 585 JNIEnv* env, |
588 const base::android::JavaParamRef<jobject>& unused_obj, | 586 const base::android::JavaParamRef<jobject>& unused_obj, |
589 const base::android::JavaParamRef<jstring>& jguid) { | 587 const base::android::JavaParamRef<jstring>& jguid) { |
590 AutofillProfile* profile = personal_data_manager_->GetProfileByGUID( | 588 AutofillProfile* profile = personal_data_manager_->GetProfileByGUID( |
591 ConvertJavaStringToUTF8(env, jguid)); | 589 ConvertJavaStringToUTF8(env, jguid)); |
592 return profile->use_count(); | 590 return profile->use_count(); |
(...skipping 23 matching lines...) Expand all Loading... |
616 const JavaParamRef<jobject>& unused_obj, | 614 const JavaParamRef<jobject>& unused_obj, |
617 const JavaParamRef<jstring>& jguid, | 615 const JavaParamRef<jstring>& jguid, |
618 jint count, | 616 jint count, |
619 jint date) { | 617 jint date) { |
620 DCHECK(count >= 0 && date >= 0); | 618 DCHECK(count >= 0 && date >= 0); |
621 | 619 |
622 CreditCard* card = personal_data_manager_->GetCreditCardByGUID( | 620 CreditCard* card = personal_data_manager_->GetCreditCardByGUID( |
623 ConvertJavaStringToUTF8(env, jguid)); | 621 ConvertJavaStringToUTF8(env, jguid)); |
624 card->set_use_count(static_cast<size_t>(count)); | 622 card->set_use_count(static_cast<size_t>(count)); |
625 card->set_use_date(base::Time::FromTimeT(date)); | 623 card->set_use_date(base::Time::FromTimeT(date)); |
| 624 |
626 personal_data_manager_->NotifyPersonalDataChangedForTest(); | 625 personal_data_manager_->NotifyPersonalDataChangedForTest(); |
627 } | 626 } |
628 | 627 |
629 jint PersonalDataManagerAndroid::GetCreditCardUseCountForTesting( | 628 jint PersonalDataManagerAndroid::GetCreditCardUseCountForTesting( |
630 JNIEnv* env, | 629 JNIEnv* env, |
631 const base::android::JavaParamRef<jobject>& unused_obj, | 630 const base::android::JavaParamRef<jobject>& unused_obj, |
632 const base::android::JavaParamRef<jstring>& jguid) { | 631 const base::android::JavaParamRef<jstring>& jguid) { |
633 CreditCard* card = personal_data_manager_->GetCreditCardByGUID( | 632 CreditCard* card = personal_data_manager_->GetCreditCardByGUID( |
634 ConvertJavaStringToUTF8(env, jguid)); | 633 ConvertJavaStringToUTF8(env, jguid)); |
635 return card->use_count(); | 634 return card->use_count(); |
(...skipping 19 matching lines...) Expand all Loading... |
655 JNIEnv* env, | 654 JNIEnv* env, |
656 const base::android::JavaParamRef<jobject>& unused_obj, | 655 const base::android::JavaParamRef<jobject>& unused_obj, |
657 const base::android::JavaParamRef<jstring>& jregion_code) { | 656 const base::android::JavaParamRef<jstring>& jregion_code) { |
658 address_validator_.LoadRules(ConvertJavaStringToUTF8(env, jregion_code)); | 657 address_validator_.LoadRules(ConvertJavaStringToUTF8(env, jregion_code)); |
659 } | 658 } |
660 | 659 |
661 void PersonalDataManagerAndroid::OnAddressValidationRulesLoaded( | 660 void PersonalDataManagerAndroid::OnAddressValidationRulesLoaded( |
662 const std::string& region_code, | 661 const std::string& region_code, |
663 bool success) { | 662 bool success) { |
664 // Check if an address normalization is pending. | 663 // Check if an address normalization is pending. |
665 std::map<std::string, Delegate*>::iterator it = | 664 auto it = pending_normalization_.find(region_code); |
666 pending_normalization_.find(region_code); | |
667 if (it != pending_normalization_.end()) { | 665 if (it != pending_normalization_.end()) { |
668 // The Delegate will self delete after normalizing. | 666 for (size_t i = 0; i < it->second.size(); ++i) |
669 it->second->OnRulesSuccessfullyLoaded(); | 667 it->second[i]->OnRulesSuccessfullyLoaded(); |
670 pending_normalization_.erase(it); | 668 pending_normalization_.erase(it); |
671 } | 669 } |
672 } | 670 } |
673 | 671 |
674 jboolean PersonalDataManagerAndroid::StartAddressNormalization( | 672 jboolean PersonalDataManagerAndroid::StartAddressNormalization( |
675 JNIEnv* env, | 673 JNIEnv* env, |
676 const JavaParamRef<jobject>& unused_obj, | 674 const JavaParamRef<jobject>& unused_obj, |
677 const JavaParamRef<jstring>& jguid, | 675 const JavaParamRef<jstring>& jguid, |
678 const JavaParamRef<jstring>& jregion_code, | 676 const JavaParamRef<jstring>& jregion_code, |
679 const JavaParamRef<jobject>& jdelegate) { | 677 const JavaParamRef<jobject>& jdelegate) { |
680 const std::string region_code = ConvertJavaStringToUTF8(env, jregion_code); | 678 const std::string region_code = ConvertJavaStringToUTF8(env, jregion_code); |
681 const std::string guid = ConvertJavaStringToUTF8(env, jguid); | 679 const std::string guid = ConvertJavaStringToUTF8(env, jguid); |
682 | 680 |
683 Delegate* requester = new AddressNormalizationRequester( | 681 std::unique_ptr<Delegate> requester(new AddressNormalizationRequester( |
684 env, jdelegate, region_code, guid, AsWeakPtr()); | 682 env, jdelegate, region_code, guid, AsWeakPtr())); |
685 | 683 |
686 // Check if the rules are already loaded. | 684 // Check if the rules are already loaded. |
687 if (AreRulesLoadedForRegion(region_code)) { | 685 if (AreRulesLoadedForRegion(region_code)) { |
688 requester->OnRulesSuccessfullyLoaded(); | 686 requester->OnRulesSuccessfullyLoaded(); |
689 return false; | 687 return false; |
690 } else { | 688 } else { |
691 // Setup the variables so the profile gets normalized when the rules have | 689 // Setup the variables so the profile gets normalized when the rules have |
692 // finished loading. | 690 // finished loading. |
693 pending_normalization_.insert( | 691 auto it = pending_normalization_.find(region_code); |
694 std::pair<std::string, Delegate*>(region_code, requester)); | 692 if (it == pending_normalization_.end()) { |
| 693 // If no entry exists yet, create the entry and assign it to |it|. |
| 694 it = pending_normalization_ |
| 695 .insert(std::make_pair(region_code, |
| 696 std::vector<std::unique_ptr<Delegate>>())) |
| 697 .first; |
| 698 } |
| 699 |
| 700 it->second.push_back(std::move(requester)); |
| 701 |
695 return true; | 702 return true; |
696 } | 703 } |
697 } | 704 } |
698 | 705 |
699 ScopedJavaLocalRef<jobject> PersonalDataManagerAndroid::NormalizeAddress( | 706 ScopedJavaLocalRef<jobject> PersonalDataManagerAndroid::NormalizeAddress( |
700 const std::string& guid, | 707 const std::string& guid, |
701 const std::string& region_code, | 708 const std::string& region_code, |
702 JNIEnv* env) { | 709 JNIEnv* env) { |
703 AutofillProfile* profile = personal_data_manager_->GetProfileByGUID(guid); | 710 AutofillProfile* profile = personal_data_manager_->GetProfileByGUID(guid); |
704 | 711 |
(...skipping 11 matching lines...) Expand all Loading... |
716 base::UTF8ToUTF16(address_data.administrative_area)); | 723 base::UTF8ToUTF16(address_data.administrative_area)); |
717 profile->SetRawInfo(ADDRESS_HOME_CITY, | 724 profile->SetRawInfo(ADDRESS_HOME_CITY, |
718 base::UTF8ToUTF16(address_data.locality)); | 725 base::UTF8ToUTF16(address_data.locality)); |
719 profile->SetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY, | 726 profile->SetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY, |
720 base::UTF8ToUTF16(address_data.dependent_locality)); | 727 base::UTF8ToUTF16(address_data.dependent_locality)); |
721 } | 728 } |
722 | 729 |
723 return CreateJavaProfileFromNative(env, *profile); | 730 return CreateJavaProfileFromNative(env, *profile); |
724 } | 731 } |
725 | 732 |
726 void PersonalDataManagerAndroid::CancelPendingAddressNormalization( | 733 void PersonalDataManagerAndroid::CancelPendingAddressNormalizations( |
727 JNIEnv* env, | 734 JNIEnv* env, |
728 const base::android::JavaParamRef<jobject>& unused_obj) { | 735 const base::android::JavaParamRef<jobject>& unused_obj) { |
729 pending_normalization_.clear(); | 736 pending_normalization_.clear(); |
730 } | 737 } |
731 | 738 |
732 ScopedJavaLocalRef<jobjectArray> PersonalDataManagerAndroid::GetProfileGUIDs( | 739 ScopedJavaLocalRef<jobjectArray> PersonalDataManagerAndroid::GetProfileGUIDs( |
733 JNIEnv* env, | 740 JNIEnv* env, |
734 const std::vector<AutofillProfile*>& profiles) { | 741 const std::vector<AutofillProfile*>& profiles) { |
735 std::vector<base::string16> guids; | 742 std::vector<base::string16> guids; |
736 for (AutofillProfile* profile : profiles) | 743 for (AutofillProfile* profile : profiles) |
(...skipping 94 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
831 base::android::ConvertJavaStringToUTF16(env, jcountry_name))); | 838 base::android::ConvertJavaStringToUTF16(env, jcountry_name))); |
832 } | 839 } |
833 | 840 |
834 static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { | 841 static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { |
835 PersonalDataManagerAndroid* personal_data_manager_android = | 842 PersonalDataManagerAndroid* personal_data_manager_android = |
836 new PersonalDataManagerAndroid(env, obj); | 843 new PersonalDataManagerAndroid(env, obj); |
837 return reinterpret_cast<intptr_t>(personal_data_manager_android); | 844 return reinterpret_cast<intptr_t>(personal_data_manager_android); |
838 } | 845 } |
839 | 846 |
840 } // namespace autofill | 847 } // namespace autofill |
OLD | NEW |