src/chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager_policy_browsertest.cc

   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@example.com", "test-1@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