Move all wallpaper file loading and decoding from DesktopBackgroundController to WallpaperManager.

chrome/browser/chromeos/login/wallpaper_manager_browsertest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/login/wallpaper_manager.h"
 
 #include "ash/ash_resources/grit/ash_resources.h"
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/desktop_background/desktop_background_controller_observer.h"
 #include "ash/display/display_manager.h"
 #include "ash/shell.h"
+#include "ash/test/ash_test_base.h"
 #include "ash/test/display_manager_test_api.h"
+#include "ash/test/test_user_wallpaper_delegate.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/login/user.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "content/public/test/test_utils.h"
 #include "ui/aura/env.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/gfx/codec/jpeg_codec.h"
+#include "ui/gfx/point.h"
+#include "ui/gfx/rect.h"
 
 using namespace ash;
 
 namespace chromeos {
 
 namespace {
 
 const int kLargeWallpaperResourceId = IDR_AURA_WALLPAPER_DEFAULT_LARGE;
 const int kSmallWallpaperResourceId = IDR_AURA_WALLPAPER_DEFAULT_SMALL;
 
 int kLargeWallpaperWidth = 256;
-int kLargeWallpaperHeight = ash::kLargeWallpaperMaxHeight;
+int kLargeWallpaperHeight = chromeos::kLargeWallpaperMaxHeight;
 int kSmallWallpaperWidth = 256;
-int kSmallWallpaperHeight = ash::kSmallWallpaperMaxHeight;
+int kSmallWallpaperHeight = chromeos::kSmallWallpaperMaxHeight;
 
 const char kTestUser1[] = "test1@domain.com";
 const char kTestUser1Hash[] = "test1@domain.com-hash";
 const char kTestUser2[] = "test2@domain.com";
 const char kTestUser2Hash[] = "test2@domain.com-hash";
 
 }  // namespace
 
 class WallpaperManagerBrowserTest : public InProcessBrowserTest,
-                                    public DesktopBackgroundControllerObserver,
                                     public testing::WithParamInterface<bool> {
  public:
   WallpaperManagerBrowserTest () : controller_(NULL),
                                    local_state_(NULL) {
   }
 
   virtual ~WallpaperManagerBrowserTest () {}
 
   virtual void SetUpOnMainThread() OVERRIDE {
     controller_ = ash::Shell::GetInstance()->desktop_background_controller();
-    controller_->AddObserver(this);
     local_state_ = g_browser_process->local_state();
     UpdateDisplay("800x600");
   }
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     command_line->AppendSwitch(switches::kLoginManager);
     command_line->AppendSwitchASCII(switches::kLoginProfile, "user");
     if (GetParam())
       command_line->AppendSwitch(::switches::kMultiProfiles);
   }
 
   virtual void CleanUpOnMainThread() OVERRIDE {
-    controller_->RemoveObserver(this);
     controller_ = NULL;
   }
 
   // Update the display configuration as given in |display_specs|.  See
   // ash::test::DisplayManagerTestApi::UpdateDisplay for more details.
   void UpdateDisplay(const std::string& display_specs) {
     ash::test::DisplayManagerTestApi display_manager_test_api(
         ash::Shell::GetInstance()->display_manager());
     display_manager_test_api.UpdateDisplay(display_specs);
   }
 
   void WaitAsyncWallpaperLoadStarted() {
     base::MessageLoop::current()->RunUntilIdle();
   }
 
   void WaitAsyncWallpaperLoadFinished() {
     base::MessageLoop::current()->RunUntilIdle();
     while (WallpaperManager::Get()->loading_.size()) {
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
       base::MessageLoop::current()->RunUntilIdle();
     }
   }
 
-  virtual void OnWallpaperDataChanged() OVERRIDE {
-    base::MessageLoop::current()->Quit();
-  }
+ protected:
+  // Colors used for different default wallpapers by
+  // WriteWallpapers().
+  static const SkColor kLargeWallpaperColor = SK_ColorRED;
+  static const SkColor kSmallWallpaperColor = SK_ColorGREEN;
+  static const SkColor kLargeGuestWallpaperColor = SK_ColorBLUE;
+  static const SkColor kSmallGuestWallpaperColor = SK_ColorYELLOW;
 
- protected:
+  // A color that can be passed to CreateImage(). Specifically chosen to not
+  // conflict with any of the default wallpaper colors.
+  static const SkColor kCustomWallpaperColor = SK_ColorMAGENTA;
+
+  // Dimension used for width and height of default wallpaper images. A
+  // small value is used to minimize the amount of time spent compressing
+  // and writing images.
+  static const int kWallpaperSize = 2;
+
   // Return custom wallpaper path. Create directory if not exist.
   base::FilePath GetCustomWallpaperPath(const char* sub_dir,
                                         const std::string& username_hash,
                                         const std::string& id) {
     base::FilePath wallpaper_path =
         WallpaperManager::Get()->GetCustomWallpaperPath(sub_dir,
                                                         username_hash,
                                                         id);
     if (!base::DirectoryExists(wallpaper_path.DirName()))
       base::CreateDirectory(wallpaper_path.DirName());
@@ skipping 17 matching lines @@
         wallpaper_path,
         reinterpret_cast<const char*>(image_data->front()),
         image_data->size());
     EXPECT_EQ(static_cast<int>(image_data->size()), written);
   }
 
   int LoadedWallpapers() {
     return WallpaperManager::Get()->loaded_wallpapers();
   }
 
