If customization includes default wallpaper, download and apply it.

ash/desktop_background/desktop_background_controller_unittest.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 "ash/desktop_background/desktop_background_controller.h"
 
 #include <cmath>
 #include <cstdlib>
 
 #include "ash/ash_switches.h"
 #include "ash/desktop_background/desktop_background_controller_observer.h"
 #include "ash/desktop_background/desktop_background_widget_controller.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.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/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_utils.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ skipping 65 matching lines @@
     base::TimeTicks step_time = controller.animator()->last_step_time();
     element->Step(step_time + base::TimeDelta::FromMilliseconds(1000));
   }
 }
 
 }  // namespace
 
 class DesktopBackgroundControllerTest : public test::AshTestBase {
  public:
   DesktopBackgroundControllerTest()
-      : command_line_(CommandLine::NO_PROGRAM),
-        controller_(NULL) {
+      : controller_(NULL) {
   }
   virtual ~DesktopBackgroundControllerTest() {}
 
   virtual void SetUp() OVERRIDE {
     test::AshTestBase::SetUp();
     // Ash shell initialization creates wallpaper. Reset it so we can manually
     // control wallpaper creation and animation in our tests.
     internal::RootWindowController* root_window_controller =
         Shell::GetPrimaryRootWindowController();
     root_window_controller->SetWallpaperController(NULL);
@@ skipping 106 matching lines @@
       return false;
     }
 
     return true;
   }
 
   // Initializes |wallpaper_dir_|, writes JPEG wallpaper images to it, and
   // passes |controller_| a command line instructing it to use the images.
   // Only needs to be called (once) by tests that want to test loading of
   // default wallpapers.
   void WriteWallpapersAndSetFlags() {

[Daniel Erat, 2014/03/25 21:58:29]

nit: rename this to something like WriteWallpapers() since it's no longer
setting any flags. also update its comment.

[Alexander Alekseev, 2014/03/27 00:28:37]

Done.

     wallpaper_dir_.reset(new base::ScopedTempDir);
     ASSERT_TRUE(wallpaper_dir_->CreateUniqueTempDir());
 
-    const base::FilePath kLargePath =
+    default_large_file_ =
         wallpaper_dir_->path().Append(FILE_PATH_LITERAL("large.jpg"));
-    ASSERT_TRUE(WriteJPEGFile(kLargePath, kWallpaperSize, kWallpaperSize,
+    ASSERT_TRUE(WriteJPEGFile(default_large_file_,
+                              kWallpaperSize,
+                              kWallpaperSize,
                               kLargeWallpaperColor));
-    command_line_.AppendSwitchPath(
-        switches::kAshDefaultWallpaperLarge, kLargePath);
-
-    const base::FilePath kSmallPath =
+    default_small_file_ =
         wallpaper_dir_->path().Append(FILE_PATH_LITERAL("small.jpg"));
-    ASSERT_TRUE(WriteJPEGFile(kSmallPath, kWallpaperSize, kWallpaperSize,
+    ASSERT_TRUE(WriteJPEGFile(default_small_file_,
+                              kWallpaperSize,
+                              kWallpaperSize,
                               kSmallWallpaperColor));
-    command_line_.AppendSwitchPath(
-        switches::kAshDefaultWallpaperSmall, kSmallPath);
-
-    const base::FilePath kLargeGuestPath =
+    guest_default_large_file_ =
         wallpaper_dir_->path().Append(FILE_PATH_LITERAL("guest_large.jpg"));
-    ASSERT_TRUE(WriteJPEGFile(kLargeGuestPath, kWallpaperSize, kWallpaperSize,
+    ASSERT_TRUE(WriteJPEGFile(guest_default_large_file_,
+                              kWallpaperSize,
+                              kWallpaperSize,
                               kLargeGuestWallpaperColor));
-    command_line_.AppendSwitchPath(
-        switches::kAshGuestWallpaperLarge, kLargeGuestPath);
-
-    const base::FilePath kSmallGuestPath =
+    guest_default_small_file_ =
         wallpaper_dir_->path().Append(FILE_PATH_LITERAL("guest_small.jpg"));
-    ASSERT_TRUE(WriteJPEGFile(kSmallGuestPath, kWallpaperSize, kWallpaperSize,
+    ASSERT_TRUE(WriteJPEGFile(guest_default_small_file_,
+                              kWallpaperSize,
+                              kWallpaperSize,
                               kSmallGuestWallpaperColor));
-    command_line_.AppendSwitchPath(
-        switches::kAshGuestWallpaperSmall, kSmallGuestPath);
-
-    controller_->set_command_line_for_testing(&command_line_);
   }
 
-  // Custom command line passed to DesktopBackgroundController by
-  // WriteWallpapersAndSetFlags().
-  CommandLine command_line_;
-
   // Directory created by WriteWallpapersAndSetFlags() to store default
   // wallpaper images.
   scoped_ptr<base::ScopedTempDir> wallpaper_dir_;
 
   DesktopBackgroundController* controller_;  // Not owned.
 
   test::TestUserWallpaperDelegate* wallpaper_delegate_;
 
+  base::FilePath default_small_file_;
+  base::FilePath default_large_file_;
+
+  base::FilePath guest_default_small_file_;
+  base::FilePath guest_default_large_file_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(DesktopBackgroundControllerTest);
 };
 
 TEST_F(DesktopBackgroundControllerTest, BasicReparenting) {
   DesktopBackgroundController* controller =
       Shell::GetInstance()->desktop_background_controller();
   controller->CreateEmptyWallpaper();
 
   // Wallpaper view/window exists in the desktop background container and
@@ skipping 234 matching lines @@
   if (!SupportsMultipleDisplays())
     return;
 
   WriteWallpapersAndSetFlags();
   TestObserver observer(controller_);
 
   // At 800x600, the small wallpaper should be loaded.
   test::DisplayManagerTestApi display_manager_test_api(
       Shell::GetInstance()->display_manager());
   display_manager_test_api.UpdateDisplay("800x600");
-  ASSERT_TRUE(controller_->SetDefaultWallpaper(false));
+  ASSERT_TRUE(controller_->SetDefaultWallpaper(default_small_file_,
+                                               default_large_file_));
   observer.WaitForWallpaperDataChanged();
   EXPECT_TRUE(ImageIsNearColor(controller_->GetWallpaper(),
                                kSmallWallpaperColor));
 
   // Requesting the same wallpaper again should be a no-op.
-  ASSERT_FALSE(controller_->SetDefaultWallpaper(false));
+  ASSERT_FALSE(controller_->SetDefaultWallpaper(default_small_file_,
+                                                default_large_file_));
 }
 
 TEST_F(DesktopBackgroundControllerTest, LargeDefaultWallpaper) {
   if (!SupportsMultipleDisplays())
     return;
 
   WriteWallpapersAndSetFlags();
   TestObserver observer(controller_);
   test::DisplayManagerTestApi display_manager_test_api(
       Shell::GetInstance()->display_manager());
   display_manager_test_api.UpdateDisplay("1600x1200");
-  ASSERT_TRUE(controller_->SetDefaultWallpaper(false));
+  ASSERT_TRUE(controller_->SetDefaultWallpaper(default_small_file_,
+                                               default_large_file_));
   observer.WaitForWallpaperDataChanged();
   EXPECT_TRUE(ImageIsNearColor(controller_->GetWallpaper(),
                                kLargeWallpaperColor));
 }
 
 TEST_F(DesktopBackgroundControllerTest, LargeDefaultWallpaperWhenRotated) {
   if (!SupportsMultipleDisplays())
     return;
   WriteWallpapersAndSetFlags();
   TestObserver observer(controller_);
   test::DisplayManagerTestApi display_manager_test_api(
       Shell::GetInstance()->display_manager());
 
   display_manager_test_api.UpdateDisplay("1200x800/r");
-  ASSERT_TRUE(controller_->SetDefaultWallpaper(false));
+  ASSERT_TRUE(controller_->SetDefaultWallpaper(default_small_file_,
+                                               default_large_file_));
   observer.WaitForWallpaperDataChanged();
   EXPECT_TRUE(ImageIsNearColor(controller_->GetWallpaper(),
                                kLargeWallpaperColor));
 }
 
 TEST_F(DesktopBackgroundControllerTest, SmallGuestWallpaper) {
   if (!SupportsMultipleDisplays())
     return;
 
   WriteWallpapersAndSetFlags();
   TestObserver observer(controller_);
   test::DisplayManagerTestApi display_manager_test_api(
       Shell::GetInstance()->display_manager());
   display_manager_test_api.UpdateDisplay("800x600");
-  ASSERT_TRUE(controller_->SetDefaultWallpaper(true));
+  ASSERT_TRUE(controller_->SetDefaultWallpaper(guest_default_small_file_,
+                                               guest_default_large_file_));
   observer.WaitForWallpaperDataChanged();
   EXPECT_TRUE(ImageIsNearColor(controller_->GetWallpaper(),
                                kSmallGuestWallpaperColor));
 }
 
 TEST_F(DesktopBackgroundControllerTest, LargeGuestWallpaper) {
   if (!SupportsMultipleDisplays())
     return;
 
   WriteWallpapersAndSetFlags();
   TestObserver observer(controller_);
   test::DisplayManagerTestApi display_manager_test_api(
       Shell::GetInstance()->display_manager());
   display_manager_test_api.UpdateDisplay("1600x1200");
-  ASSERT_TRUE(controller_->SetDefaultWallpaper(true));
+  ASSERT_TRUE(controller_->SetDefaultWallpaper(guest_default_small_file_,
+                                               guest_default_large_file_));
   observer.WaitForWallpaperDataChanged();
   EXPECT_TRUE(ImageIsNearColor(controller_->GetWallpaper(),
                                kLargeGuestWallpaperColor));
 }
 
 TEST_F(DesktopBackgroundControllerTest, ResizeCustomWallpaper) {
   if (!SupportsMultipleDisplays())
     return;
 
   test::DisplayManagerTestApi display_manager_test_api(
@@ skipping 59 matching lines @@
   UpdateDisplay("400x300,100x500");
   EXPECT_EQ(
       "400x500",
       DesktopBackgroundController::GetMaxDisplaySizeInNative().ToString());
 }
 
 TEST_F(DesktopBackgroundControllerTest, SwitchBetweenDefaultAndCustom) {
   // Start loading the default wallpaper.
   UpdateDisplay("640x480");
   WriteWallpapersAndSetFlags();
-  ASSERT_TRUE(controller_->SetDefaultWallpaper(false));
+  ASSERT_TRUE(controller_->SetDefaultWallpaper(default_small_file_,
+                                               default_large_file_));
 
   // Custom wallpaper should be applied immediately, canceling the default
   // wallpaper load task.
   gfx::ImageSkia image = CreateImage(640, 480, kCustomWallpaperColor);
   controller_->SetCustomWallpaper(image, WALLPAPER_LAYOUT_STRETCH);
   EXPECT_TRUE(ImageIsNearColor(controller_->GetWallpaper(),
                                kCustomWallpaperColor));
 
   // A call to SetDefaultWallpaper() should return true now, indicating that a
   // new load task was started (since the previous one was interrupted by
   // SetCustomWallpaper()). See http://crbug.com/327443.
   TestObserver observer(controller_);
-  ASSERT_TRUE(controller_->SetDefaultWallpaper(false));
+  ASSERT_TRUE(controller_->SetDefaultWallpaper(default_small_file_,
+                                               default_large_file_));
   observer.WaitForWallpaperDataChanged();
   EXPECT_TRUE(ImageIsNearColor(controller_->GetWallpaper(),
                                kSmallWallpaperColor));
 }
 
 }  // namespace ash