Home | History | Annotate | Download | only in chromeos 
      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 
      6 #include <vector>
      7 
      8 #include "ash/desktop_background/desktop_background_controller.h"
      9 #include "ash/shell.h"
     10 #include "base/command_line.h"
     11 #include "base/files/scoped_temp_dir.h"
     12 #include "base/run_loop.h"
     13 #include "base/time/time.h"
     14 #include "chrome/browser/chromeos/customization_document.h"
     15 #include "chrome/browser/chromeos/customization_wallpaper_downloader.h"
     16 #include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h"
     17 #include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager_test_utils.h"
     18 #include "chrome/test/base/in_process_browser_test.h"
     19 #include "chrome/test/base/testing_browser_process.h"
     20 #include "chromeos/chromeos_switches.h"
     21 #include "components/google/core/browser/google_url_tracker.h"
     22 #include "net/http/http_response_headers.h"
     23 #include "net/http/http_status_code.h"
     24 #include "net/url_request/test_url_fetcher_factory.h"
     25 #include "net/url_request/url_fetcher_impl.h"
     26 #include "testing/gtest/include/gtest/gtest.h"
     27 
     28 namespace chromeos {
     29 
     30 namespace {
     31 
     32 const char kOEMWallpaperURL[] = "http://somedomain.com/image.png";
     33 
     34 const char kServicesManifest[] =
     35     "{"
     36     "  \"version\": \"1.0\","
     37     "  \"default_wallpaper\": \"http://somedomain.com/image.png\",\n"
     38     "  \"default_apps\": [\n"
     39     "    \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
     40     "    \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
     41     "  ],\n"
     42     "  \"localized_content\": {\n"
     43     "    \"en-US\": {\n"
     44     "      \"default_apps_folder_name\": \"EN-US OEM Name\"\n"
     45     "    },\n"
     46     "    \"en\": {\n"
     47     "      \"default_apps_folder_name\": \"EN OEM Name\"\n"
     48     "    },\n"
     49     "    \"default\": {\n"
     50     "      \"default_apps_folder_name\": \"Default OEM Name\"\n"
     51     "    }\n"
     52     "  }\n"
     53     "}";
     54 
     55 // Expected minimal wallpaper download retry interval in milliseconds.
     56 const int kDownloadRetryIntervalMS = 100;
     57 
     58 class TestWallpaperObserver : public WallpaperManager::Observer {
     59  public:
     60   explicit TestWallpaperObserver(WallpaperManager* wallpaper_manager)
     61       : finished_(false),
     62         wallpaper_manager_(wallpaper_manager) {
     63     DCHECK(wallpaper_manager_);
     64     wallpaper_manager_->AddObserver(this);
     65   }
     66 
     67   virtual ~TestWallpaperObserver() {
     68     wallpaper_manager_->RemoveObserver(this);
     69   }
     70 
     71   virtual void OnWallpaperAnimationFinished(const std::string&) OVERRIDE {
     72     finished_ = true;
     73     base::MessageLoop::current()->Quit();
     74   }
     75 
     76   void WaitForWallpaperAnimationFinished() {
     77     while (!finished_)
     78       base::RunLoop().Run();
     79   }
     80 
     81  private:
     82   bool finished_;
     83   WallpaperManager* wallpaper_manager_;
     84 
     85   DISALLOW_COPY_AND_ASSIGN(TestWallpaperObserver);
     86 };
     87 
     88 }  // namespace
     89 
     90 // This is helper class for net::FakeURLFetcherFactory.
     91 class TestWallpaperImageURLFetcherCallback {
     92  public:
     93   TestWallpaperImageURLFetcherCallback(
     94       const GURL& url,
     95       const size_t require_retries,
     96       const std::vector<unsigned char>& jpeg_data_raw)
     97       : url_(url),
     98         require_retries_(require_retries),
     99         factory_(NULL) {
    100     jpeg_data_.resize(jpeg_data_raw.size());
    101     std::copy(jpeg_data_raw.begin(), jpeg_data_raw.end(), jpeg_data_.begin());
    102   }
    103 
    104   scoped_ptr<net::FakeURLFetcher> CreateURLFetcher(
    105       const GURL& url,
    106       net::URLFetcherDelegate* delegate,
    107       const std::string& response_data,
    108       net::HttpStatusCode response_code,
    109       net::URLRequestStatus::Status status) {
    110     chromeos::ServicesCustomizationDocument* customization =
    111         chromeos::ServicesCustomizationDocument::GetInstance();
    112     customization->wallpaper_downloader_for_testing()
    113         ->set_retry_delay_for_testing(
    114             base::TimeDelta::FromMilliseconds(kDownloadRetryIntervalMS));
    115 
    116     attempts_.push_back(base::TimeTicks::Now());
    117     if (attempts_.size() > 1) {
    118       const int retry = num_attempts() - 1;
    119       const base::TimeDelta current_delay =
    120           customization->wallpaper_downloader_for_testing()
    121               ->retry_current_delay_for_testing();
    122       const double base_interval = base::TimeDelta::FromMilliseconds(
    123                                        kDownloadRetryIntervalMS).InSecondsF();
    124       EXPECT_GE(current_delay,
    125                 base::TimeDelta::FromSecondsD(base_interval * retry * retry))
    126           << "Retry too fast. Actual interval " << current_delay.InSecondsF()
    127           << " seconds, but expected at least " << base_interval
    128           << " * (retry=" << retry
    129           << " * retry)= " << base_interval * retry * retry << " seconds.";
    130     }
    131     if (attempts_.size() > require_retries_) {
    132       response_code = net::HTTP_OK;
    133       status = net::URLRequestStatus::SUCCESS;
    134       factory_->SetFakeResponse(url, response_data, response_code, status);
    135     }
    136     scoped_ptr<net::FakeURLFetcher> fetcher(new net::FakeURLFetcher(
    137         url, delegate, response_data, response_code, status));
    138     scoped_refptr<net::HttpResponseHeaders> download_headers =
    139         new net::HttpResponseHeaders(std::string());
    140     download_headers->AddHeader("Content-Type: image/jpeg");
    141     fetcher->set_response_headers(download_headers);
    142     return fetcher.Pass();
    143   }
    144 
    145   void Initialize(net::FakeURLFetcherFactory* factory) {
    146     factory_ = factory;
    147     factory_->SetFakeResponse(url_,
    148                               jpeg_data_,
    149                               net::HTTP_INTERNAL_SERVER_ERROR,
    150                               net::URLRequestStatus::FAILED);
    151   }
    152 
    153   size_t num_attempts() const { return attempts_.size(); }
    154 
    155  private:
    156   const GURL url_;
    157   // Respond with OK on required retry attempt.
    158   const size_t require_retries_;
    159   net::FakeURLFetcherFactory* factory_;
    160   std::vector<base::TimeTicks> attempts_;
    161   std::string jpeg_data_;
    162 
    163   DISALLOW_COPY_AND_ASSIGN(TestWallpaperImageURLFetcherCallback);
    164 };
    165 
    166 // This implements fake remote source for wallpaper image.
    167 // JPEG image is created here and served to CustomizationWallpaperDownloader
    168 // via net::FakeURLFetcher.
    169 class WallpaperImageFetcherFactory {
    170  public:
    171   WallpaperImageFetcherFactory(const GURL& url,
    172                                int width,
    173                                int height,
    174                                SkColor color,
    175                                const size_t require_retries) {
    176     // ASSERT_TRUE() cannot be directly used in constructor.
    177     Initialize(url, width, height, color, require_retries);
    178   }
    179 
    180   ~WallpaperImageFetcherFactory() {
    181     fetcher_factory_.reset();
    182     net::URLFetcherImpl::set_factory(fallback_fetcher_factory_.get());
    183     fallback_fetcher_factory_.reset();
    184   }
    185 
    186   size_t num_attempts() const { return url_callback_->num_attempts(); }
    187 
    188  private:
    189   void Initialize(const GURL& url,
    190                   int width,
    191                   int height,
    192                   SkColor color,
    193                   const size_t require_retries) {
    194     std::vector<unsigned char> oem_wallpaper_;
    195     ASSERT_TRUE(wallpaper_manager_test_utils::CreateJPEGImage(
    196         width, height, color, &oem_wallpaper_));
    197 
    198     url_callback_.reset(new TestWallpaperImageURLFetcherCallback(
    199         url, require_retries, oem_wallpaper_));
    200     fallback_fetcher_factory_.reset(new net::TestURLFetcherFactory);
    201     net::URLFetcherImpl::set_factory(NULL);
    202     fetcher_factory_.reset(new net::FakeURLFetcherFactory(
    203         fallback_fetcher_factory_.get(),
    204         base::Bind(&TestWallpaperImageURLFetcherCallback::CreateURLFetcher,
    205                    base::Unretained(url_callback_.get()))));
    206     url_callback_->Initialize(fetcher_factory_.get());
    207   }
    208 
    209   scoped_ptr<TestWallpaperImageURLFetcherCallback> url_callback_;
    210 
    211   // Use a test factory as a fallback so we don't have to deal with other
    212   // requests.
    213   scoped_ptr<net::TestURLFetcherFactory> fallback_fetcher_factory_;
    214   scoped_ptr<net::FakeURLFetcherFactory> fetcher_factory_;
    215 
    216   DISALLOW_COPY_AND_ASSIGN(WallpaperImageFetcherFactory);
    217 };
    218 
    219 class CustomizationWallpaperDownloaderBrowserTest
    220     : public InProcessBrowserTest {
    221  public:
    222   CustomizationWallpaperDownloaderBrowserTest()
    223       : controller_(NULL),
    224         local_state_(NULL) {
    225   }
    226 
    227   virtual ~CustomizationWallpaperDownloaderBrowserTest() {}
    228 
    229   virtual void SetUpOnMainThread() OVERRIDE {
    230     controller_ = ash::Shell::GetInstance()->desktop_background_controller();
    231     local_state_ = g_browser_process->local_state();
    232   }
    233 
    234   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
    235     command_line->AppendSwitch(chromeos::switches::kLoginManager);
    236     command_line->AppendSwitchASCII(chromeos::switches::kLoginProfile, "user");
    237   }
    238 
    239   virtual void CleanUpOnMainThread() OVERRIDE { controller_ = NULL; }
    240 
    241  protected:
    242   void CreateCmdlineWallpapers() {
    243     cmdline_wallpaper_dir_.reset(new base::ScopedTempDir);
    244     ASSERT_TRUE(cmdline_wallpaper_dir_->CreateUniqueTempDir());
    245     wallpaper_manager_test_utils::CreateCmdlineWallpapers(
    246         *cmdline_wallpaper_dir_, &wallpaper_manager_command_line_);
    247   }
    248 
    249   ash::DesktopBackgroundController* controller_;
    250   PrefService* local_state_;
    251   scoped_ptr<base::CommandLine> wallpaper_manager_command_line_;
    252 
    253   // Directory created by CreateCmdlineWallpapersAndSetFlags() to store default
    254   // wallpaper images.
    255   scoped_ptr<base::ScopedTempDir> cmdline_wallpaper_dir_;
    256 
    257  private:
    258   DISALLOW_COPY_AND_ASSIGN(CustomizationWallpaperDownloaderBrowserTest);
    259 };
    260 
    261 IN_PROC_BROWSER_TEST_F(CustomizationWallpaperDownloaderBrowserTest,
    262                        OEMWallpaperIsPresent) {
    263   CreateCmdlineWallpapers();
    264   WallpaperManager::Get()->SetDefaultWallpaperNow(std::string());
    265   wallpaper_manager_test_utils::WaitAsyncWallpaperLoadFinished();
    266   EXPECT_TRUE(wallpaper_manager_test_utils::ImageIsNearColor(
    267       controller_->GetWallpaper(),
    268       wallpaper_manager_test_utils::kSmallDefaultWallpaperColor));
    269 
    270   WallpaperImageFetcherFactory url_factory(
    271       GURL(kOEMWallpaperURL),
    272       wallpaper_manager_test_utils::kWallpaperSize,
    273       wallpaper_manager_test_utils::kWallpaperSize,
    274       wallpaper_manager_test_utils::kCustomWallpaperColor,
    275       0 /* require_retries */);
    276 
    277   TestWallpaperObserver observer(WallpaperManager::Get());
    278   chromeos::ServicesCustomizationDocument* customization =
    279       chromeos::ServicesCustomizationDocument::GetInstance();
    280   EXPECT_TRUE(
    281       customization->LoadManifestFromString(std::string(kServicesManifest)));
    282 
    283   observer.WaitForWallpaperAnimationFinished();
    284   EXPECT_TRUE(wallpaper_manager_test_utils::ImageIsNearColor(
    285       controller_->GetWallpaper(),
    286       wallpaper_manager_test_utils::kCustomWallpaperColor));
    287   EXPECT_EQ(1U, url_factory.num_attempts());
    288 }
    289 
    290 IN_PROC_BROWSER_TEST_F(CustomizationWallpaperDownloaderBrowserTest,
    291                        OEMWallpaperRetryFetch) {
    292   CreateCmdlineWallpapers();
    293   WallpaperManager::Get()->SetDefaultWallpaperNow(std::string());
    294   wallpaper_manager_test_utils::WaitAsyncWallpaperLoadFinished();
    295   EXPECT_TRUE(wallpaper_manager_test_utils::ImageIsNearColor(
    296       controller_->GetWallpaper(),
    297       wallpaper_manager_test_utils::kSmallDefaultWallpaperColor));
    298 
    299   WallpaperImageFetcherFactory url_factory(
    300       GURL(kOEMWallpaperURL),
    301       wallpaper_manager_test_utils::kWallpaperSize,
    302       wallpaper_manager_test_utils::kWallpaperSize,
    303       wallpaper_manager_test_utils::kCustomWallpaperColor,
    304       1 /* require_retries */);
    305 
    306   TestWallpaperObserver observer(WallpaperManager::Get());
    307   chromeos::ServicesCustomizationDocument* customization =
    308       chromeos::ServicesCustomizationDocument::GetInstance();
    309   EXPECT_TRUE(
    310       customization->LoadManifestFromString(std::string(kServicesManifest)));
    311 
    312   observer.WaitForWallpaperAnimationFinished();
    313   EXPECT_TRUE(wallpaper_manager_test_utils::ImageIsNearColor(
    314       controller_->GetWallpaper(),
    315       wallpaper_manager_test_utils::kCustomWallpaperColor));
    316 
    317   EXPECT_EQ(2U, url_factory.num_attempts());
    318 }
    319 
    320 }  // namespace chromeos
    321