+  // Creates a test image of size 1x1.
+  gfx::ImageSkia CreateTestImage(int width, int height, SkColor color) {
+    SkBitmap bitmap;
+    bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
+    bitmap.allocPixels();
+    bitmap.eraseColor(color);
+    return gfx::ImageSkia::CreateFrom1xBitmap(bitmap);
+  }
+
+  // Writes a JPEG image of the specified size and color to |path|. Returns
+  // true on success.
+  bool WriteJPEGFile(const base::FilePath& path,
+                     int width,
+                     int height,
+                     SkColor color) {
+    SkBitmap bitmap;
+    bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height, 0);
+    bitmap.allocPixels();
+    bitmap.eraseColor(color);
+
+    const int kQuality = 80;
+    std::vector<unsigned char> output;
+    if (!gfx::JPEGCodec::Encode(
+            static_cast<const unsigned char*>(bitmap.getPixels()),
+            gfx::JPEGCodec::FORMAT_SkBitmap,
+            width,
+            height,
+            bitmap.rowBytes(),
+            kQuality,
+            &output)) {
+      LOG(ERROR) << "Unable to encode " << width << "x" << height << " bitmap";
+      return false;
+    }
+
+    size_t bytes_written = base::WriteFile(
+        path, reinterpret_cast<const char*>(&output[0]), output.size());
+    if (bytes_written != output.size()) {
+      LOG(ERROR) << "Wrote " << bytes_written << " byte(s) instead of "
+                 << output.size() << " to " << path.value();
+      return false;
+    }
+
+    return true;
+  }
+
+  // Initializes default wallpaper paths "*default_*file" and writes JPEG
+  // wallpaper images to them.
+  // Only needs to be called (once) by tests that want to test loading of
+  // default wallpapers.
+  void WriteWallpapers() {
+    wallpaper_dir_.reset(new base::ScopedTempDir);
+    ASSERT_TRUE(wallpaper_dir_->CreateUniqueTempDir());
+
+    const base::FilePath small_file =
+        wallpaper_dir_->path().Append(FILE_PATH_LITERAL("small.jpg"));
+    const base::FilePath large_file =
+        wallpaper_dir_->path().Append(FILE_PATH_LITERAL("large.jpg"));
+    const base::FilePath guest_small_file =
+        wallpaper_dir_->path().Append(FILE_PATH_LITERAL("guest_small.jpg"));
+    const base::FilePath guest_large_file =
+        wallpaper_dir_->path().Append(FILE_PATH_LITERAL("guest_large.jpg"));
+    WallpaperManager::Get()->default_small_wallpaper_file_ = small_file;
+    WallpaperManager::Get()->default_large_wallpaper_file_ = large_file;
+    WallpaperManager::Get()->guest_small_wallpaper_file_ = guest_small_file;
+    WallpaperManager::Get()->guest_large_wallpaper_file_ = guest_large_file;
+    WallpaperManager::Get()->default_wallpaper_image_.reset();

[Daniel Erat, 2014/04/04 02:45:49]

please pass a command line with the appropriate flags into WallpaperManager
instead of making the test modify the class's private members directly

[Alexander Alekseev, 2014/04/05 03:35:13]

Done.

+
+    ASSERT_TRUE(WriteJPEGFile(small_file,
+                              kWallpaperSize,
+                              kWallpaperSize,
+                              kSmallWallpaperColor));
+    ASSERT_TRUE(WriteJPEGFile(large_file,
+                              kWallpaperSize,
+                              kWallpaperSize,
+                              kLargeWallpaperColor));
+    ASSERT_TRUE(WriteJPEGFile(guest_small_file,
+                              kWallpaperSize,
+                              kWallpaperSize,
+                              kSmallGuestWallpaperColor));
+    ASSERT_TRUE(WriteJPEGFile(guest_large_file,
+                              kWallpaperSize,
+                              kWallpaperSize,
+                              kLargeGuestWallpaperColor));
+  }
+
+  // Returns true if the color at the center of |image| is close to
+  // |expected_color|. (The center is used so small wallpaper images can be
+  // used.)
+  bool ImageIsNearColor(gfx::ImageSkia image, SkColor expected_color) {
+    if (image.size().IsEmpty()) {
+      LOG(ERROR) << "Image is empty";
+      return false;
+    }
+
+    const SkBitmap* bitmap = image.bitmap();
+    if (!bitmap) {
+      LOG(ERROR) << "Unable to get bitmap from image";
+      return false;
+    }
+
+    bitmap->lockPixels();
+    gfx::Point center = gfx::Rect(image.size()).CenterPoint();
+    SkColor image_color = bitmap->getColor(center.x(), center.y());
+    bitmap->unlockPixels();
+
+    const int kDiff = 3;
+    if (std::abs(static_cast<int>(SkColorGetA(image_color)) -
+                 static_cast<int>(SkColorGetA(expected_color))) > kDiff ||
+        std::abs(static_cast<int>(SkColorGetR(image_color)) -
+                 static_cast<int>(SkColorGetR(expected_color))) > kDiff ||
+        std::abs(static_cast<int>(SkColorGetG(image_color)) -
+                 static_cast<int>(SkColorGetG(expected_color))) > kDiff ||
+        std::abs(static_cast<int>(SkColorGetB(image_color)) -
+                 static_cast<int>(SkColorGetB(expected_color))) > kDiff) {
+      LOG(ERROR) << "Expected color near 0x" << std::hex << expected_color
+                 << " but got 0x" << image_color;
+      return false;
+    }
+
+    return true;
+  }
+
   DesktopBackgroundController* controller_;
   PrefService* local_state_;
 
