1 // Copyright 2014 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 <string> 6 #include <vector> 7 8 #include "ash/desktop_background/desktop_background_controller.h" 9 #include "ash/desktop_background/desktop_background_controller_observer.h" 10 #include "ash/shell.h" 11 #include "base/basictypes.h" 12 #include "base/command_line.h" 13 #include "base/compiler_specific.h" 14 #include "base/files/file_path.h" 15 #include "base/files/file_util.h" 16 #include "base/json/json_writer.h" 17 #include "base/memory/scoped_ptr.h" 18 #include "base/path_service.h" 19 #include "base/run_loop.h" 20 #include "chrome/browser/chromeos/login/login_manager_test.h" 21 #include "chrome/browser/chromeos/login/startup_utils.h" 22 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h" 23 #include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h" 24 #include "chrome/browser/chromeos/policy/cloud_external_data_manager_base_test_util.h" 25 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h" 26 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_factory_chromeos.h" 27 #include "chrome/browser/chromeos/profiles/profile_helper.h" 28 #include "chrome/browser/profiles/profile.h" 29 #include "chrome/common/chrome_paths.h" 30 #include "chromeos/chromeos_paths.h" 31 #include "chromeos/chromeos_switches.h" 32 #include "chromeos/dbus/cryptohome_client.h" 33 #include "chromeos/dbus/dbus_thread_manager.h" 34 #include "chromeos/dbus/fake_session_manager_client.h" 35 #include "chromeos/dbus/session_manager_client.h" 36 #include "components/policy/core/common/cloud/cloud_policy_core.h" 37 #include "components/policy/core/common/cloud/cloud_policy_store.h" 38 #include "components/policy/core/common/cloud/cloud_policy_validator.h" 39 #include "components/policy/core/common/cloud/policy_builder.h" 40 #include "components/user_manager/user.h" 41 #include "components/user_manager/user_manager.h" 42 #include "content/public/test/browser_test_utils.h" 43 #include "crypto/rsa_private_key.h" 44 #include "net/test/embedded_test_server/embedded_test_server.h" 45 #include "policy/proto/cloud_policy.pb.h" 46 #include "testing/gtest/include/gtest/gtest.h" 47 #include "third_party/skia/include/core/SkBitmap.h" 48 #include "third_party/skia/include/core/SkColor.h" 49 #include "ui/gfx/image/image_skia.h" 50 #include "url/gurl.h" 51 52 namespace chromeos { 53 54 namespace { 55 56 const char kTestUsers[2][19] = { "test-0 (at) example.com", "test-1 (at) example.com" }; 57 58 const char kRedImageFileName[] = "chromeos/wallpapers/red.jpg"; 59 const char kGreenImageFileName[] = "chromeos/wallpapers/green.jpg"; 60 const char kBlueImageFileName[] = "chromeos/wallpapers/blue.jpg"; 61 62 const SkColor kRedImageColor = SkColorSetARGB(255, 199, 6, 7); 63 const SkColor kGreenImageColor = SkColorSetARGB(255, 38, 196, 15); 64 65 policy::CloudPolicyStore* GetStoreForUser(const user_manager::User* user) { 66 Profile* profile = ProfileHelper::Get()->GetProfileByUserUnsafe(user); 67 if (!profile) { 68 ADD_FAILURE(); 69 return NULL; 70 } 71 policy::UserCloudPolicyManagerChromeOS* policy_manager = 72 policy::UserCloudPolicyManagerFactoryChromeOS::GetForProfile(profile); 73 if (!policy_manager) { 74 ADD_FAILURE(); 75 return NULL; 76 } 77 return policy_manager->core()->store(); 78 } 79 80 // Compute the average ARGB color of |bitmap|. 81 SkColor ComputeAverageColor(const SkBitmap& bitmap) { 82 if (bitmap.empty() || bitmap.width() < 1 || bitmap.height() < 1) { 83 ADD_FAILURE() << "Empty or invalid bitmap."; 84 return SkColorSetARGB(0, 0, 0, 0); 85 } 86 if (bitmap.isNull()) { 87 ADD_FAILURE() << "Bitmap has no pixelref."; 88 return SkColorSetARGB(0, 0, 0, 0); 89 } 90 if (bitmap.colorType() == kUnknown_SkColorType) { 91 ADD_FAILURE() << "Bitmap has not been configured."; 92 return SkColorSetARGB(0, 0, 0, 0); 93 } 94 uint64 a = 0, r = 0, g = 0, b = 0; 95 bitmap.lockPixels(); 96 for (int x = 0; x < bitmap.width(); ++x) { 97 for (int y = 0; y < bitmap.height(); ++y) { 98 const SkColor color = bitmap.getColor(x, y); 99 a += SkColorGetA(color); 100 r += SkColorGetR(color); 101 g += SkColorGetG(color); 102 b += SkColorGetB(color); 103 } 104 } 105 bitmap.unlockPixels(); 106 uint64 pixel_number = bitmap.width() * bitmap.height(); 107 return SkColorSetARGB((a + pixel_number / 2) / pixel_number, 108 (r + pixel_number / 2) / pixel_number, 109 (g + pixel_number / 2) / pixel_number, 110 (b + pixel_number / 2) / pixel_number); 111 } 112 113 // Obtain background image and return its average ARGB color. 114 SkColor GetAverageBackgroundColor() { 115 const gfx::ImageSkia image = 116 ash::Shell::GetInstance()->desktop_background_controller()-> 117 GetWallpaper(); 118 119 const gfx::ImageSkiaRep& representation = image.GetRepresentation(1.); 120 if (representation.is_null()) { 121 ADD_FAILURE() << "No image representation."; 122 return SkColorSetARGB(0, 0, 0, 0); 123 } 124 125 const SkBitmap& bitmap = representation.sk_bitmap(); 126 return ComputeAverageColor(bitmap); 127 } 128 129 } // namespace 130 131 class WallpaperManagerPolicyTest 132 : public LoginManagerTest, 133 public ash::DesktopBackgroundControllerObserver { 134 protected: 135 WallpaperManagerPolicyTest() 136 : LoginManagerTest(true), 137 wallpaper_change_count_(0), 138 fake_session_manager_client_(new FakeSessionManagerClient) { 139 } 140 141 scoped_ptr<policy::UserPolicyBuilder> GetUserPolicyBuilder( 142 const std::string& user_id) { 143 scoped_ptr<policy::UserPolicyBuilder> 144 user_policy_builder(new policy::UserPolicyBuilder()); 145 base::FilePath user_keys_dir; 146 EXPECT_TRUE(PathService::Get(DIR_USER_POLICY_KEYS, &user_keys_dir)); 147 const std::string sanitized_user_id = 148 CryptohomeClient::GetStubSanitizedUsername(user_id); 149 const base::FilePath user_key_file = 150 user_keys_dir.AppendASCII(sanitized_user_id) 151 .AppendASCII("policy.pub"); 152 std::vector<uint8> user_key_bits; 153 EXPECT_TRUE(user_policy_builder->GetSigningKey()-> 154 ExportPublicKey(&user_key_bits)); 155 EXPECT_TRUE(base::CreateDirectory(user_key_file.DirName())); 156 EXPECT_EQ(base::WriteFile( 157 user_key_file, 158 reinterpret_cast<const char*>(user_key_bits.data()), 159 user_key_bits.size()), 160 static_cast<int>(user_key_bits.size())); 161 user_policy_builder->policy_data().set_username(user_id); 162 return user_policy_builder.Pass(); 163 } 164 165 // LoginManagerTest: 166 virtual void SetUpInProcessBrowserTestFixture() OVERRIDE { 167 DBusThreadManager::GetSetterForTesting()->SetSessionManagerClient( 168 scoped_ptr<SessionManagerClient>(fake_session_manager_client_)); 169 170 LoginManagerTest::SetUpInProcessBrowserTestFixture(); 171 ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir_)); 172 } 173 174 virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE { 175 // Set the same switches as LoginManagerTest, except that kMultiProfiles is 176 // only set when GetParam() is true and except that kLoginProfile is set 177 // when GetParam() is false. The latter seems to be required for the sane 178 // start-up of user profiles. 179 command_line->AppendSwitch(switches::kLoginManager); 180 command_line->AppendSwitch(switches::kForceLoginManagerInTests); 181 } 182 183 virtual void SetUpOnMainThread() OVERRIDE { 184 LoginManagerTest::SetUpOnMainThread(); 185 ash::Shell::GetInstance()-> 186 desktop_background_controller()->AddObserver(this); 187 188 // Set up policy signing. 189 user_policy_builders_[0] = GetUserPolicyBuilder(kTestUsers[0]); 190 user_policy_builders_[1] = GetUserPolicyBuilder(kTestUsers[1]); 191 192 ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady()); 193 } 194 195 virtual void TearDownOnMainThread() OVERRIDE { 196 ash::Shell::GetInstance()-> 197 desktop_background_controller()->RemoveObserver(this); 198 LoginManagerTest::TearDownOnMainThread(); 199 } 200 201 // ash::DesktopBackgroundControllerObserver: 202 virtual void OnWallpaperDataChanged() OVERRIDE { 203 ++wallpaper_change_count_; 204 if (run_loop_) 205 run_loop_->Quit(); 206 } 207 208 // Runs the loop until wallpaper has changed at least |count| times in total. 209 void RunUntilWallpaperChangeCount(int count) { 210 while (wallpaper_change_count_ < count) { 211 run_loop_.reset(new base::RunLoop); 212 run_loop_->Run(); 213 } 214 } 215 216 std::string ConstructPolicy(const std::string& relative_path) const { 217 std::string image_data; 218 if (!base::ReadFileToString(test_data_dir_.Append(relative_path), 219 &image_data)) { 220 ADD_FAILURE(); 221 } 222 std::string policy; 223 base::JSONWriter::Write(policy::test::ConstructExternalDataReference( 224 embedded_test_server()->GetURL(std::string("/") + relative_path).spec(), 225 image_data).get(), 226 &policy); 227 return policy; 228 } 229 230 // Inject |filename| as wallpaper policy for test user |user_number|. Set 231 // empty |filename| to clear policy. 232 void InjectPolicy(int user_number, const std::string& filename) { 233 ASSERT_TRUE(user_number == 0 || user_number == 1); 234 const std::string user_id = kTestUsers[user_number]; 235 policy::UserPolicyBuilder* builder = 236 user_policy_builders_[user_number].get(); 237 if (filename != "") { 238 builder->payload(). 239 mutable_wallpaperimage()->set_value(ConstructPolicy(filename)); 240 } else { 241 builder->payload().Clear(); 242 } 243 builder->Build(); 244 fake_session_manager_client_->set_user_policy(user_id, builder->GetBlob()); 245 const user_manager::User* user = 246 user_manager::UserManager::Get()->FindUser(user_id); 247 ASSERT_TRUE(user); 248 policy::CloudPolicyStore* store = GetStoreForUser(user); 249 ASSERT_TRUE(store); 250 store->Load(); 251 ASSERT_EQ(policy::CloudPolicyStore::STATUS_OK, store->status()); 252 ASSERT_EQ(policy::CloudPolicyValidatorBase::VALIDATION_OK, 253 store->validation_status()); 254 } 255 256 // Obtain WallpaperInfo for |user_number| from WallpaperManager. 257 void GetUserWallpaperInfo(int user_number, WallpaperInfo* wallpaper_info) { 258 WallpaperManager::Get()-> 259 GetUserWallpaperInfo(kTestUsers[user_number], wallpaper_info); 260 } 261 262 base::FilePath test_data_dir_; 263 scoped_ptr<base::RunLoop> run_loop_; 264 int wallpaper_change_count_; 265 scoped_ptr<policy::UserPolicyBuilder> user_policy_builders_[2]; 266 FakeSessionManagerClient* fake_session_manager_client_; 267 268 private: 269 DISALLOW_COPY_AND_ASSIGN(WallpaperManagerPolicyTest); 270 }; 271 272 IN_PROC_BROWSER_TEST_F(WallpaperManagerPolicyTest, PRE_SetResetClear) { 273 RegisterUser(kTestUsers[0]); 274 RegisterUser(kTestUsers[1]); 275 StartupUtils::MarkOobeCompleted(); 276 } 277 278 // Verifies that the wallpaper can be set and re-set through policy and that 279 // setting policy for a user that is not logged in doesn't affect the current 280 // user. Also verifies that after the policy has been cleared, the wallpaper 281 // reverts to default. 282 IN_PROC_BROWSER_TEST_F(WallpaperManagerPolicyTest, SetResetClear) { 283 WallpaperInfo info; 284 LoginUser(kTestUsers[0]); 285 base::RunLoop().RunUntilIdle(); 286 287 // First user: Wait until default wallpaper has been loaded (happens 288 // automatically) and store color to recognize it later. 289 RunUntilWallpaperChangeCount(1); 290 const SkColor original_background_color = GetAverageBackgroundColor(); 291 292 // Second user: Set wallpaper policy to blue image. This should not result in 293 // a wallpaper change, which is checked at the very end of this test. 294 InjectPolicy(1, kBlueImageFileName); 295 296 // First user: Set wallpaper policy to red image and verify average color. 297 InjectPolicy(0, kRedImageFileName); 298 RunUntilWallpaperChangeCount(2); 299 GetUserWallpaperInfo(0, &info); 300 ASSERT_EQ(user_manager::User::POLICY, info.type); 301 ASSERT_EQ(kRedImageColor, GetAverageBackgroundColor()); 302 303 // First user: Set wallpaper policy to green image and verify average color. 304 InjectPolicy(0, kGreenImageFileName); 305 RunUntilWallpaperChangeCount(3); 306 GetUserWallpaperInfo(0, &info); 307 ASSERT_EQ(user_manager::User::POLICY, info.type); 308 ASSERT_EQ(kGreenImageColor, GetAverageBackgroundColor()); 309 310 // First user: Clear wallpaper policy and verify that the default wallpaper is 311 // set again. 312 InjectPolicy(0, ""); 313 RunUntilWallpaperChangeCount(4); 314 GetUserWallpaperInfo(0, &info); 315 ASSERT_EQ(user_manager::User::DEFAULT, info.type); 316 ASSERT_EQ(original_background_color, GetAverageBackgroundColor()); 317 318 // Check wallpaper change count to ensure that setting the second user's 319 // wallpaper didn't have any effect. 320 ASSERT_EQ(4, wallpaper_change_count_); 321 } 322 323 IN_PROC_BROWSER_TEST_F(WallpaperManagerPolicyTest, 324 DISABLED_PRE_PRE_PRE_WallpaperOnLoginScreen) { 325 RegisterUser(kTestUsers[0]); 326 RegisterUser(kTestUsers[1]); 327 StartupUtils::MarkOobeCompleted(); 328 } 329 330 IN_PROC_BROWSER_TEST_F(WallpaperManagerPolicyTest, 331 DISABLED_PRE_PRE_WallpaperOnLoginScreen) { 332 LoginUser(kTestUsers[0]); 333 334 // Wait until default wallpaper has been loaded. 335 RunUntilWallpaperChangeCount(1); 336 337 // Set wallpaper policy to red image. 338 InjectPolicy(0, kRedImageFileName); 339 340 // Run until wallpaper has changed. 341 RunUntilWallpaperChangeCount(2); 342 ASSERT_EQ(kRedImageColor, GetAverageBackgroundColor()); 343 } 344 345 IN_PROC_BROWSER_TEST_F(WallpaperManagerPolicyTest, 346 DISABLED_PRE_WallpaperOnLoginScreen) { 347 LoginUser(kTestUsers[1]); 348 349 // Wait until default wallpaper has been loaded. 350 RunUntilWallpaperChangeCount(1); 351 352 // Set wallpaper policy to green image. 353 InjectPolicy(1, kGreenImageFileName); 354 355 // Run until wallpaper has changed. 356 RunUntilWallpaperChangeCount(2); 357 ASSERT_EQ(kGreenImageColor, GetAverageBackgroundColor()); 358 } 359 360 // Disabled due to flakiness: http://crbug.com/385648. 361 IN_PROC_BROWSER_TEST_F(WallpaperManagerPolicyTest, 362 DISABLED_WallpaperOnLoginScreen) { 363 // Wait for active pod's wallpaper to be loaded. 364 RunUntilWallpaperChangeCount(1); 365 ASSERT_EQ(kGreenImageColor, GetAverageBackgroundColor()); 366 367 // Select the second pod (belonging to user 1). 368 ASSERT_TRUE(content::ExecuteScript( 369 static_cast<chromeos::LoginDisplayHostImpl*>( 370 chromeos::LoginDisplayHostImpl::default_host())->GetOobeUI()-> 371 web_ui()->GetWebContents(), 372 "document.getElementsByClassName('pod')[1].focus();")); 373 RunUntilWallpaperChangeCount(2); 374 ASSERT_EQ(kRedImageColor, GetAverageBackgroundColor()); 375 } 376 377 IN_PROC_BROWSER_TEST_F(WallpaperManagerPolicyTest, PRE_PRE_PersistOverLogout) { 378 RegisterUser(kTestUsers[0]); 379 StartupUtils::MarkOobeCompleted(); 380 } 381 382 IN_PROC_BROWSER_TEST_F(WallpaperManagerPolicyTest, PRE_PersistOverLogout) { 383 LoginUser(kTestUsers[0]); 384 385 // Wait until default wallpaper has been loaded. 386 RunUntilWallpaperChangeCount(1); 387 388 // Set wallpaper policy to red image. 389 InjectPolicy(0, kRedImageFileName); 390 391 // Run until wallpaper has changed. 392 RunUntilWallpaperChangeCount(2); 393 ASSERT_EQ(kRedImageColor, GetAverageBackgroundColor()); 394 } 395 396 IN_PROC_BROWSER_TEST_F(WallpaperManagerPolicyTest, PersistOverLogout) { 397 LoginUser(kTestUsers[0]); 398 399 // Wait until wallpaper has been loaded. 400 RunUntilWallpaperChangeCount(1); 401 ASSERT_EQ(kRedImageColor, GetAverageBackgroundColor()); 402 } 403 404 } // namespace chromeos 405