Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(642)

Side by Side Diff: chrome/browser/usb/usb_chooser_context_unittest.cc

Issue 1854483002: Remove WebUSB descriptor data from device.mojom. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@use_interface_associations
Patch Set: Rebased. Created 4 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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 }
OLDNEW
« no previous file with comments | « chrome/browser/usb/usb_chooser_context.cc ('k') | chrome/browser/usb/web_usb_permission_provider.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698