+  // Directory created by WriteWallpapersAndSetFlags() to store default
+  // wallpaper images.
+  scoped_ptr<base::ScopedTempDir> wallpaper_dir_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(WallpaperManagerBrowserTest);
 };
 
 // Tests that the appropriate custom wallpaper (large vs. small) is loaded
 // depending on the desktop resolution.
 IN_PROC_BROWSER_TEST_P(WallpaperManagerBrowserTest,
                        LoadCustomLargeWallpaperForLargeExternalScreen) {
   WallpaperManager* wallpaper_manager = WallpaperManager::Get();
   LogIn(kTestUser1, kTestUser1Hash);
@@ skipping 29 matching lines @@
   WaitAsyncWallpaperLoadFinished();
   gfx::ImageSkia wallpaper = controller_->GetWallpaper();
 
   // Display is initialized to 800x600. The small resolution custom wallpaper is
   // expected.
   EXPECT_EQ(kSmallWallpaperWidth, wallpaper.width());
   EXPECT_EQ(kSmallWallpaperHeight, wallpaper.height());
 
   // Hook up another 800x600 display. This shouldn't trigger a reload.
   UpdateDisplay("800x600,800x600");
-  content::RunAllPendingInMessageLoop();
+  WaitAsyncWallpaperLoadFinished();
   // The small resolution custom wallpaper is expected.
   EXPECT_EQ(kSmallWallpaperWidth, wallpaper.width());
   EXPECT_EQ(kSmallWallpaperHeight, wallpaper.height());
 
   // Detach the secondary display.
   UpdateDisplay("800x600");
   // Hook up a 2000x2000 display. The large resolution custom wallpaper should
   // be loaded.
   UpdateDisplay("800x600,2000x2000");
   WaitAsyncWallpaperLoadFinished();
@@ skipping 354 matching lines @@
                         testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(WallpaperManagerBrowserTestCrashRestoreInstantiation,
                         WallpaperManagerBrowserTestCrashRestore,
                         testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(WallpaperManagerBrowserTestCacheUpdateInstantiation,
                         WallpaperManagerBrowserTestCacheUpdate,
                         testing::Bool());
 
+// ----------------------------------------------------------------------
+// Test default wallpapers.
+
+class AshTestBaseAdapter : public ash::test::AshTestBase {

[Daniel Erat, 2014/04/04 02:45:49]

this seems a bit strange. are the AshTestBase methods that you're calling
protected static members or something like that? could you make them be public
instead?

[Alexander Alekseev, 2014/04/05 03:35:13]

Done.

+ public:
+  static bool SupportsMultipleDisplays() {
+    return ash::test::AshTestBase::SupportsMultipleDisplays();
+  }
+
+  static bool SupportsHostWindowResize() {
+    return ash::test::AshTestBase::SupportsHostWindowResize();
+  }
+};
+
+class TestObserver : public WallpaperManager::Observer {
+ public:
+  explicit TestObserver(WallpaperManager* wallpaper_manager)
+      : update_wallpaper_count_(0), wallpaper_manager_(wallpaper_manager) {
+    DCHECK(wallpaper_manager_);
+    wallpaper_manager_->AddObserver(this);
+    LOG(ERROR) << "TestObserver: Created.";
+  }
+
+  virtual ~TestObserver() {
+    wallpaper_manager_->RemoveObserver(this);
+  }
+
+  virtual void OnWallpaperAnimationFinished(const std::string&) {
+  }
+
+  virtual void OnUpdateWallpaperForTesting() OVERRIDE {
+    LOG(ERROR) << "TestObserver::OnUpdateWallpaperForTesting() called.";
+    ++update_wallpaper_count_;
+  }
+
+  int GetUpdateWallpaperCountAndReset() {
+    const size_t old = update_wallpaper_count_;
+    update_wallpaper_count_ = 0;
+    return old;
+  }
+
+ private:
+  int update_wallpaper_count_;
+  WallpaperManager* wallpaper_manager_;
+};
+
+IN_PROC_BROWSER_TEST_P(WallpaperManagerBrowserTest, DisplayChange) {
+  // TODO(derat|oshima|bshe): Host windows can't be resized on Win8.
+  if (!chromeos::AshTestBaseAdapter::SupportsHostWindowResize)
+    return;
+
+  TestObserver observer(WallpaperManager::Get());
+
+  // Set the wallpaper to ensure that UpdateWallpaper() will be called when the
+  // display configuration changes.
+  gfx::ImageSkia image = CreateTestImage(640, 480, kCustomWallpaperColor);
+  controller_->SetWallpaper(image, WALLPAPER_LAYOUT_STRETCH);
+
+  // Small wallpaper images should be used for configurations less than or
+  // equal to kSmallWallpaperMaxWidth by kSmallWallpaperMaxHeight, even if
+  // multiple displays are connected.
+  UpdateDisplay("800x600");
+  WaitAsyncWallpaperLoadFinished();
+  EXPECT_EQ(WallpaperManager::WALLPAPER_RESOLUTION_SMALL,
+            WallpaperManager::Get()->GetAppropriateResolution());
+  EXPECT_EQ(0, observer.GetUpdateWallpaperCountAndReset());
+
+  UpdateDisplay("800x600,800x600");
+  WaitAsyncWallpaperLoadFinished();
+  EXPECT_EQ(WallpaperManager::WALLPAPER_RESOLUTION_SMALL,
+            WallpaperManager::Get()->GetAppropriateResolution());
+  EXPECT_EQ(0, observer.GetUpdateWallpaperCountAndReset());
+
+  UpdateDisplay("1366x800");
+  WaitAsyncWallpaperLoadFinished();
+  EXPECT_EQ(WallpaperManager::WALLPAPER_RESOLUTION_SMALL,
+            WallpaperManager::Get()->GetAppropriateResolution());
+  EXPECT_EQ(1, observer.GetUpdateWallpaperCountAndReset());

[Alexander Alekseev, 2014/04/03 19:15:45]

This check fails because UpdateWallpaper() doesn't happen here.

[Daniel Erat, 2014/04/04 02:45:49]

presumably the changes that UpdateDisplay() does don't make it back to
WallpaperManager. i think that this usually goes through
DesktopBackgroundController::OnDisplayConfigurationChanged(), but i don't think
that there's much of a reason for DBC to be observing these changes -- all it
does is call
ash::Shell::GetInstance()->user_wallpaper_delegate()->UpdateWallpaper(), right?

would it be possible to make WallpaperManager be a
ash::DisplayController::Observer instead of DBC? i'm not sure what the right
approach should be for DesktopBackgroundController::OnRootWindowAdded, though.

[Alexander Alekseev, 2014/04/05 03:35:13]

The problem is (probably) with UpdateDisplay.
DBC::::OnDisplayConfigurationChanged() is analyzing display size, but as I've
mentioned below, GetMaxDisplaySizeInNative() returns incorrect display size.
Why?

[Daniel Erat, 2014/04/07 13:57:00]

maybe oshima has some ideas about this.

[oshima, 2014/04/07 17:16:11]

Let me look into this. It's hard to tell just by looking at the code.

[oshima, 2014/04/07 19:02:28]

The failure was due to missing 

DesktopBackgroundController::set_wallpaper_reload_delay_for_test(0)  (see
DesktopBackgroundControllerTest::SetUp

[Alexander Alekseev, 2014/04/08 13:18:49]

This helps only partially, here is my debug:


[ RUN      ]
WallpaperManagerBrowserTestInstantiation/WallpaperManagerBrowserTest.DisplayChange/0
[22965:22965:0408/165937:WARNING:profile_io_data.cc(366)] no username_hash
[22965:22965:0408/165937:WARNING:profile_io_data.cc(366)] no username_hash
[22994:22994:0408/125937:WARNING:sandbox_linux.cc(56)] Activated seccomp-bpf
sandbox for process type: gpu-process.
[22965:22965:0408/165937:ERROR:wallpaper_manager_browsertest.cc(95)]
UpdateDisplay(800x600) called.
[22965:22965:0408/165937:ERROR:wallpaper_manager_browsertest.cc(95)]
UpdateDisplay(800x600) called.
[22965:22965:0408/165937:ERROR:wallpaper_manager.cc(661)]
GetAppropriateResolution(: width=800 vs kSmallWallpaperMaxWidth=1366, height=600
vs kSmallWallpaperMaxHeight = 800
[22965:22965:0408/165937:ERROR:wallpaper_manager_browsertest.cc(95)]
UpdateDisplay(800x600,800x600) called.
[22965:22965:0408/165937:ERROR:wallpaper_manager.cc(661)]
GetAppropriateResolution(: width=800 vs kSmallWallpaperMaxWidth=1366, height=600
vs kSmallWallpaperMaxHeight = 800
[22965:22965:0408/165937:ERROR:wallpaper_manager_browsertest.cc(95)]
UpdateDisplay(1366x800) called.
[22965:22965:0408/165937:ERROR:wallpaper_manager.cc(661)]
GetAppropriateResolution(: width=1366 vs kSmallWallpaperMaxWidth=1366,
height=800 vs kSmallWallpaperMaxHeight = 800
[22965:22965:0408/165937:ERROR:wallpaper_manager.cc(661)]
GetAppropriateResolution(: width=1366 vs kSmallWallpaperMaxWidth=1366,
height=800 vs kSmallWallpaperMaxHeight = 800
[22965:22965:0408/165937:ERROR:wallpaper_manager_browsertest.cc(95)]
UpdateDisplay(1367x800) called.
[22965:22965:0408/165937:ERROR:wallpaper_manager.cc(661)]
GetAppropriateResolution(: width=1367 vs kSmallWallpaperMaxWidth=1366,
height=800 vs kSmallWallpaperMaxHeight = 800
[22965:22965:0408/165937:ERROR:wallpaper_manager.cc(661)]
GetAppropriateResolution(: width=1367 vs kSmallWallpaperMaxWidth=1366,
height=800 vs kSmallWallpaperMaxHeight = 800
[22965:22965:0408/165937:ERROR:wallpaper_manager_browsertest.cc(95)]
UpdateDisplay(1367x801) called.
[22965:22965:0408/165937:ERROR:wallpaper_manager.cc(661)]
GetAppropriateResolution(: width=1367 vs kSmallWallpaperMaxWidth=1366,
height=801 vs kSmallWallpaperMaxHeight = 800
[22965:22965:0408/165937:ERROR:wallpaper_manager.cc(661)]
GetAppropriateResolution(: width=1367 vs kSmallWallpaperMaxWidth=1366,
height=801 vs kSmallWallpaperMaxHeight = 800
[22965:22965:0408/165937:ERROR:wallpaper_manager_browsertest.cc(95)]
UpdateDisplay(2560x1700) called.
[22965:22965:0408/165937:ERROR:wallpaper_manager.cc(661)]
GetAppropriateResolution(: width=2493 vs kSmallWallpaperMaxWidth=1366,
height=1547 vs kSmallWallpaperMaxHeight = 800
[22965:22965:0408/165937:ERROR:wallpaper_manager.cc(661)]
GetAppropriateResolution(: width=2493 vs kSmallWallpaperMaxWidth=1366,
height=1547 vs kSmallWallpaperMaxHeight = 800
[22965:22965:0408/165937:ERROR:wallpaper_manager_browsertest.cc(95)]
UpdateDisplay(800x600/r) called.
[22965:22965:0408/165937:ERROR:wallpaper_manager.cc(661)]
GetAppropriateResolution(: width=600 vs kSmallWallpaperMaxWidth=1366, height=800
vs kSmallWallpaperMaxHeight = 800
[22965:22965:0408/165937:ERROR:wallpaper_manager.cc(661)]
GetAppropriateResolution(: width=600 vs kSmallWallpaperMaxWidth=1366, height=800
vs kSmallWallpaperMaxHeight = 800
[22965:22965:0408/165937:ERROR:wallpaper_manager_browsertest.cc(95)]
UpdateDisplay(800x600/r,800x600) called.
[22965:22965:0408/165937:ERROR:wallpaper_manager.cc(661)]
GetAppropriateResolution(: width=1576 vs kSmallWallpaperMaxWidth=1366,
height=2495 vs kSmallWallpaperMaxHeight = 800
[22965:22965:0408/165937:ERROR:wallpaper_manager.cc(661)]
GetAppropriateResolution(: width=1576 vs kSmallWallpaperMaxWidth=1366,
height=2495 vs kSmallWallpaperMaxHeight = 800
../../chrome/browser/chromeos/login/wallpaper_manager_browsertest.cc:835:
Failure
Value of: WallpaperManager::Get()->GetAppropriateResolution()
  Actual: 0
Expected: WallpaperManager::WALLPAPER_RESOLUTION_SMALL
Which is: 1
[22965:22965:0408/165937:ERROR:wallpaper_manager_browsertest.cc(95)]
UpdateDisplay(1366x800/r) called.
[22965:22965:0408/165937:ERROR:wallpaper_manager.cc(661)]
GetAppropriateResolution(: width=1576 vs kSmallWallpaperMaxWidth=1366,
height=2495 vs kSmallWallpaperMaxHeight = 800
[22965:22965:0408/165937:ERROR:wallpaper_manager.cc(661)]
GetAppropriateResolution(: width=1576 vs kSmallWallpaperMaxWidth=1366,
height=2495 vs kSmallWallpaperMaxHeight = 800
[22965:22965:0408/165937:ERROR:wallpaper_manager_browsertest.cc(95)]
UpdateDisplay(900x800/r,400x1366) called.
[22965:22965:0408/165937:ERROR:wallpaper_manager.cc(661)]
GetAppropriateResolution(: width=1576 vs kSmallWallpaperMaxWidth=1366,
height=2495 vs kSmallWallpaperMaxHeight = 800
../../chrome/browser/chromeos/login/wallpaper_manager_browsertest.cc:846:
Failure
Value of: observer.GetUpdateWallpaperCountAndReset()
  Actual: 1
Expected: 0
[  FAILED  ]
WallpaperManagerBrowserTestInstantiation/WallpaperManagerBrowserTest.DisplayChange/0,
where GetParam() = false (1058 ms)

[Alexander Alekseev, 2014/04/08 13:32:31]

The same debug in a more compact format:

UpdateDisplay(800x600) called.                                                  

UpdateDisplay(800x600) called.                                                  

GetAppropriateResolution: width=800, height=600                                 

UpdateDisplay(800x600,800x600) called.                                          

GetAppropriateResolution: width=800, height=600                                 

UpdateDisplay(1366x800) called.                                                 

GetAppropriateResolution: width=1366, height=800                                

GetAppropriateResolution: width=1366, height=800                                

UpdateDisplay(1367x800) called.                                                 

GetAppropriateResolution: width=1367, height=800                                

GetAppropriateResolution: width=1367, height=800                                

UpdateDisplay(1367x801) called.                                                 

GetAppropriateResolution: width=1367, height=801                                

GetAppropriateResolution: width=1367, height=801                                

UpdateDisplay(2560x1700) called.                                                

GetAppropriateResolution: width=2493, height=1547                               

GetAppropriateResolution: width=2493, height=1547                               

UpdateDisplay(800x600/r) called.                                                

GetAppropriateResolution: width=600, height=800                                 

GetAppropriateResolution: width=600, height=800                                 

UpdateDisplay(800x600/r,800x600) called.                                        

GetAppropriateResolution: width=1576, height=2495                               

GetAppropriateResolution: width=1576, height=2495                               

../../chrome/browser/chromeos/login/wallpaper_manager_browsertest.cc:835:
Failure
Value of: WallpaperManager::Get()->GetAppropriateResolution)                    

  Actual: 0                                                                     

Expected: WallpaperManager::WALLPAPER_RESOLUTION_SMALL                          

Which is: 1                                                                     

UpdateDisplay(1366x800/r) called.                                               

GetAppropriateResolution: width=1576, height=2495                               

GetAppropriateResolution: width=1576, height=2495                               

UpdateDisplay(900x800/r,400x1366) called.                                       

GetAppropriateResolution: width=1576, height=2495                               

+
+  // At larger sizes, large wallpapers should be used.
+  UpdateDisplay("1367x800");
+  WaitAsyncWallpaperLoadFinished();
+  EXPECT_EQ(WallpaperManager::WALLPAPER_RESOLUTION_LARGE,
+            WallpaperManager::Get()->GetAppropriateResolution());
+  EXPECT_EQ(1, observer.GetUpdateWallpaperCountAndReset());

[Alexander Alekseev, 2014/04/03 19:15:45]

This check fails because UpdateWallpaper() doesn't happen here.

+
+  UpdateDisplay("1367x801");
+  WaitAsyncWallpaperLoadFinished();
+  EXPECT_EQ(WallpaperManager::WALLPAPER_RESOLUTION_LARGE,
+            WallpaperManager::Get()->GetAppropriateResolution());
+  EXPECT_EQ(1, observer.GetUpdateWallpaperCountAndReset());

[Alexander Alekseev, 2014/04/03 19:15:45]

This check fails because UpdateWallpaper() doesn't happen here.

+
+  UpdateDisplay("2560x1700");
+  WaitAsyncWallpaperLoadFinished();
+  EXPECT_EQ(WallpaperManager::WALLPAPER_RESOLUTION_LARGE,
+            WallpaperManager::Get()->GetAppropriateResolution());
+  EXPECT_EQ(1, observer.GetUpdateWallpaperCountAndReset());

[Alexander Alekseev, 2014/04/03 19:15:45]

This check fails because UpdateWallpaper() doesn't happen here.

+
+  // Rotated smaller screen may use larger image.
+  UpdateDisplay("800x600/r");
+  WaitAsyncWallpaperLoadFinished();
+  EXPECT_EQ(WallpaperManager::WALLPAPER_RESOLUTION_SMALL,
+            WallpaperManager::Get()->GetAppropriateResolution());

[Alexander Alekseev, 2014/04/03 19:15:45]

This check fails because:

[wallpaper_manager.cc(663)] GetAppropriateResolution(): Actual
MaxSize.width()=1576 vs kMaxWidth=1366, MaxSize.height()=2495 vs kMaxHeight=800

I do not know why GetAppropriateResolution() here returns these values.

+  EXPECT_EQ(1, observer.GetUpdateWallpaperCountAndReset());

[Alexander Alekseev, 2014/04/03 19:15:45]

This check fails because UpdateWallpaper() doesn't happen here.

+
+  UpdateDisplay("800x600/r,800x600");
+  WaitAsyncWallpaperLoadFinished();
+  EXPECT_EQ(WallpaperManager::WALLPAPER_RESOLUTION_SMALL,
+            WallpaperManager::Get()->GetAppropriateResolution());

[Alexander Alekseev, 2014/04/03 19:15:45]

This check fails because:

[wallpaper_manager.cc(663)] GetAppropriateResolution(): MaxSize.width()=1576 vs
kMaxWidth=1366, MaxSize.height()=2495 vs kMaxHeight=800

+  EXPECT_EQ(1, observer.GetUpdateWallpaperCountAndReset());
+  UpdateDisplay("1366x800/r");
+  WaitAsyncWallpaperLoadFinished();
+  EXPECT_EQ(WallpaperManager::WALLPAPER_RESOLUTION_LARGE,
+            WallpaperManager::Get()->GetAppropriateResolution());
+  EXPECT_EQ(1, observer.GetUpdateWallpaperCountAndReset());

[Alexander Alekseev, 2014/04/03 19:15:45]

This check fails because UpdateWallpaper() doesn't happen here.

+
+  // Max display size didn't chagne.
+  UpdateDisplay("900x800/r,400x1366");
+  WaitAsyncWallpaperLoadFinished();
+  EXPECT_EQ(0, observer.GetUpdateWallpaperCountAndReset());
+}
+
+// Test that WallpaperManager loads the appropriate wallpaper
+// images as specified via command-line flags in various situations.
+// Splitting these into separate tests avoids needing to run animations.
+// TODO(derat): Combine these into a single test
+IN_PROC_BROWSER_TEST_P(WallpaperManagerBrowserTest, SmallDefaultWallpaper) {
+  if (!chromeos::AshTestBaseAdapter::SupportsMultipleDisplays())
+    return;
+
+  WriteWallpapers();
+
+  // At 800x600, the small wallpaper should be loaded.
+  UpdateDisplay("800x600");
+  WallpaperManager::Get()->SetDefaultWallpaperNow(std::string());
+  WaitAsyncWallpaperLoadFinished();
+  EXPECT_TRUE(
+      ImageIsNearColor(controller_->GetWallpaper(), kSmallWallpaperColor));
+}
+
+IN_PROC_BROWSER_TEST_P(WallpaperManagerBrowserTest, LargeDefaultWallpaper) {
+  if (!chromeos::AshTestBaseAdapter::SupportsMultipleDisplays())
+    return;
+
+  WriteWallpapers();
+  UpdateDisplay("1600x1200");
+  WallpaperManager::Get()->SetDefaultWallpaperNow(std::string());
+  WaitAsyncWallpaperLoadFinished();
+  EXPECT_TRUE(
+      ImageIsNearColor(controller_->GetWallpaper(), kLargeWallpaperColor));
+}
+
+IN_PROC_BROWSER_TEST_P(WallpaperManagerBrowserTest,
+                       LargeDefaultWallpaperWhenRotated) {
+  if (!chromeos::AshTestBaseAdapter::SupportsMultipleDisplays())
+    return;
+  WriteWallpapers();
+
+  UpdateDisplay("1200x800/r");
+  WallpaperManager::Get()->SetDefaultWallpaperNow(std::string());
+  WaitAsyncWallpaperLoadFinished();
+  EXPECT_TRUE(
+      ImageIsNearColor(controller_->GetWallpaper(), kLargeWallpaperColor));
+}
+
+IN_PROC_BROWSER_TEST_P(WallpaperManagerBrowserTest, SmallGuestWallpaper) {
+  if (!chromeos::AshTestBaseAdapter::SupportsMultipleDisplays())
+    return;
+  WriteWallpapers();
+  UserManager::Get()->UserLoggedIn(
+      UserManager::kGuestUserName, UserManager::kGuestUserName, false);
+  UpdateDisplay("800x600");
+  WallpaperManager::Get()->SetDefaultWallpaperNow(std::string());
+  WaitAsyncWallpaperLoadFinished();
+  EXPECT_TRUE(
+      ImageIsNearColor(controller_->GetWallpaper(), kSmallGuestWallpaperColor));
+}
+
+IN_PROC_BROWSER_TEST_P(WallpaperManagerBrowserTest, LargeGuestWallpaper) {
+  if (!chromeos::AshTestBaseAdapter::SupportsMultipleDisplays())
+    return;
+
+  WriteWallpapers();
+  UserManager::Get()->UserLoggedIn(
+      UserManager::kGuestUserName, UserManager::kGuestUserName, false);
+  UpdateDisplay("1600x1200");
+  WallpaperManager::Get()->SetDefaultWallpaperNow(std::string());
+  WaitAsyncWallpaperLoadFinished();
+  EXPECT_TRUE(
+      ImageIsNearColor(controller_->GetWallpaper(), kLargeGuestWallpaperColor));
+}
+
+IN_PROC_BROWSER_TEST_P(WallpaperManagerBrowserTest,
+                       SwitchBetweenDefaultAndCustom) {
+  // Start loading the default wallpaper.
+  UpdateDisplay("640x480");
+  WriteWallpapers();
+  UserManager::Get()->UserLoggedIn(UserManager::kStubUser, "test_hash", false);
+
+  WallpaperManager::Get()->SetDefaultWallpaperNow(std::string());
+
+  // Custom wallpaper should be applied immediately, canceling the default
+  // wallpaper load task.
+  gfx::ImageSkia image = CreateTestImage(640, 480, kCustomWallpaperColor);
+  UserImage wallpaper(image);
+  WallpaperManager::Get()->SetCustomWallpaper(UserManager::kStubUser,
+                                              "test_hash",
+                                              "test-nofile.jpeg",
+                                              WALLPAPER_LAYOUT_STRETCH,
+                                              User::CUSTOMIZED,
+                                              wallpaper,
+                                              true);
+  WaitAsyncWallpaperLoadFinished();
+
+  EXPECT_TRUE(
+      ImageIsNearColor(controller_->GetWallpaper(), kCustomWallpaperColor));
+
+  WallpaperManager::Get()->SetDefaultWallpaperNow(std::string());
+  WaitAsyncWallpaperLoadFinished();
+
+  EXPECT_TRUE(
+      ImageIsNearColor(controller_->GetWallpaper(), kSmallWallpaperColor));
+}
+
 }  // namespace chromeos