1 // Copyright (c) 2012 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 "ash/desktop_background/desktop_background_controller.h"
6
7 #include <cmath>
8 #include <cstdlib>
9
10 #include "ash/ash_switches.h"
11 #include "ash/desktop_background/desktop_background_controller_observer.h"
12 #include "ash/desktop_background/desktop_background_widget_controller.h"
13 #include "ash/root_window_controller.h"
14 #include "ash/shell.h"
15 #include "ash/shell_window_ids.h"
16 #include "ash/test/ash_test_base.h"
17 #include "ash/test/display_manager_test_api.h"
18 #include "ash/test/test_user_wallpaper_delegate.h"
19 #include "base/command_line.h"
20 #include "base/file_util.h"
21 #include "base/files/file_path.h"
22 #include "base/files/scoped_temp_dir.h"
23 #include "base/message_loop/message_loop.h"
24 #include "base/threading/sequenced_worker_pool.h"
25 #include "content/public/browser/browser_thread.h"
26 #include "content/public/test/test_browser_thread.h"
27 #include "content/public/test/test_utils.h"
28 #include "third_party/skia/include/core/SkBitmap.h"
29 #include "third_party/skia/include/core/SkColor.h"
30 #include "ui/aura/root_window.h"
31 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
32 #include "ui/compositor/test/layer_animator_test_controller.h"
33 #include "ui/gfx/codec/jpeg_codec.h"
34 #include "ui/gfx/point.h"
35 #include "ui/gfx/rect.h"
36
37 using aura::RootWindow;
38 using aura::Window;
39
40 namespace ash {
41 namespace {
42
43 // Containers IDs used for tests.
44 const int kDesktopBackgroundId =
45 ash::internal::kShellWindowId_DesktopBackgroundContainer;
46 const int kLockScreenBackgroundId =
47 ash::internal::kShellWindowId_LockScreenBackgroundContainer;
48
49 // Returns number of child windows in a shell window container.
ChildCountForContainer(int container_id)50 int ChildCountForContainer(int container_id) {
51 Window* root = ash::Shell::GetPrimaryRootWindow();
52 Window* container = root->GetChildById(container_id);
53 return static_cast<int>(container->children().size());
54 }
55
56 class TestObserver : public DesktopBackgroundControllerObserver {
57 public:
TestObserver(DesktopBackgroundController * controller)58 explicit TestObserver(DesktopBackgroundController* controller)
59 : controller_(controller) {
60 DCHECK(controller_);
61 controller_->AddObserver(this);
62 }
63
~TestObserver()64 virtual ~TestObserver() {
65 controller_->RemoveObserver(this);
66 }
67
WaitForWallpaperDataChanged()68 void WaitForWallpaperDataChanged() {
69 base::MessageLoop::current()->Run();
70 }
71
72 // DesktopBackgroundControllerObserver overrides:
OnWallpaperDataChanged()73 virtual void OnWallpaperDataChanged() OVERRIDE {
74 base::MessageLoop::current()->Quit();
75 }
76
77 private:
78 DesktopBackgroundController* controller_;
79 };
80
81 // Steps a widget's layer animation until it is completed. Animations must be
82 // enabled.
RunAnimationForWidget(views::Widget * widget)83 void RunAnimationForWidget(views::Widget* widget) {
84 // Animations must be enabled for stepping to work.
85 ASSERT_NE(ui::ScopedAnimationDurationScaleMode::duration_scale_mode(),
86 ui::ScopedAnimationDurationScaleMode::ZERO_DURATION);
87
88 ui::Layer* layer = widget->GetNativeView()->layer();
89 ui::LayerAnimatorTestController controller(layer->GetAnimator());
90 gfx::AnimationContainerElement* element = layer->GetAnimator();
91 // Multiple steps are required to complete complex animations.
92 // TODO(vollick): This should not be necessary. crbug.com/154017
93 while (controller.animator()->is_animating()) {
94 controller.StartThreadedAnimationsIfNeeded();
95 base::TimeTicks step_time = controller.animator()->last_step_time();
96 element->Step(step_time + base::TimeDelta::FromMilliseconds(1000));
97 }
98 }
99
100 } // namespace
101
102 class DesktopBackgroundControllerTest : public test::AshTestBase {
103 public:
DesktopBackgroundControllerTest()104 DesktopBackgroundControllerTest()
105 : command_line_(CommandLine::NO_PROGRAM),
106 controller_(NULL) {
107 }
~DesktopBackgroundControllerTest()108 virtual ~DesktopBackgroundControllerTest() {}
109
SetUp()110 virtual void SetUp() OVERRIDE {
111 test::AshTestBase::SetUp();
112 // Ash shell initialization creates wallpaper. Reset it so we can manually
113 // control wallpaper creation and animation in our tests.
114 internal::RootWindowController* root_window_controller =
115 Shell::GetPrimaryRootWindowController();
116 root_window_controller->SetWallpaperController(NULL);
117 root_window_controller->SetAnimatingWallpaperController(NULL);
118 controller_ = Shell::GetInstance()->desktop_background_controller();
119 wallpaper_delegate_ = static_cast<test::TestUserWallpaperDelegate*>(
120 Shell::GetInstance()->user_wallpaper_delegate());
121 controller_->set_wallpaper_reload_delay_for_test(0);
122 }
123
124 protected:
125 // Colors used for different default wallpapers by
126 // WriteWallpapersAndSetFlags().
127 static const SkColor kLargeWallpaperColor = SK_ColorRED;
128 static const SkColor kSmallWallpaperColor = SK_ColorGREEN;
129 static const SkColor kLargeGuestWallpaperColor = SK_ColorBLUE;
130 static const SkColor kSmallGuestWallpaperColor = SK_ColorYELLOW;
131
132 // Dimension used for width and height of default wallpaper images. A
133 // small value is used to minimize the amount of time spent compressing
134 // and writing images.
135 static const int kWallpaperSize = 2;
136
137 // Creates an image of size |size|.
CreateImage(int width,int height)138 gfx::ImageSkia CreateImage(int width, int height) {
139 SkBitmap bitmap;
140 bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
141 bitmap.allocPixels();
142 gfx::ImageSkia image = gfx::ImageSkia::CreateFrom1xBitmap(bitmap);
143 return image;
144 }
145
146 // Runs kAnimatingDesktopController's animation to completion.
147 // TODO(bshe): Don't require tests to run animations; it's slow.
RunDesktopControllerAnimation()148 void RunDesktopControllerAnimation() {
149 internal::DesktopBackgroundWidgetController* controller =
150 Shell::GetPrimaryRootWindowController()->
151 animating_wallpaper_controller()->GetController(false);
152 ASSERT_NO_FATAL_FAILURE(RunAnimationForWidget(controller->widget()));
153 }
154
155 // Returns true if the color at the center of |image| is close to
156 // |expected_color|. (The center is used so small wallpaper images can be
157 // used.)
ImageIsNearColor(gfx::ImageSkia image,SkColor expected_color)158 bool ImageIsNearColor(gfx::ImageSkia image, SkColor expected_color) {
159 if (image.size().IsEmpty()) {
160 LOG(ERROR) << "Image is empty";
161 return false;
162 }
163
164 const SkBitmap* bitmap = image.bitmap();
165 if (!bitmap) {
166 LOG(ERROR) << "Unable to get bitmap from image";
167 return false;
168 }
169
170 bitmap->lockPixels();
171 gfx::Point center = gfx::Rect(image.size()).CenterPoint();
172 SkColor image_color = bitmap->getColor(center.x(), center.y());
173 bitmap->unlockPixels();
174
175 const int kDiff = 3;
176 if (std::abs(static_cast<int>(SkColorGetA(image_color)) -
177 static_cast<int>(SkColorGetA(expected_color))) > kDiff ||
178 std::abs(static_cast<int>(SkColorGetR(image_color)) -
179 static_cast<int>(SkColorGetR(expected_color))) > kDiff ||
180 std::abs(static_cast<int>(SkColorGetG(image_color)) -
181 static_cast<int>(SkColorGetG(expected_color))) > kDiff ||
182 std::abs(static_cast<int>(SkColorGetB(image_color)) -
183 static_cast<int>(SkColorGetB(expected_color))) > kDiff) {
184 LOG(ERROR) << "Expected color near 0x" << std::hex << expected_color
185 << " but got 0x" << image_color;
186 return false;
187 }
188
189 return true;
190 }
191
192 // Writes a JPEG image of the specified size and color to |path|. Returns
193 // true on success.
WriteJPEGFile(const base::FilePath & path,int width,int height,SkColor color)194 bool WriteJPEGFile(const base::FilePath& path,
195 int width,
196 int height,
197 SkColor color) {
198 SkBitmap bitmap;
199 bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height, 0);
200 bitmap.allocPixels();
201 bitmap.eraseColor(color);
202
203 const int kQuality = 80;
204 std::vector<unsigned char> output;
205 if (!gfx::JPEGCodec::Encode(
206 static_cast<const unsigned char*>(bitmap.getPixels()),
207 gfx::JPEGCodec::FORMAT_SkBitmap, width, height, bitmap.rowBytes(),
208 kQuality, &output)) {
209 LOG(ERROR) << "Unable to encode " << width << "x" << height << " bitmap";
210 return false;
211 }
212
213 size_t bytes_written = file_util::WriteFile(
214 path, reinterpret_cast<const char*>(&output[0]), output.size());
215 if (bytes_written != output.size()) {
216 LOG(ERROR) << "Wrote " << bytes_written << " byte(s) instead of "
217 << output.size() << " to " << path.value();
218 return false;
219 }
220
221 return true;
222 }
223
224 // Initializes |wallpaper_dir_|, writes JPEG wallpaper images to it, and
225 // passes |controller_| a command line instructing it to use the images.
226 // Only needs to be called (once) by tests that want to test loading of
227 // default wallpapers.
WriteWallpapersAndSetFlags()228 void WriteWallpapersAndSetFlags() {
229 wallpaper_dir_.reset(new base::ScopedTempDir);
230 ASSERT_TRUE(wallpaper_dir_->CreateUniqueTempDir());
231
232 const base::FilePath kLargePath =
233 wallpaper_dir_->path().Append(FILE_PATH_LITERAL("large.jpg"));
234 ASSERT_TRUE(WriteJPEGFile(kLargePath, kWallpaperSize, kWallpaperSize,
235 kLargeWallpaperColor));
236 command_line_.AppendSwitchPath(
237 switches::kAshDefaultWallpaperLarge, kLargePath);
238
239 const base::FilePath kSmallPath =
240 wallpaper_dir_->path().Append(FILE_PATH_LITERAL("small.jpg"));
241 ASSERT_TRUE(WriteJPEGFile(kSmallPath, kWallpaperSize, kWallpaperSize,
242 kSmallWallpaperColor));
243 command_line_.AppendSwitchPath(
244 switches::kAshDefaultWallpaperSmall, kSmallPath);
245
246 const base::FilePath kLargeGuestPath =
247 wallpaper_dir_->path().Append(FILE_PATH_LITERAL("guest_large.jpg"));
248 ASSERT_TRUE(WriteJPEGFile(kLargeGuestPath, kWallpaperSize, kWallpaperSize,
249 kLargeGuestWallpaperColor));
250 command_line_.AppendSwitchPath(
251 switches::kAshGuestWallpaperLarge, kLargeGuestPath);
252
253 const base::FilePath kSmallGuestPath =
254 wallpaper_dir_->path().Append(FILE_PATH_LITERAL("guest_small.jpg"));
255 ASSERT_TRUE(WriteJPEGFile(kSmallGuestPath, kWallpaperSize, kWallpaperSize,
256 kSmallGuestWallpaperColor));
257 command_line_.AppendSwitchPath(
258 switches::kAshGuestWallpaperSmall, kSmallGuestPath);
259
260 controller_->set_command_line_for_testing(&command_line_);
261 }
262
263 // Custom command line passed to DesktopBackgroundController by
264 // WriteWallpapersAndSetFlags().
265 CommandLine command_line_;
266
267 // Directory created by WriteWallpapersAndSetFlags() to store default
268 // wallpaper images.
269 scoped_ptr<base::ScopedTempDir> wallpaper_dir_;
270
271 DesktopBackgroundController* controller_; // Not owned.
272
273 test::TestUserWallpaperDelegate* wallpaper_delegate_;
274
275 private:
276 DISALLOW_COPY_AND_ASSIGN(DesktopBackgroundControllerTest);
277 };
278
TEST_F(DesktopBackgroundControllerTest,BasicReparenting)279 TEST_F(DesktopBackgroundControllerTest, BasicReparenting) {
280 DesktopBackgroundController* controller =
281 Shell::GetInstance()->desktop_background_controller();
282 controller->CreateEmptyWallpaper();
283
284 // Wallpaper view/window exists in the desktop background container and
285 // nothing is in the lock screen background container.
286 EXPECT_EQ(1, ChildCountForContainer(kDesktopBackgroundId));
287 EXPECT_EQ(0, ChildCountForContainer(kLockScreenBackgroundId));
288
289 // Moving background to lock container should succeed the first time but
290 // subsequent calls should do nothing.
291 EXPECT_TRUE(controller->MoveDesktopToLockedContainer());
292 EXPECT_FALSE(controller->MoveDesktopToLockedContainer());
293
294 // One window is moved from desktop to lock container.
295 EXPECT_EQ(0, ChildCountForContainer(kDesktopBackgroundId));
296 EXPECT_EQ(1, ChildCountForContainer(kLockScreenBackgroundId));
297
298 // Moving background to desktop container should succeed the first time.
299 EXPECT_TRUE(controller->MoveDesktopToUnlockedContainer());
300 EXPECT_FALSE(controller->MoveDesktopToUnlockedContainer());
301
302 // One window is moved from lock to desktop container.
303 EXPECT_EQ(1, ChildCountForContainer(kDesktopBackgroundId));
304 EXPECT_EQ(0, ChildCountForContainer(kLockScreenBackgroundId));
305 }
306
TEST_F(DesktopBackgroundControllerTest,ControllerOwnership)307 TEST_F(DesktopBackgroundControllerTest, ControllerOwnership) {
308 // We cannot short-circuit animations for this test.
309 ui::ScopedAnimationDurationScaleMode normal_duration_mode(
310 ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION);
311
312 // Create wallpaper and background view.
313 DesktopBackgroundController* controller =
314 Shell::GetInstance()->desktop_background_controller();
315 controller->CreateEmptyWallpaper();
316
317 // The new wallpaper is ready to start animating. kAnimatingDesktopController
318 // holds the widget controller instance. kDesktopController will get it later.
319 internal::RootWindowController* root_window_controller =
320 Shell::GetPrimaryRootWindowController();
321 EXPECT_TRUE(root_window_controller->animating_wallpaper_controller()->
322 GetController(false));
323
324 // kDesktopController will receive the widget controller when the animation
325 // is done.
326 EXPECT_FALSE(root_window_controller->wallpaper_controller());
327
328 // Force the widget's layer animation to play to completion.
329 RunDesktopControllerAnimation();
330
331 // Ownership has moved from kAnimatingDesktopController to kDesktopController.
332 EXPECT_FALSE(root_window_controller->animating_wallpaper_controller()->
333 GetController(false));
334 EXPECT_TRUE(root_window_controller->wallpaper_controller());
335 }
336
337 // Test for crbug.com/149043 "Unlock screen, no launcher appears". Ensure we
338 // move all desktop views if there are more than one.
TEST_F(DesktopBackgroundControllerTest,BackgroundMovementDuringUnlock)339 TEST_F(DesktopBackgroundControllerTest, BackgroundMovementDuringUnlock) {
340 // We cannot short-circuit animations for this test.
341 ui::ScopedAnimationDurationScaleMode normal_duration_mode(
342 ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION);
343
344 // Reset wallpaper state, see ControllerOwnership above.
345 DesktopBackgroundController* controller =
346 Shell::GetInstance()->desktop_background_controller();
347 controller->CreateEmptyWallpaper();
348
349 // Run wallpaper show animation to completion.
350 RunDesktopControllerAnimation();
351
352 // User locks the screen, which moves the background forward.
353 controller->MoveDesktopToLockedContainer();
354
355 // Suspend/resume cycle causes wallpaper to refresh, loading a new desktop
356 // background that will animate in on top of the old one.
357 controller->CreateEmptyWallpaper();
358
359 // In this state we have two desktop background views stored in different
360 // properties. Both are in the lock screen background container.
361 internal::RootWindowController* root_window_controller =
362 Shell::GetPrimaryRootWindowController();
363 EXPECT_TRUE(root_window_controller->animating_wallpaper_controller()->
364 GetController(false));
365 EXPECT_TRUE(root_window_controller->wallpaper_controller());
366 EXPECT_EQ(0, ChildCountForContainer(kDesktopBackgroundId));
367 EXPECT_EQ(2, ChildCountForContainer(kLockScreenBackgroundId));
368
369 // Before the wallpaper's animation completes, user unlocks the screen, which
370 // moves the desktop to the back.
371 controller->MoveDesktopToUnlockedContainer();
372
373 // Ensure both desktop backgrounds have moved.
374 EXPECT_EQ(2, ChildCountForContainer(kDesktopBackgroundId));
375 EXPECT_EQ(0, ChildCountForContainer(kLockScreenBackgroundId));
376
377 // Finish the new desktop background animation.
378 RunDesktopControllerAnimation();
379
380 // Now there is one desktop background, in the back.
381 EXPECT_EQ(1, ChildCountForContainer(kDesktopBackgroundId));
382 EXPECT_EQ(0, ChildCountForContainer(kLockScreenBackgroundId));
383 }
384
385 // Test for crbug.com/156542. Animating wallpaper should immediately finish
386 // animation and replace current wallpaper before next animation starts.
TEST_F(DesktopBackgroundControllerTest,ChangeWallpaperQuick)387 TEST_F(DesktopBackgroundControllerTest, ChangeWallpaperQuick) {
388 // We cannot short-circuit animations for this test.
389 ui::ScopedAnimationDurationScaleMode normal_duration_mode(
390 ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION);
391
392 // Reset wallpaper state, see ControllerOwnership above.
393 DesktopBackgroundController* controller =
394 Shell::GetInstance()->desktop_background_controller();
395 controller->CreateEmptyWallpaper();
396
397 // Run wallpaper show animation to completion.
398 RunDesktopControllerAnimation();
399
400 // Change to a new wallpaper.
401 controller->CreateEmptyWallpaper();
402
403 internal::RootWindowController* root_window_controller =
404 Shell::GetPrimaryRootWindowController();
405 internal::DesktopBackgroundWidgetController* animating_controller =
406 root_window_controller->animating_wallpaper_controller()->
407 GetController(false);
408 EXPECT_TRUE(animating_controller);
409 EXPECT_TRUE(root_window_controller->wallpaper_controller());
410
411 // Change to another wallpaper before animation finished.
412 controller->CreateEmptyWallpaper();
413
414 // The animating controller should immediately move to desktop controller.
415 EXPECT_EQ(animating_controller,
416 root_window_controller->wallpaper_controller());
417
418 // Cache the new animating controller.
419 animating_controller = root_window_controller->
420 animating_wallpaper_controller()->GetController(false);
421
422 // Run wallpaper show animation to completion.
423 ASSERT_NO_FATAL_FAILURE(
424 RunAnimationForWidget(
425 root_window_controller->animating_wallpaper_controller()->
426 GetController(false)->widget()));
427
428 EXPECT_TRUE(root_window_controller->wallpaper_controller());
429 EXPECT_FALSE(root_window_controller->animating_wallpaper_controller()->
430 GetController(false));
431 // The desktop controller should be the last created animating controller.
432 EXPECT_EQ(animating_controller,
433 root_window_controller->wallpaper_controller());
434 }
435
TEST_F(DesktopBackgroundControllerTest,DisplayChange)436 TEST_F(DesktopBackgroundControllerTest, DisplayChange) {
437 // TODO(derat|oshima|bshe): Host windows can't be resized on Win8.
438 if (!SupportsHostWindowResize())
439 return;
440
441 // Set the wallpaper to ensure that UpdateWallpaper() will be called when the
442 // display configuration changes.
443 gfx::ImageSkia image = CreateImage(640, 480);
444 wallpaper_delegate_->set_custom_wallpaper(image);
445 controller_->SetCustomWallpaper(image, WALLPAPER_LAYOUT_STRETCH);
446
447 // Small wallpaper images should be used for configurations less than or
448 // equal to kSmallWallpaperMaxWidth by kSmallWallpaperMaxHeight, even if
449 // multiple displays are connected.
450 test::DisplayManagerTestApi display_manager_test_api(
451 Shell::GetInstance()->display_manager());
452 display_manager_test_api.UpdateDisplay("800x600");
453 RunAllPendingInMessageLoop();
454 EXPECT_EQ(WALLPAPER_RESOLUTION_SMALL,
455 controller_->GetAppropriateResolution());
456 EXPECT_EQ(0, wallpaper_delegate_->GetUpdateWallpaperCountAndReset());
457
458 display_manager_test_api.UpdateDisplay("800x600,800x600");
459 RunAllPendingInMessageLoop();
460 EXPECT_EQ(WALLPAPER_RESOLUTION_SMALL,
461 controller_->GetAppropriateResolution());
462 EXPECT_EQ(0, wallpaper_delegate_->GetUpdateWallpaperCountAndReset());
463
464 display_manager_test_api.UpdateDisplay("1366x800");
465 RunAllPendingInMessageLoop();
466 EXPECT_EQ(WALLPAPER_RESOLUTION_SMALL,
467 controller_->GetAppropriateResolution());
468 EXPECT_EQ(1, wallpaper_delegate_->GetUpdateWallpaperCountAndReset());
469
470 // At larger sizes, large wallpapers should be used.
471 display_manager_test_api.UpdateDisplay("1367x800");
472 RunAllPendingInMessageLoop();
473 EXPECT_EQ(WALLPAPER_RESOLUTION_LARGE,
474 controller_->GetAppropriateResolution());
475 EXPECT_EQ(1, wallpaper_delegate_->GetUpdateWallpaperCountAndReset());
476
477 display_manager_test_api.UpdateDisplay("1367x801");
478 RunAllPendingInMessageLoop();
479 EXPECT_EQ(WALLPAPER_RESOLUTION_LARGE,
480 controller_->GetAppropriateResolution());
481 EXPECT_EQ(1, wallpaper_delegate_->GetUpdateWallpaperCountAndReset());
482
483 display_manager_test_api.UpdateDisplay("2560x1700");
484 RunAllPendingInMessageLoop();
485 EXPECT_EQ(WALLPAPER_RESOLUTION_LARGE,
486 controller_->GetAppropriateResolution());
487 EXPECT_EQ(1, wallpaper_delegate_->GetUpdateWallpaperCountAndReset());
488
489 // Rotated smaller screen may use larger image.
490 display_manager_test_api.UpdateDisplay("800x600/r");
491 RunAllPendingInMessageLoop();
492 EXPECT_EQ(WALLPAPER_RESOLUTION_SMALL,
493 controller_->GetAppropriateResolution());
494 EXPECT_EQ(1, wallpaper_delegate_->GetUpdateWallpaperCountAndReset());
495
496 display_manager_test_api.UpdateDisplay("800x600/r,800x600");
497 RunAllPendingInMessageLoop();
498 EXPECT_EQ(WALLPAPER_RESOLUTION_SMALL,
499 controller_->GetAppropriateResolution());
500 EXPECT_EQ(1, wallpaper_delegate_->GetUpdateWallpaperCountAndReset());
501 display_manager_test_api.UpdateDisplay("1366x800/r");
502 RunAllPendingInMessageLoop();
503 EXPECT_EQ(WALLPAPER_RESOLUTION_LARGE,
504 controller_->GetAppropriateResolution());
505 EXPECT_EQ(1, wallpaper_delegate_->GetUpdateWallpaperCountAndReset());
506
507 // Max display size didn't chagne.
508 display_manager_test_api.UpdateDisplay("900x800/r,400x1366");
509 RunAllPendingInMessageLoop();
510 EXPECT_EQ(0, wallpaper_delegate_->GetUpdateWallpaperCountAndReset());
511 }
512
513 // Test that DesktopBackgroundController loads the appropriate wallpaper
514 // images as specified via command-line flags in various situations.
515 // Splitting these into separate tests avoids needing to run animations.
516 // TODO(derat): Combine these into a single test -- see
517 // RunDesktopControllerAnimation()'s TODO.
TEST_F(DesktopBackgroundControllerTest,SmallDefaultWallpaper)518 TEST_F(DesktopBackgroundControllerTest, SmallDefaultWallpaper) {
519 if (!SupportsMultipleDisplays())
520 return;
521
522 WriteWallpapersAndSetFlags();
523 TestObserver observer(controller_);
524
525 // At 800x600, the small wallpaper should be loaded.
526 test::DisplayManagerTestApi display_manager_test_api(
527 Shell::GetInstance()->display_manager());
528 display_manager_test_api.UpdateDisplay("800x600");
529 ASSERT_TRUE(controller_->SetDefaultWallpaper(false));
530 observer.WaitForWallpaperDataChanged();
531 EXPECT_TRUE(ImageIsNearColor(controller_->GetWallpaper(),
532 kSmallWallpaperColor));
533
534 // Requesting the same wallpaper again should be a no-op.
535 ASSERT_FALSE(controller_->SetDefaultWallpaper(false));
536 }
537
TEST_F(DesktopBackgroundControllerTest,LargeDefaultWallpaper)538 TEST_F(DesktopBackgroundControllerTest, LargeDefaultWallpaper) {
539 if (!SupportsMultipleDisplays())
540 return;
541
542 WriteWallpapersAndSetFlags();
543 TestObserver observer(controller_);
544 test::DisplayManagerTestApi display_manager_test_api(
545 Shell::GetInstance()->display_manager());
546 display_manager_test_api.UpdateDisplay("1600x1200");
547 ASSERT_TRUE(controller_->SetDefaultWallpaper(false));
548 observer.WaitForWallpaperDataChanged();
549 EXPECT_TRUE(ImageIsNearColor(controller_->GetWallpaper(),
550 kLargeWallpaperColor));
551 }
552
TEST_F(DesktopBackgroundControllerTest,LargeDefaultWallpaperWhenRotated)553 TEST_F(DesktopBackgroundControllerTest, LargeDefaultWallpaperWhenRotated) {
554 if (!SupportsMultipleDisplays())
555 return;
556 WriteWallpapersAndSetFlags();
557 TestObserver observer(controller_);
558 test::DisplayManagerTestApi display_manager_test_api(
559 Shell::GetInstance()->display_manager());
560
561 display_manager_test_api.UpdateDisplay("1200x800/r");
562 ASSERT_TRUE(controller_->SetDefaultWallpaper(false));
563 observer.WaitForWallpaperDataChanged();
564 EXPECT_TRUE(ImageIsNearColor(controller_->GetWallpaper(),
565 kLargeWallpaperColor));
566 }
567
TEST_F(DesktopBackgroundControllerTest,SmallGuestWallpaper)568 TEST_F(DesktopBackgroundControllerTest, SmallGuestWallpaper) {
569 if (!SupportsMultipleDisplays())
570 return;
571
572 WriteWallpapersAndSetFlags();
573 TestObserver observer(controller_);
574 test::DisplayManagerTestApi display_manager_test_api(
575 Shell::GetInstance()->display_manager());
576 display_manager_test_api.UpdateDisplay("800x600");
577 ASSERT_TRUE(controller_->SetDefaultWallpaper(true));
578 observer.WaitForWallpaperDataChanged();
579 EXPECT_TRUE(ImageIsNearColor(controller_->GetWallpaper(),
580 kSmallGuestWallpaperColor));
581 }
582
TEST_F(DesktopBackgroundControllerTest,LargeGuestWallpaper)583 TEST_F(DesktopBackgroundControllerTest, LargeGuestWallpaper) {
584 if (!SupportsMultipleDisplays())
585 return;
586
587 WriteWallpapersAndSetFlags();
588 TestObserver observer(controller_);
589 test::DisplayManagerTestApi display_manager_test_api(
590 Shell::GetInstance()->display_manager());
591 display_manager_test_api.UpdateDisplay("1600x1200");
592 ASSERT_TRUE(controller_->SetDefaultWallpaper(true));
593 observer.WaitForWallpaperDataChanged();
594 EXPECT_TRUE(ImageIsNearColor(controller_->GetWallpaper(),
595 kLargeGuestWallpaperColor));
596 }
597
TEST_F(DesktopBackgroundControllerTest,ResizeCustomWallpaper)598 TEST_F(DesktopBackgroundControllerTest, ResizeCustomWallpaper) {
599 if (!SupportsMultipleDisplays())
600 return;
601
602 test::DisplayManagerTestApi display_manager_test_api(
603 Shell::GetInstance()->display_manager());
604 display_manager_test_api.UpdateDisplay("320x200");
605
606 gfx::ImageSkia image = CreateImage(640, 480);
607
608 // Set the image as custom wallpaper, wait for the resize to finish, and check
609 // that the resized image is the expected size.
610 controller_->SetCustomWallpaper(image, WALLPAPER_LAYOUT_STRETCH);
611 EXPECT_TRUE(image.BackedBySameObjectAs(controller_->GetWallpaper()));
612 content::BrowserThread::GetBlockingPool()->FlushForTesting();
613 content::RunAllPendingInMessageLoop();
614 gfx::ImageSkia resized_image = controller_->GetWallpaper();
615 EXPECT_FALSE(image.BackedBySameObjectAs(resized_image));
616 EXPECT_EQ(gfx::Size(320, 200).ToString(), resized_image.size().ToString());
617
618 // Load the original wallpaper again and check that we're still using the
619 // previously-resized image instead of doing another resize
620 // (http://crbug.com/321402).
621 controller_->SetCustomWallpaper(image, WALLPAPER_LAYOUT_STRETCH);
622 content::BrowserThread::GetBlockingPool()->FlushForTesting();
623 content::RunAllPendingInMessageLoop();
624 EXPECT_TRUE(resized_image.BackedBySameObjectAs(controller_->GetWallpaper()));
625 }
626
TEST_F(DesktopBackgroundControllerTest,GetMaxDisplaySize)627 TEST_F(DesktopBackgroundControllerTest, GetMaxDisplaySize) {
628 // Device scale factor shouldn't affect the native size.
629 UpdateDisplay("1000x300*2");
630 EXPECT_EQ(
631 "1000x300",
632 DesktopBackgroundController::GetMaxDisplaySizeInNative().ToString());
633
634 // Rotated display should return the rotated size.
635 UpdateDisplay("1000x300*2/r");
636 EXPECT_EQ(
637 "300x1000",
638 DesktopBackgroundController::GetMaxDisplaySizeInNative().ToString());
639
640 // UI Scaling shouldn't affect the native size.
641 UpdateDisplay("1000x300*2@1.5");
642 EXPECT_EQ(
643 "1000x300",
644 DesktopBackgroundController::GetMaxDisplaySizeInNative().ToString());
645
646 if (!SupportsMultipleDisplays())
647 return;
648
649 // First display has maximum size.
650 UpdateDisplay("400x300,100x100");
651 EXPECT_EQ(
652 "400x300",
653 DesktopBackgroundController::GetMaxDisplaySizeInNative().ToString());
654
655 // Second display has maximum size.
656 UpdateDisplay("400x300,500x600");
657 EXPECT_EQ(
658 "500x600",
659 DesktopBackgroundController::GetMaxDisplaySizeInNative().ToString());
660
661 // Maximum width and height belongs to different displays.
662 UpdateDisplay("400x300,100x500");
663 EXPECT_EQ(
664 "400x500",
665 DesktopBackgroundController::GetMaxDisplaySizeInNative().ToString());
666 }
667
668 } // namespace ash
669