OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2017 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "components/payments/core/subkey_requester.h" | |
6 | |
7 #include <memory> | |
8 #include <utility> | |
9 | |
10 #include "base/bind.h" | |
11 #include "base/bind_helpers.h" | |
12 #include "base/cancelable_callback.h" | |
13 #include "base/memory/ptr_util.h" | |
14 #include "base/strings/utf_string_conversions.h" | |
15 #include "base/threading/sequenced_task_runner_handle.h" | |
16 #include "base/time/time.h" | |
17 #include "third_party/libaddressinput/chromium/chrome_address_validator.h" | |
18 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_da ta.h" | |
19 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/source.h" | |
20 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/storage.h" | |
21 namespace payments { | |
22 | |
23 namespace { | |
24 | |
25 using ::i18n::addressinput::Source; | |
26 using ::i18n::addressinput::Storage; | |
27 | |
28 class SubKeyRequest : public SubKeyRequester::Request { | |
29 public: | |
30 // The |delegate| and |address_validator| need to outlive this Request. | |
31 SubKeyRequest(const std::string& region_code, | |
32 int timeout_seconds, | |
33 SubKeyRequester::Delegate* delegate, | |
34 autofill::AddressValidator* address_validator) | |
35 : region_code_(region_code), | |
36 delegate_(delegate), | |
37 address_validator_(address_validator), | |
38 has_responded_(false), | |
39 on_timeout_(base::Bind(&::payments::SubKeyRequest::OnRulesLoaded, | |
40 base::Unretained(this))) { | |
41 base::SequencedTaskRunnerHandle::Get()->PostDelayedTask( | |
42 FROM_HERE, on_timeout_.callback(), | |
43 base::TimeDelta::FromSeconds(timeout_seconds)); | |
44 } | |
45 | |
46 ~SubKeyRequest() override {} | |
47 | |
48 void OnRulesLoaded() override { | |
49 on_timeout_.Cancel(); | |
50 // Check if the timeout happened before the rules were loaded. | |
51 if (has_responded_) | |
52 return; | |
53 has_responded_ = true; | |
54 | |
55 delegate_->OnSubKeysReceived( | |
56 address_validator_->GetRegionSubKeys(region_code_)); | |
57 } | |
58 | |
59 private: | |
60 std::string region_code_; | |
61 // Not owned. Never null. Outlive this object. | |
62 SubKeyRequester::Delegate* delegate_; | |
63 autofill::AddressValidator* address_validator_; | |
64 | |
65 bool has_responded_; | |
66 base::CancelableCallback<void()> on_timeout_; | |
67 | |
68 DISALLOW_COPY_AND_ASSIGN(SubKeyRequest); | |
69 }; | |
70 | |
71 } // namespace | |
72 | |
73 SubKeyRequester::SubKeyRequester(std::unique_ptr<Source> source, | |
74 std::unique_ptr<Storage> storage) | |
75 : address_validator_(std::move(source), std::move(storage), this) {} | |
76 | |
77 SubKeyRequester::~SubKeyRequester() {} | |
78 | |
79 void SubKeyRequester::StartRegionSubKeysRequest(const std::string& region_code, | |
80 int timeout_seconds, | |
81 Delegate* requester) { | |
82 DCHECK(timeout_seconds >= 0); | |
83 | |
sebsg
2017/05/19 13:39:09
Can we DCHECK(requester) too? Thanks!
Parastoo
2017/05/19 15:18:44
Done.
| |
84 std::unique_ptr<SubKeyRequest> request(base::MakeUnique<SubKeyRequest>( | |
85 region_code, timeout_seconds, requester, &address_validator_)); | |
86 | |
87 if (AreRulesLoadedForRegion(region_code)) { | |
88 request->OnRulesLoaded(); | |
89 } else { | |
90 // Setup the variables so that the subkeys request is sent, when the rules | |
91 // are loaded. | |
92 pending_subkey_region_code_ = region_code; | |
93 pending_subkey_request_ = std::move(request); | |
94 | |
95 // Start loading the rules for that region. If the rules were already in the | |
96 // process of being loaded, this call will do nothing. | |
97 LoadRulesForRegion(region_code); | |
98 } | |
99 } | |
100 | |
101 bool SubKeyRequester::AreRulesLoadedForRegion(const std::string& region_code) { | |
102 return address_validator_.AreRulesLoadedForRegion(region_code); | |
103 } | |
104 | |
105 void SubKeyRequester::LoadRulesForRegion(const std::string& region_code) { | |
106 address_validator_.LoadRules(region_code); | |
107 } | |
108 | |
109 void SubKeyRequester::OnAddressValidationRulesLoaded( | |
110 const std::string& region_code, | |
111 bool success) { | |
112 // if |success| == false, AddressValidator::GetRegionSubKeys will return an | |
113 // empty list of subkeys. => No need to check for |success|. | |
114 // Check if there is any subkey request for that region code. | |
115 if (!pending_subkey_region_code_.compare(region_code)) | |
116 pending_subkey_request_->OnRulesLoaded(); | |
117 pending_subkey_region_code_.clear(); | |
118 pending_subkey_request_.reset(); | |
119 } | |
120 | |
121 void SubKeyRequester::CancelPendingGetSubKeys() { | |
122 pending_subkey_region_code_.clear(); | |
123 pending_subkey_request_.reset(); | |
124 } | |
125 | |
126 } // namespace payments | |
OLD | NEW |