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 3 // found in the LICENSE file. 4 5 #include "base/pickle.h" 6 #include "base/values.h" 7 #include "chrome/common/extensions/extension_messages.h" 8 #include "extensions/common/permissions/manifest_permission.h" 9 #include "extensions/common/permissions/manifest_permission_set.h" 10 #include "ipc/ipc_message.h" 11 #include "testing/gtest/include/gtest/gtest.h" 12 13 namespace extensions { 14 15 class MockManifestPermission : public ManifestPermission { 16 public: 17 MockManifestPermission(const std::string& name) 18 : name_(name) { 19 } 20 21 virtual std::string name() const OVERRIDE { 22 return name_; 23 } 24 25 virtual std::string id() const OVERRIDE { 26 return name(); 27 } 28 29 virtual bool HasMessages() const OVERRIDE { 30 return false; 31 } 32 33 virtual PermissionMessages GetMessages() const OVERRIDE { 34 return PermissionMessages(); 35 } 36 37 virtual bool FromValue(const base::Value* value) OVERRIDE { 38 return false; 39 } 40 41 virtual scoped_ptr<base::Value> ToValue() const OVERRIDE { 42 return scoped_ptr<base::Value>(base::Value::CreateNullValue()); 43 } 44 45 virtual ManifestPermission* Clone() const OVERRIDE { 46 return new MockManifestPermission(name_); 47 } 48 49 virtual ManifestPermission* Diff(const ManifestPermission* rhs) 50 const OVERRIDE { 51 const MockManifestPermission* other = 52 static_cast<const MockManifestPermission*>(rhs); 53 EXPECT_EQ(name_, other->name_); 54 return NULL; 55 } 56 57 virtual ManifestPermission* Union(const ManifestPermission* rhs) 58 const OVERRIDE { 59 const MockManifestPermission* other = 60 static_cast<const MockManifestPermission*>(rhs); 61 EXPECT_EQ(name_, other->name_); 62 return new MockManifestPermission(name_); 63 } 64 65 virtual ManifestPermission* Intersect(const ManifestPermission* rhs) 66 const OVERRIDE { 67 const MockManifestPermission* other = 68 static_cast<const MockManifestPermission*>(rhs); 69 EXPECT_EQ(name_, other->name_); 70 return new MockManifestPermission(name_); 71 } 72 73 virtual bool Contains(const ManifestPermission* rhs) const OVERRIDE { 74 const MockManifestPermission* other = 75 static_cast<const MockManifestPermission*>(rhs); 76 EXPECT_EQ(name_, other->name_); 77 return true; 78 } 79 80 virtual bool Equal(const ManifestPermission* rhs) const OVERRIDE { 81 const MockManifestPermission* other = 82 static_cast<const MockManifestPermission*>(rhs); 83 EXPECT_EQ(name_, other->name_); 84 return true; 85 } 86 87 virtual void Write(IPC::Message* m) const OVERRIDE { 88 IPC::WriteParam(m, name_); 89 } 90 91 virtual bool Read(const IPC::Message* m, PickleIterator* iter) OVERRIDE { 92 std::string read_name; 93 bool result = IPC::ReadParam(m, iter, &read_name); 94 if (!result) 95 return result; 96 EXPECT_EQ(read_name, name_); 97 return true; 98 } 99 100 virtual void Log(std::string* log) const OVERRIDE { 101 } 102 103 private: 104 std::string name_; 105 }; 106 107 TEST(ManifestPermissionSetTest, General) { 108 ManifestPermissionSet set; 109 set.insert(new MockManifestPermission("p1")); 110 set.insert(new MockManifestPermission("p2")); 111 set.insert(new MockManifestPermission("p3")); 112 set.insert(new MockManifestPermission("p4")); 113 set.insert(new MockManifestPermission("p5")); 114 115 EXPECT_EQ(set.find("p1")->id(), "p1"); 116 EXPECT_TRUE(set.find("p10") == set.end()); 117 118 EXPECT_EQ(set.size(), 5u); 119 120 EXPECT_EQ(set.erase("p1"), 1u); 121 EXPECT_EQ(set.size(), 4u); 122 123 EXPECT_EQ(set.erase("p1"), 0u); 124 EXPECT_EQ(set.size(), 4u); 125 } 126 127 TEST(ManifestPermissionSetTest, CreateUnion) { 128 ManifestPermissionSet permissions1; 129 ManifestPermissionSet permissions2; 130 ManifestPermissionSet expected_permissions; 131 ManifestPermissionSet result; 132 133 ManifestPermission* permission = new MockManifestPermission("p3"); 134 135 // Union with an empty set. 136 permissions1.insert(new MockManifestPermission("p1")); 137 permissions1.insert(new MockManifestPermission("p2")); 138 permissions1.insert(permission->Clone()); 139 expected_permissions.insert(new MockManifestPermission("p1")); 140 expected_permissions.insert(new MockManifestPermission("p2")); 141 expected_permissions.insert(permission); 142 143 ManifestPermissionSet::Union(permissions1, permissions2, &result); 144 145 EXPECT_TRUE(permissions1.Contains(permissions2)); 146 EXPECT_TRUE(permissions1.Contains(result)); 147 EXPECT_FALSE(permissions2.Contains(permissions1)); 148 EXPECT_FALSE(permissions2.Contains(result)); 149 EXPECT_TRUE(result.Contains(permissions1)); 150 EXPECT_TRUE(result.Contains(permissions2)); 151 152 EXPECT_EQ(expected_permissions, result); 153 154 // Now use a real second set. 155 permissions2.insert(new MockManifestPermission("p1")); 156 permissions2.insert(new MockManifestPermission("p2")); 157 permissions2.insert(new MockManifestPermission("p33")); 158 permissions2.insert(new MockManifestPermission("p4")); 159 permissions2.insert(new MockManifestPermission("p5")); 160 161 expected_permissions.insert(new MockManifestPermission("p1")); 162 expected_permissions.insert(new MockManifestPermission("p2")); 163 expected_permissions.insert(new MockManifestPermission("p3")); 164 expected_permissions.insert(new MockManifestPermission("p4")); 165 expected_permissions.insert(new MockManifestPermission("p5")); 166 expected_permissions.insert(new MockManifestPermission("p33")); 167 168 ManifestPermissionSet::Union(permissions1, permissions2, &result); 169 170 { 171 ManifestPermissionSet set1; 172 set1.insert(new MockManifestPermission("p1")); 173 set1.insert(new MockManifestPermission("p2")); 174 ManifestPermissionSet set2; 175 set2.insert(new MockManifestPermission("p3")); 176 177 EXPECT_FALSE(set1.Contains(set2)); 178 EXPECT_FALSE(set2.Contains(set1)); 179 } 180 181 EXPECT_FALSE(permissions1.Contains(permissions2)); 182 EXPECT_FALSE(permissions1.Contains(result)); 183 EXPECT_FALSE(permissions2.Contains(permissions1)); 184 EXPECT_FALSE(permissions2.Contains(result)); 185 EXPECT_TRUE(result.Contains(permissions1)); 186 EXPECT_TRUE(result.Contains(permissions2)); 187 188 EXPECT_EQ(expected_permissions, result); 189 } 190 191 TEST(ManifestPermissionSetTest, CreateIntersection) { 192 ManifestPermissionSet permissions1; 193 ManifestPermissionSet permissions2; 194 ManifestPermissionSet expected_permissions; 195 ManifestPermissionSet result; 196 197 // Intersection with an empty set. 198 permissions1.insert(new MockManifestPermission("p1")); 199 permissions1.insert(new MockManifestPermission("p2")); 200 permissions1.insert(new MockManifestPermission("p3")); 201 202 ManifestPermissionSet::Intersection(permissions1, permissions2, &result); 203 EXPECT_TRUE(permissions1.Contains(result)); 204 EXPECT_TRUE(permissions2.Contains(result)); 205 EXPECT_TRUE(permissions1.Contains(permissions2)); 206 EXPECT_FALSE(permissions2.Contains(permissions1)); 207 EXPECT_FALSE(result.Contains(permissions1)); 208 EXPECT_TRUE(result.Contains(permissions2)); 209 210 EXPECT_TRUE(result.empty()); 211 EXPECT_EQ(expected_permissions, result); 212 213 // Now use a real second set. 214 permissions2.insert(new MockManifestPermission("p1")); 215 permissions2.insert(new MockManifestPermission("p3")); 216 permissions2.insert(new MockManifestPermission("p4")); 217 permissions2.insert(new MockManifestPermission("p5")); 218 219 expected_permissions.insert(new MockManifestPermission("p1")); 220 expected_permissions.insert(new MockManifestPermission("p3")); 221 222 ManifestPermissionSet::Intersection(permissions1, permissions2, &result); 223 224 EXPECT_TRUE(permissions1.Contains(result)); 225 EXPECT_TRUE(permissions2.Contains(result)); 226 EXPECT_FALSE(permissions1.Contains(permissions2)); 227 EXPECT_FALSE(permissions2.Contains(permissions1)); 228 EXPECT_FALSE(result.Contains(permissions1)); 229 EXPECT_FALSE(result.Contains(permissions2)); 230 231 EXPECT_EQ(expected_permissions, result); 232 } 233 234 TEST(ManifestPermissionSetTest, CreateDifference) { 235 ManifestPermissionSet permissions1; 236 ManifestPermissionSet permissions2; 237 ManifestPermissionSet expected_permissions; 238 ManifestPermissionSet result; 239 240 // Difference with an empty set. 241 permissions1.insert(new MockManifestPermission("p1")); 242 permissions1.insert(new MockManifestPermission("p2")); 243 permissions1.insert(new MockManifestPermission("p3")); 244 245 ManifestPermissionSet::Difference(permissions1, permissions2, &result); 246 247 EXPECT_EQ(permissions1, result); 248 249 // Now use a real second set. 250 permissions2.insert(new MockManifestPermission("p1")); 251 permissions2.insert(new MockManifestPermission("p2")); 252 permissions2.insert(new MockManifestPermission("p4")); 253 permissions2.insert(new MockManifestPermission("p5")); 254 permissions2.insert(new MockManifestPermission("p6")); 255 256 expected_permissions.insert(new MockManifestPermission("p3")); 257 258 ManifestPermissionSet::Difference(permissions1, permissions2, &result); 259 260 EXPECT_TRUE(permissions1.Contains(result)); 261 EXPECT_FALSE(permissions2.Contains(result)); 262 263 EXPECT_EQ(expected_permissions, result); 264 265 // |result| = |permissions1| - |permissions2| --> 266 // |result| intersect |permissions2| == empty_set 267 ManifestPermissionSet result2; 268 ManifestPermissionSet::Intersection(result, permissions2, &result2); 269 EXPECT_TRUE(result2.empty()); 270 } 271 272 } // namespace extensions 273
