OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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 "remoting/protocol/pairing_registry.h" | 5 #include "remoting/protocol/pairing_registry.h" |
6 | 6 |
7 #include <stdlib.h> | 7 #include <stdlib.h> |
8 | 8 |
9 #include <algorithm> | 9 #include <algorithm> |
| 10 #include <memory> |
10 #include <utility> | 11 #include <utility> |
11 | 12 |
12 #include "base/bind.h" | 13 #include "base/bind.h" |
13 #include "base/compiler_specific.h" | 14 #include "base/compiler_specific.h" |
14 #include "base/macros.h" | 15 #include "base/macros.h" |
15 #include "base/memory/scoped_ptr.h" | 16 #include "base/memory/ptr_util.h" |
16 #include "base/message_loop/message_loop.h" | 17 #include "base/message_loop/message_loop.h" |
17 #include "base/run_loop.h" | 18 #include "base/run_loop.h" |
18 #include "base/thread_task_runner_handle.h" | 19 #include "base/thread_task_runner_handle.h" |
19 #include "base/values.h" | 20 #include "base/values.h" |
20 #include "remoting/protocol/protocol_mock_objects.h" | 21 #include "remoting/protocol/protocol_mock_objects.h" |
21 #include "testing/gmock/include/gmock/gmock.h" | 22 #include "testing/gmock/include/gmock/gmock.h" |
22 #include "testing/gtest/include/gtest/gtest.h" | 23 #include "testing/gtest/include/gtest/gtest.h" |
23 | 24 |
24 using testing::Sequence; | 25 using testing::Sequence; |
25 | 26 |
26 namespace { | 27 namespace { |
27 | 28 |
28 using remoting::protocol::PairingRegistry; | 29 using remoting::protocol::PairingRegistry; |
29 | 30 |
30 class MockPairingRegistryCallbacks { | 31 class MockPairingRegistryCallbacks { |
31 public: | 32 public: |
32 MockPairingRegistryCallbacks() {} | 33 MockPairingRegistryCallbacks() {} |
33 virtual ~MockPairingRegistryCallbacks() {} | 34 virtual ~MockPairingRegistryCallbacks() {} |
34 | 35 |
35 MOCK_METHOD1(DoneCallback, void(bool)); | 36 MOCK_METHOD1(DoneCallback, void(bool)); |
36 MOCK_METHOD1(GetAllPairingsCallbackPtr, void(base::ListValue*)); | 37 MOCK_METHOD1(GetAllPairingsCallbackPtr, void(base::ListValue*)); |
37 MOCK_METHOD1(GetPairingCallback, void(PairingRegistry::Pairing)); | 38 MOCK_METHOD1(GetPairingCallback, void(PairingRegistry::Pairing)); |
38 | 39 |
39 void GetAllPairingsCallback(scoped_ptr<base::ListValue> pairings) { | 40 void GetAllPairingsCallback(std::unique_ptr<base::ListValue> pairings) { |
40 GetAllPairingsCallbackPtr(pairings.get()); | 41 GetAllPairingsCallbackPtr(pairings.get()); |
41 } | 42 } |
42 | 43 |
43 private: | 44 private: |
44 DISALLOW_COPY_AND_ASSIGN(MockPairingRegistryCallbacks); | 45 DISALLOW_COPY_AND_ASSIGN(MockPairingRegistryCallbacks); |
45 }; | 46 }; |
46 | 47 |
47 // Verify that a pairing Dictionary has correct entries, but doesn't include | 48 // Verify that a pairing Dictionary has correct entries, but doesn't include |
48 // any shared secret. | 49 // any shared secret. |
49 void VerifyPairing(PairingRegistry::Pairing expected, | 50 void VerifyPairing(PairingRegistry::Pairing expected, |
50 const base::DictionaryValue& actual) { | 51 const base::DictionaryValue& actual) { |
51 std::string value; | 52 std::string value; |
52 EXPECT_TRUE(actual.GetString(PairingRegistry::kClientNameKey, &value)); | 53 EXPECT_TRUE(actual.GetString(PairingRegistry::kClientNameKey, &value)); |
53 EXPECT_EQ(expected.client_name(), value); | 54 EXPECT_EQ(expected.client_name(), value); |
54 EXPECT_TRUE(actual.GetString(PairingRegistry::kClientIdKey, &value)); | 55 EXPECT_TRUE(actual.GetString(PairingRegistry::kClientIdKey, &value)); |
55 EXPECT_EQ(expected.client_id(), value); | 56 EXPECT_EQ(expected.client_id(), value); |
56 | 57 |
57 EXPECT_FALSE(actual.HasKey(PairingRegistry::kSharedSecretKey)); | 58 EXPECT_FALSE(actual.HasKey(PairingRegistry::kSharedSecretKey)); |
58 } | 59 } |
59 | 60 |
60 } // namespace | 61 } // namespace |
61 | 62 |
62 namespace remoting { | 63 namespace remoting { |
63 namespace protocol { | 64 namespace protocol { |
64 | 65 |
65 class PairingRegistryTest : public testing::Test { | 66 class PairingRegistryTest : public testing::Test { |
66 public: | 67 public: |
67 void SetUp() override { callback_count_ = 0; } | 68 void SetUp() override { callback_count_ = 0; } |
68 | 69 |
69 void set_pairings(scoped_ptr<base::ListValue> pairings) { | 70 void set_pairings(std::unique_ptr<base::ListValue> pairings) { |
70 pairings_ = std::move(pairings); | 71 pairings_ = std::move(pairings); |
71 } | 72 } |
72 | 73 |
73 void ExpectSecret(const std::string& expected, | 74 void ExpectSecret(const std::string& expected, |
74 PairingRegistry::Pairing actual) { | 75 PairingRegistry::Pairing actual) { |
75 EXPECT_EQ(expected, actual.shared_secret()); | 76 EXPECT_EQ(expected, actual.shared_secret()); |
76 ++callback_count_; | 77 ++callback_count_; |
77 } | 78 } |
78 | 79 |
79 void ExpectSaveSuccess(bool success) { | 80 void ExpectSaveSuccess(bool success) { |
80 EXPECT_TRUE(success); | 81 EXPECT_TRUE(success); |
81 ++callback_count_; | 82 ++callback_count_; |
82 } | 83 } |
83 | 84 |
84 protected: | 85 protected: |
85 base::MessageLoop message_loop_; | 86 base::MessageLoop message_loop_; |
86 base::RunLoop run_loop_; | 87 base::RunLoop run_loop_; |
87 | 88 |
88 int callback_count_; | 89 int callback_count_; |
89 scoped_ptr<base::ListValue> pairings_; | 90 std::unique_ptr<base::ListValue> pairings_; |
90 }; | 91 }; |
91 | 92 |
92 TEST_F(PairingRegistryTest, CreateAndGetPairings) { | 93 TEST_F(PairingRegistryTest, CreateAndGetPairings) { |
93 scoped_refptr<PairingRegistry> registry = new SynchronousPairingRegistry( | 94 scoped_refptr<PairingRegistry> registry = new SynchronousPairingRegistry( |
94 make_scoped_ptr(new MockPairingRegistryDelegate())); | 95 base::WrapUnique(new MockPairingRegistryDelegate())); |
95 PairingRegistry::Pairing pairing_1 = registry->CreatePairing("my_client"); | 96 PairingRegistry::Pairing pairing_1 = registry->CreatePairing("my_client"); |
96 PairingRegistry::Pairing pairing_2 = registry->CreatePairing("my_client"); | 97 PairingRegistry::Pairing pairing_2 = registry->CreatePairing("my_client"); |
97 | 98 |
98 EXPECT_NE(pairing_1.shared_secret(), pairing_2.shared_secret()); | 99 EXPECT_NE(pairing_1.shared_secret(), pairing_2.shared_secret()); |
99 | 100 |
100 registry->GetPairing(pairing_1.client_id(), | 101 registry->GetPairing(pairing_1.client_id(), |
101 base::Bind(&PairingRegistryTest::ExpectSecret, | 102 base::Bind(&PairingRegistryTest::ExpectSecret, |
102 base::Unretained(this), | 103 base::Unretained(this), |
103 pairing_1.shared_secret())); | 104 pairing_1.shared_secret())); |
104 EXPECT_EQ(1, callback_count_); | 105 EXPECT_EQ(1, callback_count_); |
105 | 106 |
106 // Check that the second client is paired with a different shared secret. | 107 // Check that the second client is paired with a different shared secret. |
107 registry->GetPairing(pairing_2.client_id(), | 108 registry->GetPairing(pairing_2.client_id(), |
108 base::Bind(&PairingRegistryTest::ExpectSecret, | 109 base::Bind(&PairingRegistryTest::ExpectSecret, |
109 base::Unretained(this), | 110 base::Unretained(this), |
110 pairing_2.shared_secret())); | 111 pairing_2.shared_secret())); |
111 EXPECT_EQ(2, callback_count_); | 112 EXPECT_EQ(2, callback_count_); |
112 } | 113 } |
113 | 114 |
114 TEST_F(PairingRegistryTest, GetAllPairings) { | 115 TEST_F(PairingRegistryTest, GetAllPairings) { |
115 scoped_refptr<PairingRegistry> registry = new SynchronousPairingRegistry( | 116 scoped_refptr<PairingRegistry> registry = new SynchronousPairingRegistry( |
116 make_scoped_ptr(new MockPairingRegistryDelegate())); | 117 base::WrapUnique(new MockPairingRegistryDelegate())); |
117 PairingRegistry::Pairing pairing_1 = registry->CreatePairing("client1"); | 118 PairingRegistry::Pairing pairing_1 = registry->CreatePairing("client1"); |
118 PairingRegistry::Pairing pairing_2 = registry->CreatePairing("client2"); | 119 PairingRegistry::Pairing pairing_2 = registry->CreatePairing("client2"); |
119 | 120 |
120 registry->GetAllPairings( | 121 registry->GetAllPairings( |
121 base::Bind(&PairingRegistryTest::set_pairings, | 122 base::Bind(&PairingRegistryTest::set_pairings, |
122 base::Unretained(this))); | 123 base::Unretained(this))); |
123 | 124 |
124 ASSERT_EQ(2u, pairings_->GetSize()); | 125 ASSERT_EQ(2u, pairings_->GetSize()); |
125 const base::DictionaryValue* actual_pairing_1; | 126 const base::DictionaryValue* actual_pairing_1; |
126 const base::DictionaryValue* actual_pairing_2; | 127 const base::DictionaryValue* actual_pairing_2; |
127 ASSERT_TRUE(pairings_->GetDictionary(0, &actual_pairing_1)); | 128 ASSERT_TRUE(pairings_->GetDictionary(0, &actual_pairing_1)); |
128 ASSERT_TRUE(pairings_->GetDictionary(1, &actual_pairing_2)); | 129 ASSERT_TRUE(pairings_->GetDictionary(1, &actual_pairing_2)); |
129 | 130 |
130 // Ordering is not guaranteed, so swap if necessary. | 131 // Ordering is not guaranteed, so swap if necessary. |
131 std::string actual_client_id; | 132 std::string actual_client_id; |
132 ASSERT_TRUE(actual_pairing_1->GetString(PairingRegistry::kClientIdKey, | 133 ASSERT_TRUE(actual_pairing_1->GetString(PairingRegistry::kClientIdKey, |
133 &actual_client_id)); | 134 &actual_client_id)); |
134 if (actual_client_id != pairing_1.client_id()) { | 135 if (actual_client_id != pairing_1.client_id()) { |
135 std::swap(actual_pairing_1, actual_pairing_2); | 136 std::swap(actual_pairing_1, actual_pairing_2); |
136 } | 137 } |
137 | 138 |
138 VerifyPairing(pairing_1, *actual_pairing_1); | 139 VerifyPairing(pairing_1, *actual_pairing_1); |
139 VerifyPairing(pairing_2, *actual_pairing_2); | 140 VerifyPairing(pairing_2, *actual_pairing_2); |
140 } | 141 } |
141 | 142 |
142 TEST_F(PairingRegistryTest, DeletePairing) { | 143 TEST_F(PairingRegistryTest, DeletePairing) { |
143 scoped_refptr<PairingRegistry> registry = new SynchronousPairingRegistry( | 144 scoped_refptr<PairingRegistry> registry = new SynchronousPairingRegistry( |
144 make_scoped_ptr(new MockPairingRegistryDelegate())); | 145 base::WrapUnique(new MockPairingRegistryDelegate())); |
145 PairingRegistry::Pairing pairing_1 = registry->CreatePairing("client1"); | 146 PairingRegistry::Pairing pairing_1 = registry->CreatePairing("client1"); |
146 PairingRegistry::Pairing pairing_2 = registry->CreatePairing("client2"); | 147 PairingRegistry::Pairing pairing_2 = registry->CreatePairing("client2"); |
147 | 148 |
148 registry->DeletePairing( | 149 registry->DeletePairing( |
149 pairing_1.client_id(), | 150 pairing_1.client_id(), |
150 base::Bind(&PairingRegistryTest::ExpectSaveSuccess, | 151 base::Bind(&PairingRegistryTest::ExpectSaveSuccess, |
151 base::Unretained(this))); | 152 base::Unretained(this))); |
152 | 153 |
153 // Re-read the list, and verify it only has the pairing_2 client. | 154 // Re-read the list, and verify it only has the pairing_2 client. |
154 registry->GetAllPairings( | 155 registry->GetAllPairings( |
155 base::Bind(&PairingRegistryTest::set_pairings, | 156 base::Bind(&PairingRegistryTest::set_pairings, |
156 base::Unretained(this))); | 157 base::Unretained(this))); |
157 | 158 |
158 ASSERT_EQ(1u, pairings_->GetSize()); | 159 ASSERT_EQ(1u, pairings_->GetSize()); |
159 const base::DictionaryValue* actual_pairing_2; | 160 const base::DictionaryValue* actual_pairing_2; |
160 ASSERT_TRUE(pairings_->GetDictionary(0, &actual_pairing_2)); | 161 ASSERT_TRUE(pairings_->GetDictionary(0, &actual_pairing_2)); |
161 std::string actual_client_id; | 162 std::string actual_client_id; |
162 ASSERT_TRUE(actual_pairing_2->GetString(PairingRegistry::kClientIdKey, | 163 ASSERT_TRUE(actual_pairing_2->GetString(PairingRegistry::kClientIdKey, |
163 &actual_client_id)); | 164 &actual_client_id)); |
164 EXPECT_EQ(pairing_2.client_id(), actual_client_id); | 165 EXPECT_EQ(pairing_2.client_id(), actual_client_id); |
165 } | 166 } |
166 | 167 |
167 TEST_F(PairingRegistryTest, ClearAllPairings) { | 168 TEST_F(PairingRegistryTest, ClearAllPairings) { |
168 scoped_refptr<PairingRegistry> registry = new SynchronousPairingRegistry( | 169 scoped_refptr<PairingRegistry> registry = new SynchronousPairingRegistry( |
169 make_scoped_ptr(new MockPairingRegistryDelegate())); | 170 base::WrapUnique(new MockPairingRegistryDelegate())); |
170 PairingRegistry::Pairing pairing_1 = registry->CreatePairing("client1"); | 171 PairingRegistry::Pairing pairing_1 = registry->CreatePairing("client1"); |
171 PairingRegistry::Pairing pairing_2 = registry->CreatePairing("client2"); | 172 PairingRegistry::Pairing pairing_2 = registry->CreatePairing("client2"); |
172 | 173 |
173 registry->ClearAllPairings( | 174 registry->ClearAllPairings( |
174 base::Bind(&PairingRegistryTest::ExpectSaveSuccess, | 175 base::Bind(&PairingRegistryTest::ExpectSaveSuccess, |
175 base::Unretained(this))); | 176 base::Unretained(this))); |
176 | 177 |
177 // Re-read the list, and verify it is empty. | 178 // Re-read the list, and verify it is empty. |
178 registry->GetAllPairings( | 179 registry->GetAllPairings( |
179 base::Bind(&PairingRegistryTest::set_pairings, | 180 base::Bind(&PairingRegistryTest::set_pairings, |
(...skipping 28 matching lines...) Expand all Loading... |
208 EXPECT_CALL(callbacks, GetPairingCallback(EqualsClientName(""))) | 209 EXPECT_CALL(callbacks, GetPairingCallback(EqualsClientName(""))) |
209 .InSequence(s); | 210 .InSequence(s); |
210 EXPECT_CALL(callbacks, DoneCallback(true)) | 211 EXPECT_CALL(callbacks, DoneCallback(true)) |
211 .InSequence(s); | 212 .InSequence(s); |
212 EXPECT_CALL(callbacks, GetAllPairingsCallbackPtr(NoPairings())) | 213 EXPECT_CALL(callbacks, GetAllPairingsCallbackPtr(NoPairings())) |
213 .InSequence(s); | 214 .InSequence(s); |
214 EXPECT_CALL(callbacks, GetPairingCallback(EqualsClientName("client3"))) | 215 EXPECT_CALL(callbacks, GetPairingCallback(EqualsClientName("client3"))) |
215 .InSequence(s) | 216 .InSequence(s) |
216 .WillOnce(QuitMessageLoop(run_loop_.QuitClosure())); | 217 .WillOnce(QuitMessageLoop(run_loop_.QuitClosure())); |
217 | 218 |
218 scoped_refptr<PairingRegistry> registry = new PairingRegistry( | 219 scoped_refptr<PairingRegistry> registry = |
219 base::ThreadTaskRunnerHandle::Get(), | 220 new PairingRegistry(base::ThreadTaskRunnerHandle::Get(), |
220 make_scoped_ptr(new MockPairingRegistryDelegate())); | 221 base::WrapUnique(new MockPairingRegistryDelegate())); |
221 PairingRegistry::Pairing pairing_1 = registry->CreatePairing("client1"); | 222 PairingRegistry::Pairing pairing_1 = registry->CreatePairing("client1"); |
222 PairingRegistry::Pairing pairing_2 = registry->CreatePairing("client2"); | 223 PairingRegistry::Pairing pairing_2 = registry->CreatePairing("client2"); |
223 registry->GetPairing( | 224 registry->GetPairing( |
224 pairing_1.client_id(), | 225 pairing_1.client_id(), |
225 base::Bind(&MockPairingRegistryCallbacks::GetPairingCallback, | 226 base::Bind(&MockPairingRegistryCallbacks::GetPairingCallback, |
226 base::Unretained(&callbacks))); | 227 base::Unretained(&callbacks))); |
227 registry->GetPairing( | 228 registry->GetPairing( |
228 pairing_2.client_id(), | 229 pairing_2.client_id(), |
229 base::Bind(&MockPairingRegistryCallbacks::GetPairingCallback, | 230 base::Bind(&MockPairingRegistryCallbacks::GetPairingCallback, |
230 base::Unretained(&callbacks))); | 231 base::Unretained(&callbacks))); |
(...skipping 19 matching lines...) Expand all Loading... |
250 registry->GetPairing( | 251 registry->GetPairing( |
251 pairing_3.client_id(), | 252 pairing_3.client_id(), |
252 base::Bind(&MockPairingRegistryCallbacks::GetPairingCallback, | 253 base::Bind(&MockPairingRegistryCallbacks::GetPairingCallback, |
253 base::Unretained(&callbacks))); | 254 base::Unretained(&callbacks))); |
254 | 255 |
255 run_loop_.Run(); | 256 run_loop_.Run(); |
256 } | 257 } |
257 | 258 |
258 } // namespace protocol | 259 } // namespace protocol |
259 } // namespace remoting | 260 } // namespace remoting |
OLD | NEW |