OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 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 <vector> | 5 #include <vector> |
6 | 6 |
7 #include "chrome/browser/usb/usb_chooser_context.h" | 7 #include "chrome/browser/usb/usb_chooser_context.h" |
8 #include "chrome/browser/usb/usb_chooser_context_factory.h" | 8 #include "chrome/browser/usb/usb_chooser_context_factory.h" |
9 #include "chrome/test/base/testing_profile.h" | 9 #include "chrome/test/base/testing_profile.h" |
10 #include "content/public/test/test_browser_thread_bundle.h" | 10 #include "content/public/test/test_browser_thread_bundle.h" |
11 #include "device/core/mock_device_client.h" | 11 #include "device/core/mock_device_client.h" |
12 #include "device/usb/mock_usb_device.h" | 12 #include "device/usb/mock_usb_device.h" |
13 #include "device/usb/mock_usb_service.h" | 13 #include "device/usb/mock_usb_service.h" |
14 #include "device/usb/mojo/type_converters.h" | |
15 #include "device/usb/public/interfaces/device.mojom.h" | |
16 | 14 |
17 using device::MockUsbDevice; | 15 using device::MockUsbDevice; |
18 using device::UsbDevice; | 16 using device::UsbDevice; |
19 | 17 |
20 class UsbChooserContextTest : public testing::Test { | 18 class UsbChooserContextTest : public testing::Test { |
21 public: | 19 public: |
22 UsbChooserContextTest() {} | 20 UsbChooserContextTest() {} |
23 ~UsbChooserContextTest() override {} | 21 ~UsbChooserContextTest() override {} |
24 | 22 |
25 protected: | 23 protected: |
26 Profile* profile() { return &profile_; } | 24 Profile* profile() { return &profile_; } |
27 | 25 |
28 device::MockDeviceClient device_client_; | 26 device::MockDeviceClient device_client_; |
29 | 27 |
30 private: | 28 private: |
31 content::TestBrowserThreadBundle thread_bundle_; | 29 content::TestBrowserThreadBundle thread_bundle_; |
32 TestingProfile profile_; | 30 TestingProfile profile_; |
33 }; | 31 }; |
34 | 32 |
35 TEST_F(UsbChooserContextTest, CheckGrantAndRevokePermission) { | 33 TEST_F(UsbChooserContextTest, CheckGrantAndRevokePermission) { |
36 GURL origin("https://www.google.com"); | 34 GURL origin("https://www.google.com"); |
37 scoped_refptr<UsbDevice> device = | 35 scoped_refptr<UsbDevice> device = |
38 new MockUsbDevice(0, 0, "Google", "Gizmo", "123ABC"); | 36 new MockUsbDevice(0, 0, "Google", "Gizmo", "123ABC"); |
39 device::usb::DeviceInfoPtr device_info = | |
40 device::usb::DeviceInfo::From(*device); | |
41 device_client_.usb_service()->AddDevice(device); | 37 device_client_.usb_service()->AddDevice(device); |
42 UsbChooserContext* store = UsbChooserContextFactory::GetForProfile(profile()); | 38 UsbChooserContext* store = UsbChooserContextFactory::GetForProfile(profile()); |
43 | 39 |
44 base::DictionaryValue object_dict; | 40 base::DictionaryValue object_dict; |
45 object_dict.SetString("name", "Gizmo"); | 41 object_dict.SetString("name", "Gizmo"); |
46 object_dict.SetInteger("vendor-id", 0); | 42 object_dict.SetInteger("vendor-id", 0); |
47 object_dict.SetInteger("product-id", 0); | 43 object_dict.SetInteger("product-id", 0); |
48 object_dict.SetString("serial-number", "123ABC"); | 44 object_dict.SetString("serial-number", "123ABC"); |
49 | 45 |
50 EXPECT_FALSE(store->HasDevicePermission(origin, origin, *device_info)); | 46 EXPECT_FALSE(store->HasDevicePermission(origin, origin, device)); |
51 store->GrantDevicePermission(origin, origin, device->guid()); | 47 store->GrantDevicePermission(origin, origin, device->guid()); |
52 EXPECT_TRUE(store->HasDevicePermission(origin, origin, *device_info)); | 48 EXPECT_TRUE(store->HasDevicePermission(origin, origin, device)); |
53 std::vector<scoped_ptr<base::DictionaryValue>> objects = | 49 std::vector<scoped_ptr<base::DictionaryValue>> objects = |
54 store->GetGrantedObjects(origin, origin); | 50 store->GetGrantedObjects(origin, origin); |
55 ASSERT_EQ(1u, objects.size()); | 51 ASSERT_EQ(1u, objects.size()); |
56 EXPECT_TRUE(object_dict.Equals(objects[0].get())); | 52 EXPECT_TRUE(object_dict.Equals(objects[0].get())); |
57 std::vector<scoped_ptr<ChooserContextBase::Object>> all_origin_objects = | 53 std::vector<scoped_ptr<ChooserContextBase::Object>> all_origin_objects = |
58 store->GetAllGrantedObjects(); | 54 store->GetAllGrantedObjects(); |
59 ASSERT_EQ(1u, all_origin_objects.size()); | 55 ASSERT_EQ(1u, all_origin_objects.size()); |
60 EXPECT_EQ(origin, all_origin_objects[0]->requesting_origin); | 56 EXPECT_EQ(origin, all_origin_objects[0]->requesting_origin); |
61 EXPECT_EQ(origin, all_origin_objects[0]->embedding_origin); | 57 EXPECT_EQ(origin, all_origin_objects[0]->embedding_origin); |
62 EXPECT_TRUE(object_dict.Equals(&all_origin_objects[0]->object)); | 58 EXPECT_TRUE(object_dict.Equals(&all_origin_objects[0]->object)); |
63 EXPECT_FALSE(all_origin_objects[0]->incognito); | 59 EXPECT_FALSE(all_origin_objects[0]->incognito); |
64 | 60 |
65 store->RevokeObjectPermission(origin, origin, *objects[0]); | 61 store->RevokeObjectPermission(origin, origin, *objects[0]); |
66 EXPECT_FALSE(store->HasDevicePermission(origin, origin, *device_info)); | 62 EXPECT_FALSE(store->HasDevicePermission(origin, origin, device)); |
67 objects = store->GetGrantedObjects(origin, origin); | 63 objects = store->GetGrantedObjects(origin, origin); |
68 EXPECT_EQ(0u, objects.size()); | 64 EXPECT_EQ(0u, objects.size()); |
69 all_origin_objects = store->GetAllGrantedObjects(); | 65 all_origin_objects = store->GetAllGrantedObjects(); |
70 EXPECT_EQ(0u, all_origin_objects.size()); | 66 EXPECT_EQ(0u, all_origin_objects.size()); |
71 } | 67 } |
72 | 68 |
73 TEST_F(UsbChooserContextTest, CheckGrantAndRevokeEphemeralPermission) { | 69 TEST_F(UsbChooserContextTest, CheckGrantAndRevokeEphemeralPermission) { |
74 GURL origin("https://www.google.com"); | 70 GURL origin("https://www.google.com"); |
75 scoped_refptr<UsbDevice> device = | 71 scoped_refptr<UsbDevice> device = |
76 new MockUsbDevice(0, 0, "Google", "Gizmo", ""); | 72 new MockUsbDevice(0, 0, "Google", "Gizmo", ""); |
77 device::usb::DeviceInfoPtr device_info = | |
78 device::usb::DeviceInfo::From(*device); | |
79 scoped_refptr<UsbDevice> other_device = | 73 scoped_refptr<UsbDevice> other_device = |
80 new MockUsbDevice(0, 0, "Google", "Gizmo", ""); | 74 new MockUsbDevice(0, 0, "Google", "Gizmo", ""); |
81 device::usb::DeviceInfoPtr other_device_info = | |
82 device::usb::DeviceInfo::From(*other_device); | |
83 device_client_.usb_service()->AddDevice(device); | 75 device_client_.usb_service()->AddDevice(device); |
84 UsbChooserContext* store = UsbChooserContextFactory::GetForProfile(profile()); | 76 UsbChooserContext* store = UsbChooserContextFactory::GetForProfile(profile()); |
85 | 77 |
86 base::DictionaryValue object_dict; | 78 base::DictionaryValue object_dict; |
87 object_dict.SetString("name", "Gizmo"); | 79 object_dict.SetString("name", "Gizmo"); |
88 object_dict.SetString("ephemeral-guid", device->guid()); | 80 object_dict.SetString("ephemeral-guid", device->guid()); |
89 | 81 |
90 EXPECT_FALSE(store->HasDevicePermission(origin, origin, *device_info)); | 82 EXPECT_FALSE(store->HasDevicePermission(origin, origin, device)); |
91 store->GrantDevicePermission(origin, origin, device->guid()); | 83 store->GrantDevicePermission(origin, origin, device->guid()); |
92 EXPECT_TRUE(store->HasDevicePermission(origin, origin, *device_info)); | 84 EXPECT_TRUE(store->HasDevicePermission(origin, origin, device)); |
93 EXPECT_FALSE(store->HasDevicePermission(origin, origin, *other_device_info)); | 85 EXPECT_FALSE(store->HasDevicePermission(origin, origin, other_device)); |
94 std::vector<scoped_ptr<base::DictionaryValue>> objects = | 86 std::vector<scoped_ptr<base::DictionaryValue>> objects = |
95 store->GetGrantedObjects(origin, origin); | 87 store->GetGrantedObjects(origin, origin); |
96 EXPECT_EQ(1u, objects.size()); | 88 EXPECT_EQ(1u, objects.size()); |
97 EXPECT_TRUE(object_dict.Equals(objects[0].get())); | 89 EXPECT_TRUE(object_dict.Equals(objects[0].get())); |
98 std::vector<scoped_ptr<ChooserContextBase::Object>> all_origin_objects = | 90 std::vector<scoped_ptr<ChooserContextBase::Object>> all_origin_objects = |
99 store->GetAllGrantedObjects(); | 91 store->GetAllGrantedObjects(); |
100 EXPECT_EQ(1u, all_origin_objects.size()); | 92 EXPECT_EQ(1u, all_origin_objects.size()); |
101 EXPECT_EQ(origin, all_origin_objects[0]->requesting_origin); | 93 EXPECT_EQ(origin, all_origin_objects[0]->requesting_origin); |
102 EXPECT_EQ(origin, all_origin_objects[0]->embedding_origin); | 94 EXPECT_EQ(origin, all_origin_objects[0]->embedding_origin); |
103 EXPECT_TRUE(object_dict.Equals(&all_origin_objects[0]->object)); | 95 EXPECT_TRUE(object_dict.Equals(&all_origin_objects[0]->object)); |
104 EXPECT_FALSE(all_origin_objects[0]->incognito); | 96 EXPECT_FALSE(all_origin_objects[0]->incognito); |
105 | 97 |
106 store->RevokeObjectPermission(origin, origin, *objects[0]); | 98 store->RevokeObjectPermission(origin, origin, *objects[0]); |
107 EXPECT_FALSE(store->HasDevicePermission(origin, origin, *device_info)); | 99 EXPECT_FALSE(store->HasDevicePermission(origin, origin, device)); |
108 objects = store->GetGrantedObjects(origin, origin); | 100 objects = store->GetGrantedObjects(origin, origin); |
109 EXPECT_EQ(0u, objects.size()); | 101 EXPECT_EQ(0u, objects.size()); |
110 all_origin_objects = store->GetAllGrantedObjects(); | 102 all_origin_objects = store->GetAllGrantedObjects(); |
111 EXPECT_EQ(0u, all_origin_objects.size()); | 103 EXPECT_EQ(0u, all_origin_objects.size()); |
112 } | 104 } |
113 | 105 |
114 TEST_F(UsbChooserContextTest, DisconnectDeviceWithPermission) { | 106 TEST_F(UsbChooserContextTest, DisconnectDeviceWithPermission) { |
115 GURL origin("https://www.google.com"); | 107 GURL origin("https://www.google.com"); |
116 scoped_refptr<UsbDevice> device = | 108 scoped_refptr<UsbDevice> device = |
117 new MockUsbDevice(0, 0, "Google", "Gizmo", "123ABC"); | 109 new MockUsbDevice(0, 0, "Google", "Gizmo", "123ABC"); |
118 device::usb::DeviceInfoPtr device_info = | |
119 device::usb::DeviceInfo::From(*device); | |
120 device_client_.usb_service()->AddDevice(device); | 110 device_client_.usb_service()->AddDevice(device); |
121 UsbChooserContext* store = UsbChooserContextFactory::GetForProfile(profile()); | 111 UsbChooserContext* store = UsbChooserContextFactory::GetForProfile(profile()); |
122 | 112 |
123 EXPECT_FALSE(store->HasDevicePermission(origin, origin, *device_info)); | 113 EXPECT_FALSE(store->HasDevicePermission(origin, origin, device)); |
124 store->GrantDevicePermission(origin, origin, device->guid()); | 114 store->GrantDevicePermission(origin, origin, device->guid()); |
125 EXPECT_TRUE(store->HasDevicePermission(origin, origin, *device_info)); | 115 EXPECT_TRUE(store->HasDevicePermission(origin, origin, device)); |
126 std::vector<scoped_ptr<base::DictionaryValue>> objects = | 116 std::vector<scoped_ptr<base::DictionaryValue>> objects = |
127 store->GetGrantedObjects(origin, origin); | 117 store->GetGrantedObjects(origin, origin); |
128 EXPECT_EQ(1u, objects.size()); | 118 EXPECT_EQ(1u, objects.size()); |
129 std::vector<scoped_ptr<ChooserContextBase::Object>> all_origin_objects = | 119 std::vector<scoped_ptr<ChooserContextBase::Object>> all_origin_objects = |
130 store->GetAllGrantedObjects(); | 120 store->GetAllGrantedObjects(); |
131 EXPECT_EQ(1u, all_origin_objects.size()); | 121 EXPECT_EQ(1u, all_origin_objects.size()); |
132 | 122 |
133 device_client_.usb_service()->RemoveDevice(device); | 123 device_client_.usb_service()->RemoveDevice(device); |
134 EXPECT_TRUE(store->HasDevicePermission(origin, origin, *device_info)); | 124 EXPECT_TRUE(store->HasDevicePermission(origin, origin, device)); |
135 objects = store->GetGrantedObjects(origin, origin); | 125 objects = store->GetGrantedObjects(origin, origin); |
136 EXPECT_EQ(1u, objects.size()); | 126 EXPECT_EQ(1u, objects.size()); |
137 all_origin_objects = store->GetAllGrantedObjects(); | 127 all_origin_objects = store->GetAllGrantedObjects(); |
138 EXPECT_EQ(1u, all_origin_objects.size()); | 128 EXPECT_EQ(1u, all_origin_objects.size()); |
139 | 129 |
140 scoped_refptr<UsbDevice> reconnected_device = | 130 scoped_refptr<UsbDevice> reconnected_device = |
141 new MockUsbDevice(0, 0, "Google", "Gizmo", "123ABC"); | 131 new MockUsbDevice(0, 0, "Google", "Gizmo", "123ABC"); |
142 device_client_.usb_service()->AddDevice(reconnected_device); | 132 device_client_.usb_service()->AddDevice(reconnected_device); |
143 device_info = device::usb::DeviceInfo::From(*reconnected_device); | 133 EXPECT_TRUE(store->HasDevicePermission(origin, origin, reconnected_device)); |
144 EXPECT_TRUE(store->HasDevicePermission(origin, origin, *device_info)); | |
145 objects = store->GetGrantedObjects(origin, origin); | 134 objects = store->GetGrantedObjects(origin, origin); |
146 EXPECT_EQ(1u, objects.size()); | 135 EXPECT_EQ(1u, objects.size()); |
147 all_origin_objects = store->GetAllGrantedObjects(); | 136 all_origin_objects = store->GetAllGrantedObjects(); |
148 EXPECT_EQ(1u, all_origin_objects.size()); | 137 EXPECT_EQ(1u, all_origin_objects.size()); |
149 } | 138 } |
150 | 139 |
151 TEST_F(UsbChooserContextTest, DisconnectDeviceWithEphemeralPermission) { | 140 TEST_F(UsbChooserContextTest, DisconnectDeviceWithEphemeralPermission) { |
152 GURL origin("https://www.google.com"); | 141 GURL origin("https://www.google.com"); |
153 scoped_refptr<UsbDevice> device = | 142 scoped_refptr<UsbDevice> device = |
154 new MockUsbDevice(0, 0, "Google", "Gizmo", ""); | 143 new MockUsbDevice(0, 0, "Google", "Gizmo", ""); |
155 device::usb::DeviceInfoPtr device_info = | |
156 device::usb::DeviceInfo::From(*device); | |
157 device_client_.usb_service()->AddDevice(device); | 144 device_client_.usb_service()->AddDevice(device); |
158 UsbChooserContext* store = UsbChooserContextFactory::GetForProfile(profile()); | 145 UsbChooserContext* store = UsbChooserContextFactory::GetForProfile(profile()); |
159 | 146 |
160 EXPECT_FALSE(store->HasDevicePermission(origin, origin, *device_info)); | 147 EXPECT_FALSE(store->HasDevicePermission(origin, origin, device)); |
161 store->GrantDevicePermission(origin, origin, device->guid()); | 148 store->GrantDevicePermission(origin, origin, device->guid()); |
162 EXPECT_TRUE(store->HasDevicePermission(origin, origin, *device_info)); | 149 EXPECT_TRUE(store->HasDevicePermission(origin, origin, device)); |
163 std::vector<scoped_ptr<base::DictionaryValue>> objects = | 150 std::vector<scoped_ptr<base::DictionaryValue>> objects = |
164 store->GetGrantedObjects(origin, origin); | 151 store->GetGrantedObjects(origin, origin); |
165 EXPECT_EQ(1u, objects.size()); | 152 EXPECT_EQ(1u, objects.size()); |
166 std::vector<scoped_ptr<ChooserContextBase::Object>> all_origin_objects = | 153 std::vector<scoped_ptr<ChooserContextBase::Object>> all_origin_objects = |
167 store->GetAllGrantedObjects(); | 154 store->GetAllGrantedObjects(); |
168 EXPECT_EQ(1u, all_origin_objects.size()); | 155 EXPECT_EQ(1u, all_origin_objects.size()); |
169 | 156 |
170 device_client_.usb_service()->RemoveDevice(device); | 157 device_client_.usb_service()->RemoveDevice(device); |
171 EXPECT_FALSE(store->HasDevicePermission(origin, origin, *device_info)); | 158 EXPECT_FALSE(store->HasDevicePermission(origin, origin, device)); |
172 objects = store->GetGrantedObjects(origin, origin); | 159 objects = store->GetGrantedObjects(origin, origin); |
173 EXPECT_EQ(0u, objects.size()); | 160 EXPECT_EQ(0u, objects.size()); |
174 all_origin_objects = store->GetAllGrantedObjects(); | 161 all_origin_objects = store->GetAllGrantedObjects(); |
175 EXPECT_EQ(0u, all_origin_objects.size()); | 162 EXPECT_EQ(0u, all_origin_objects.size()); |
176 | 163 |
177 scoped_refptr<UsbDevice> reconnected_device = | 164 scoped_refptr<UsbDevice> reconnected_device = |
178 new MockUsbDevice(0, 0, "Google", "Gizmo", ""); | 165 new MockUsbDevice(0, 0, "Google", "Gizmo", ""); |
179 device_info = device::usb::DeviceInfo::From(*reconnected_device); | |
180 device_client_.usb_service()->AddDevice(reconnected_device); | 166 device_client_.usb_service()->AddDevice(reconnected_device); |
181 EXPECT_FALSE(store->HasDevicePermission(origin, origin, *device_info)); | 167 EXPECT_FALSE(store->HasDevicePermission(origin, origin, reconnected_device)); |
182 objects = store->GetGrantedObjects(origin, origin); | 168 objects = store->GetGrantedObjects(origin, origin); |
183 EXPECT_EQ(0u, objects.size()); | 169 EXPECT_EQ(0u, objects.size()); |
184 all_origin_objects = store->GetAllGrantedObjects(); | 170 all_origin_objects = store->GetAllGrantedObjects(); |
185 EXPECT_EQ(0u, all_origin_objects.size()); | 171 EXPECT_EQ(0u, all_origin_objects.size()); |
186 } | 172 } |
187 | 173 |
188 TEST_F(UsbChooserContextTest, GrantPermissionInIncognito) { | 174 TEST_F(UsbChooserContextTest, GrantPermissionInIncognito) { |
189 GURL origin("https://www.google.com"); | 175 GURL origin("https://www.google.com"); |
190 UsbChooserContext* store = UsbChooserContextFactory::GetForProfile(profile()); | 176 UsbChooserContext* store = UsbChooserContextFactory::GetForProfile(profile()); |
191 UsbChooserContext* incognito_store = UsbChooserContextFactory::GetForProfile( | 177 UsbChooserContext* incognito_store = UsbChooserContextFactory::GetForProfile( |
192 profile()->GetOffTheRecordProfile()); | 178 profile()->GetOffTheRecordProfile()); |
193 | 179 |
194 scoped_refptr<UsbDevice> device1 = | 180 scoped_refptr<UsbDevice> device1 = |
195 new MockUsbDevice(0, 0, "Google", "Gizmo", ""); | 181 new MockUsbDevice(0, 0, "Google", "Gizmo", ""); |
196 device::usb::DeviceInfoPtr device1_info = | |
197 device::usb::DeviceInfo::From(*device1); | |
198 scoped_refptr<UsbDevice> device2 = | 182 scoped_refptr<UsbDevice> device2 = |
199 new MockUsbDevice(0, 0, "Google", "Gizmo", ""); | 183 new MockUsbDevice(0, 0, "Google", "Gizmo", ""); |
200 device::usb::DeviceInfoPtr device2_info = | |
201 device::usb::DeviceInfo::From(*device2); | |
202 device_client_.usb_service()->AddDevice(device1); | 184 device_client_.usb_service()->AddDevice(device1); |
203 device_client_.usb_service()->AddDevice(device2); | 185 device_client_.usb_service()->AddDevice(device2); |
204 | 186 |
205 store->GrantDevicePermission(origin, origin, device1->guid()); | 187 store->GrantDevicePermission(origin, origin, device1->guid()); |
206 EXPECT_TRUE(store->HasDevicePermission(origin, origin, *device1_info)); | 188 EXPECT_TRUE(store->HasDevicePermission(origin, origin, device1)); |
207 EXPECT_FALSE( | 189 EXPECT_FALSE(incognito_store->HasDevicePermission(origin, origin, device1)); |
208 incognito_store->HasDevicePermission(origin, origin, *device1_info)); | |
209 | 190 |
210 incognito_store->GrantDevicePermission(origin, origin, device2->guid()); | 191 incognito_store->GrantDevicePermission(origin, origin, device2->guid()); |
211 EXPECT_TRUE(store->HasDevicePermission(origin, origin, *device1_info)); | 192 EXPECT_TRUE(store->HasDevicePermission(origin, origin, device1)); |
212 EXPECT_FALSE(store->HasDevicePermission(origin, origin, *device2_info)); | 193 EXPECT_FALSE(store->HasDevicePermission(origin, origin, device2)); |
213 EXPECT_FALSE( | 194 EXPECT_FALSE(incognito_store->HasDevicePermission(origin, origin, device1)); |
214 incognito_store->HasDevicePermission(origin, origin, *device1_info)); | 195 EXPECT_TRUE(incognito_store->HasDevicePermission(origin, origin, device2)); |
215 EXPECT_TRUE( | |
216 incognito_store->HasDevicePermission(origin, origin, *device2_info)); | |
217 | 196 |
218 { | 197 { |
219 std::vector<scoped_ptr<base::DictionaryValue>> objects = | 198 std::vector<scoped_ptr<base::DictionaryValue>> objects = |
220 store->GetGrantedObjects(origin, origin); | 199 store->GetGrantedObjects(origin, origin); |
221 EXPECT_EQ(1u, objects.size()); | 200 EXPECT_EQ(1u, objects.size()); |
222 std::vector<scoped_ptr<ChooserContextBase::Object>> all_origin_objects = | 201 std::vector<scoped_ptr<ChooserContextBase::Object>> all_origin_objects = |
223 store->GetAllGrantedObjects(); | 202 store->GetAllGrantedObjects(); |
224 ASSERT_EQ(1u, all_origin_objects.size()); | 203 ASSERT_EQ(1u, all_origin_objects.size()); |
225 EXPECT_FALSE(all_origin_objects[0]->incognito); | 204 EXPECT_FALSE(all_origin_objects[0]->incognito); |
226 } | 205 } |
227 { | 206 { |
228 std::vector<scoped_ptr<base::DictionaryValue>> objects = | 207 std::vector<scoped_ptr<base::DictionaryValue>> objects = |
229 incognito_store->GetGrantedObjects(origin, origin); | 208 incognito_store->GetGrantedObjects(origin, origin); |
230 EXPECT_EQ(1u, objects.size()); | 209 EXPECT_EQ(1u, objects.size()); |
231 std::vector<scoped_ptr<ChooserContextBase::Object>> all_origin_objects = | 210 std::vector<scoped_ptr<ChooserContextBase::Object>> all_origin_objects = |
232 incognito_store->GetAllGrantedObjects(); | 211 incognito_store->GetAllGrantedObjects(); |
233 ASSERT_EQ(1u, all_origin_objects.size()); | 212 ASSERT_EQ(1u, all_origin_objects.size()); |
234 EXPECT_TRUE(all_origin_objects[0]->incognito); | 213 EXPECT_TRUE(all_origin_objects[0]->incognito); |
235 } | 214 } |
236 } | 215 } |
OLD | NEW |