// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/ambient/ambient_photo_controller.h"
#include <array>
#include <memory>
#include <tuple>
#include <utility>
#include "ash/ambient/ambient_constants.h"
#include "ash/ambient/ambient_controller.h"
#include "ash/ambient/ambient_photo_cache.h"
#include "ash/ambient/ambient_ui_settings.h"
#include "ash/ambient/model/ambient_animation_photo_config.h"
#include "ash/ambient/model/ambient_backend_model.h"
#include "ash/ambient/model/ambient_backend_model_observer.h"
#include "ash/ambient/model/ambient_photo_config.h"
#include "ash/ambient/test/ambient_ash_test_base.h"
#include "ash/ambient/test/ambient_test_util.h"
#include "ash/ambient/test/mock_ambient_backend_model_observer.h"
#include "ash/public/cpp/ambient/ambient_backend_controller.h"
#include "ash/public/cpp/ambient/fake_ambient_backend_controller_impl.h"
#include "ash/public/cpp/ambient/proto/photo_cache_entry.pb.h"
#include "ash/shell.h"
#include "ash/test/ash_test_util.h"
#include "ash/webui/personalization_app/mojom/personalization_app.mojom-shared.h"
#include "base/barrier_closure.h"
#include "base/base_paths.h"
#include "base/check.h"
#include "base/containers/contains.h"
#include "base/files/file_enumerator.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/hash/sha1.h"
#include "base/path_service.h"
#include "base/run_loop.h"
#include "base/scoped_observation.h"
#include "base/system/sys_info.h"
#include "base/test/bind.h"
#include "base/test/scoped_run_loop_timeout.h"
#include "base/time/time.h"
#include "base/timer/timer.h"
#include "cc/paint/skottie_resource_metadata.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "ui/gfx/image/image_skia.h"
namespace ash {
using ::testing::AnyOf;
using ::testing::Contains;
using ::testing::Eq;
using ::testing::IsEmpty;
using ::testing::Not;
using ::testing::Pointwise;
using ::testing::SizeIs;
namespace {
bool AreBackedBySameImage(const PhotoWithDetails& topic_l,
const PhotoWithDetails& topic_r) {
return !topic_l.photo.isNull() && !topic_r.photo.isNull() &&
topic_l.photo.BackedBySameObjectAs(topic_r.photo);
}
MATCHER(BackedBySameImage, "") {
return AreBackedBySameImage(std::get<0>(arg), std::get<1>(arg));
}
MATCHER_P(BackedBySameImageAs, photo_with_details, "") {
return AreBackedBySameImage(arg, photo_with_details);
}
} // namespace
class AmbientPhotoControllerTest : public AmbientAshTestBase {
protected:
void SetUp() override {
AmbientAshTestBase::SetUp();
// Force the `AmbientUiSettings` to be any setting that has photos, or
// `photo_controller()` will be null and the tests will crash.
SetAmbientTheme(personalization_app::mojom::AmbientTheme::kSlideshow);
// This is common to all AmbientPhotoConfigs and mimics real-world behavior:
// When OnImagesReady() is called, the UI synchronously starts rendering.
ON_CALL(images_ready_observer_, OnImagesReady)
.WillByDefault(::testing::Invoke([this]() {
photo_controller()->OnMarkerHit(
AmbientPhotoConfig::Marker::kUiStartRendering);
}));
images_ready_observation_.Observe(
photo_controller()->ambient_backend_model());
}
void TearDown() override {
images_ready_observation_.Reset();
AmbientAshTestBase::TearDown();
}
std::vector<int> GetSavedCacheIndices(bool backup = false) {
std::vector<int> result;
const auto& map = backup ? GetBackupCachedFiles() : GetCachedFiles();
for (auto& it : map) {
result.push_back(it.first);
}
return result;
}
const ::ambient::PhotoCacheEntry* GetCacheEntryAtIndex(int cache_index,
bool backup = false) {
const auto& files = backup ? GetBackupCachedFiles() : GetCachedFiles();
auto it = files.find(cache_index);
if (it == files.end())
return nullptr;
else
return &(it->second);
}
void WriteCacheDataBlocking(int cache_index,
std::string image,
const std::string* details = nullptr,
const std::string* related_image = nullptr,
const std::string* related_details = nullptr,
bool is_portrait = false) {
::ambient::PhotoCacheEntry cache_entry;
cache_entry.mutable_primary_photo()->set_image(std::move(image));
if (details)
cache_entry.mutable_primary_photo()->set_details(*details);
cache_entry.mutable_primary_photo()->set_is_portrait(is_portrait);
if (related_image) {
cache_entry.mutable_related_photo()->set_image(*related_image);
cache_entry.mutable_related_photo()->set_is_portrait(is_portrait);
}
if (related_details)
cache_entry.mutable_related_photo()->set_details(*related_details);
base::RunLoop loop;
ambient_photo_cache::WritePhotoCache(ambient_photo_cache::Store::kPrimary,
/*cache_index=*/cache_index,
cache_entry, loop.QuitClosure());
loop.Run();
}
void ScheduleFetchBackupImages() {
photo_controller()->ScheduleFetchBackupImages();
}
void Init() { photo_controller()->Init(); }
bool RunUntilImagesReady() {
if (photo_controller()->ambient_backend_model()->ImagesReady()) {
return true;
}
static constexpr base::TimeDelta kTimeout = base::Seconds(3);
base::RunLoop loop;
base::RepeatingClosure quit_closure = loop.QuitClosure();
testing::NiceMock<MockAmbientBackendModelObserver> mock_backend_observer;
base::ScopedObservation<AmbientBackendModel, AmbientBackendModelObserver>
scoped_observation{&mock_backend_observer};
scoped_observation.Observe(photo_controller()->ambient_backend_model());
bool images_ready = false;
ON_CALL(mock_backend_observer, OnImagesReady)
.WillByDefault(::testing::Invoke([quit_closure, &images_ready]() {
quit_closure.Run();
images_ready = true;
}));
task_environment()->GetMainThreadTaskRunner()->PostDelayedTask(
FROM_HERE, quit_closure, kTimeout);
loop.Run();
return images_ready;
}
bool RunUntilNextTopicsAdded(int num_expected_topics) {
static constexpr base::TimeDelta kTimeout = base::Seconds(3);
base::RunLoop loop;
base::RepeatingClosure quit_closure = loop.QuitClosure();
int num_topics_added = 0;
testing::NiceMock<MockAmbientBackendModelObserver> mock_backend_observer;
base::ScopedObservation<AmbientBackendModel, AmbientBackendModelObserver>
scoped_observation{&mock_backend_observer};
scoped_observation.Observe(photo_controller()->ambient_backend_model());
ON_CALL(mock_backend_observer, OnImageAdded)
.WillByDefault(::testing::Invoke(
[quit_closure, num_expected_topics, &num_topics_added]() {
++num_topics_added;
if (num_topics_added >= num_expected_topics)
quit_closure.Run();
}));
task_environment()->GetMainThreadTaskRunner()->PostDelayedTask(
FROM_HERE, quit_closure, kTimeout);
loop.Run();
return num_topics_added >= num_expected_topics;
}
testing::NiceMock<MockAmbientBackendModelObserver> images_ready_observer_;
base::ScopedObservation<AmbientBackendModel, AmbientBackendModelObserver>
images_ready_observation_{&images_ready_observer_};
};
// Has 2 positions in the animation for photos and 2 dynamic assets per
// position.
class AmbientPhotoControllerAnimationTest : public AmbientPhotoControllerTest {
protected:
void SetUp() override {
AmbientPhotoControllerTest::SetUp();
cc::SkottieResourceMetadataMap resource_metadata;
std::array<std::string, 4> all_dynamic_asset_ids = {
GenerateLottieDynamicAssetIdForTesting(/*position=*/"A", /*idx=*/1),
GenerateLottieDynamicAssetIdForTesting(/*position=*/"A", /*idx=*/2),
GenerateLottieDynamicAssetIdForTesting(/*position=*/"B", /*idx=*/1),
GenerateLottieDynamicAssetIdForTesting(/*position=*/"B", /*idx=*/2)};
for (const std::string& asset_id : all_dynamic_asset_ids) {
CHECK(resource_metadata.RegisterAsset("test-path", "test-name", asset_id,
/*size=*/std::nullopt));
}
photo_controller()->ambient_backend_model()->SetPhotoConfig(
CreateAmbientAnimationPhotoConfig(resource_metadata));
CHECK_EQ(photo_config().GetNumDecodedTopicsToBuffer(), 4u);
CHECK_EQ(photo_config().topic_set_size, 2u);
}
const AmbientPhotoConfig& photo_config() {
return photo_controller()->ambient_backend_model()->photo_config();
}
};
// No topics should be prepared at all; the screensaver doesn't have photos in
// it. AmbientPhotoController should be completely idle and
// AmbientBackendModel::ImagesReady() should be true immediately.
class AmbientPhotoControllerEmptyConfigTest
: public AmbientPhotoControllerTest {
protected:
void SetUp() override {
AmbientPhotoControllerTest::SetUp();
photo_controller()->ambient_backend_model()->SetPhotoConfig(
AmbientPhotoConfig());
}
};
// Test that topics are downloaded when starting screen update.
TEST_F(AmbientPhotoControllerTest, ShouldStartToDownloadTopics) {
auto topics =
photo_controller()->ambient_backend_model()->all_decoded_topics();
EXPECT_TRUE(topics.empty());
// Start to refresh images.
photo_controller()->StartScreenUpdate();
topics = photo_controller()->ambient_backend_model()->all_decoded_topics();
EXPECT_TRUE(topics.empty());
ASSERT_TRUE(RunUntilImagesReady());
topics = photo_controller()->ambient_backend_model()->all_decoded_topics();
EXPECT_FALSE(topics.empty());
// Stop to refresh images.
photo_controller()->StopScreenUpdate();
topics = photo_controller()->ambient_backend_model()->all_decoded_topics();
EXPECT_TRUE(topics.empty());
}
// Test that image is downloaded when starting screen update.
TEST_F(AmbientPhotoControllerTest, ShouldStartToDownloadImages) {
PhotoWithDetails image;
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/nullptr,
/*next_image=*/&image);
EXPECT_TRUE(image.IsNull());
// Start to refresh images.
photo_controller()->StartScreenUpdate();
ASSERT_TRUE(RunUntilImagesReady());
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/nullptr,
/*next_image=*/&image);
EXPECT_FALSE(image.IsNull());
// Stop to refresh images.
photo_controller()->StopScreenUpdate();
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/nullptr,
/*next_image=*/&image);
EXPECT_TRUE(image.IsNull());
}
// Tests that photos are updated when OnMarkerHit() is called.
TEST_F(AmbientPhotoControllerTest, OnMarkerHitShouldUpdatePhoto) {
PhotoWithDetails image1;
PhotoWithDetails image2;
PhotoWithDetails image3;
// Start to refresh images.
photo_controller()->StartScreenUpdate();
ASSERT_TRUE(RunUntilImagesReady());
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/nullptr,
/*next_image=*/&image1);
EXPECT_FALSE(image1.IsNull());
EXPECT_TRUE(image2.IsNull());
photo_controller()->OnMarkerHit(AmbientPhotoConfig::Marker::kUiCycleEnded);
ASSERT_TRUE(RunUntilNextTopicsAdded(/*num_expected_topics=*/1));
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/nullptr,
/*next_image=*/&image2);
EXPECT_FALSE(image2.IsNull());
EXPECT_FALSE(image1.photo.BackedBySameObjectAs(image2.photo));
EXPECT_TRUE(image3.IsNull());
photo_controller()->OnMarkerHit(AmbientPhotoConfig::Marker::kUiCycleEnded);
ASSERT_TRUE(RunUntilNextTopicsAdded(/*num_expected_topics=*/1));
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/nullptr,
/*next_image=*/&image3);
EXPECT_FALSE(image3.IsNull());
EXPECT_FALSE(image1.photo.BackedBySameObjectAs(image3.photo));
EXPECT_FALSE(image2.photo.BackedBySameObjectAs(image3.photo));
// Stop to refresh images.
photo_controller()->StopScreenUpdate();
}
TEST_F(AmbientPhotoControllerTest,
ShouldLoadSavedTopicsFromDiskWithoutInternet) {
// Start ambient mode and run until ImagesReady(). At this point, the
// controller should have saved 2 topics to disk.
PhotoWithDetails image;
photo_controller()->StartScreenUpdate();
ASSERT_TRUE(RunUntilImagesReady());
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/nullptr,
/*next_image=*/&image);
ASSERT_FALSE(image.IsNull());
// Stop ambient mode. That should clear the decoded topics in the model but
// not clear the saved topics on disk.
photo_controller()->StopScreenUpdate();
// Simulate internet connection down.
backend_controller()->SetFetchScreenUpdateInfoResponseSize(
/*num_topics_to_return=*/0);
// Restart ambient mode, and it should load previously saved topics from disk.
photo_controller()->StartScreenUpdate();
ASSERT_TRUE(RunUntilImagesReady());
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/nullptr,
/*next_image=*/&image);
EXPECT_FALSE(image.IsNull());
}
// Tests that image details is correctly set.
TEST_F(AmbientPhotoControllerTest, ShouldSetDetailsCorrectly) {
SetPhotoOrientation(/*portrait=*/true);
// Start to refresh images.
photo_controller()->StartScreenUpdate();
ASSERT_TRUE(RunUntilImagesReady());
PhotoWithDetails image;
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/nullptr,
/*next_image=*/&image);
EXPECT_FALSE(image.IsNull());
// Fake details defined in fake_ambient_backend_controller_impl.cc.
EXPECT_EQ(image.details, "fake-photo-attribution");
// Stop to refresh images.
photo_controller()->StopScreenUpdate();
}
// Test that image is saved.
TEST_F(AmbientPhotoControllerTest, ShouldSaveImagesOnDisk) {
// Start to refresh images. It will download two images immediately and write
// them in |ambient_image_path|. It will also download one more image after
// OnMarkerHit(). It will also download the related images and not cache
// them.
photo_controller()->StartScreenUpdate();
ASSERT_TRUE(RunUntilImagesReady());
photo_controller()->OnMarkerHit(AmbientPhotoConfig::Marker::kUiCycleEnded);
ASSERT_TRUE(RunUntilNextTopicsAdded(/*num_expected_topics=*/1));
// Count number of writes to cache. There should be three cache writes during
// this ambient mode session.
auto file_paths = GetSavedCacheIndices();
EXPECT_EQ(file_paths.size(), 3u);
}
// Test that image is save and will not be deleted when stopping ambient mode.
TEST_F(AmbientPhotoControllerTest, ShouldNotDeleteImagesOnDisk) {
// Start to refresh images. It will download two images immediately and write
// them in |ambient_image_path|. It will also download one more image after
// OnMarkerHit(). It will also download the related images and not cache
// them.
photo_controller()->StartScreenUpdate();
ASSERT_TRUE(RunUntilImagesReady());
photo_controller()->OnMarkerHit(AmbientPhotoConfig::Marker::kUiCycleEnded);
ASSERT_TRUE(RunUntilNextTopicsAdded(/*num_expected_topics=*/1));
EXPECT_EQ(GetSavedCacheIndices().size(), 3u);
PhotoWithDetails image;
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/nullptr,
/*next_image=*/&image);
EXPECT_FALSE(image.IsNull());
// Stop to refresh images.
photo_controller()->StopScreenUpdate();
FastForwardByPhotoRefreshInterval();
EXPECT_EQ(GetSavedCacheIndices().size(), 3u);
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/nullptr,
/*next_image=*/&image);
EXPECT_TRUE(image.IsNull());
}
// Test that image is read from disk when no more topics.
TEST_F(AmbientPhotoControllerTest, ShouldReadCacheWhenNoMoreTopics) {
backend_controller()->SetFetchScreenUpdateInfoResponseSize(0);
Init();
FetchImage();
FastForwardByPhotoRefreshInterval();
// Topics is empty. Will read from cache, which is empty.
PhotoWithDetails image;
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/&image,
/*next_image=*/nullptr);
EXPECT_TRUE(image.IsNull());
// Save a file to check if it gets read for display.
WriteCacheDataBlocking(/*cache_index=*/0,
CreateEncodedImageForTesting(gfx::Size(10, 10)));
// Reset variables in photo controller.
Init();
FetchImage();
ASSERT_TRUE(RunUntilNextTopicsAdded(/*num_expected_topics=*/1));
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/&image,
/*next_image=*/nullptr);
EXPECT_FALSE(image.IsNull());
}
// Test that will try 100 times to read image from disk when no more topics.
TEST_F(AmbientPhotoControllerTest,
ShouldTry100TimesToReadCacheWhenNoMoreTopics) {
backend_controller()->SetFetchScreenUpdateInfoResponseSize(0);
Init();
FetchImage();
FastForwardByPhotoRefreshInterval();
// Topics is empty. Will read from cache, which is empty.
PhotoWithDetails image;
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/&image,
/*next_image=*/nullptr);
EXPECT_TRUE(image.IsNull());
// The initial file name to be read is 0. Save a file with index 99 to check
// if it gets read for display.
WriteCacheDataBlocking(/*cache_index=*/99,
CreateEncodedImageForTesting(gfx::Size(10, 10)));
// Reset variables in photo controller.
Init();
FetchImage();
ASSERT_TRUE(RunUntilNextTopicsAdded(/*num_expected_topics=*/1));
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/&image,
/*next_image=*/nullptr);
EXPECT_FALSE(image.IsNull());
}
// Test that image is read from disk when image downloading failed.
TEST_F(AmbientPhotoControllerTest, ShouldReadCacheWhenImageDownloadingFailed) {
SetDownloadPhotoData("");
Init();
FetchTopics();
// Forward a little bit time. FetchTopics() will succeed. Downloading should
// fail. Will read from cache, which is empty.
task_environment()->FastForwardBy(0.2 * kTopicFetchInterval);
PhotoWithDetails image;
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/&image,
/*next_image=*/nullptr);
EXPECT_TRUE(image.IsNull());
// Save a file to check if it gets read for display.
WriteCacheDataBlocking(/*cache_index=*/0,
CreateEncodedImageForTesting(gfx::Size(10, 10)));
// Reset variables in photo controller.
Init();
FetchTopics();
// Forward a little bit time. FetchTopics() will succeed. Downloading should
// fail. Will read from cache.
task_environment()->FastForwardBy(0.2 * kTopicFetchInterval);
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/&image,
/*next_image=*/nullptr);
EXPECT_FALSE(image.IsNull());
}
// Test that image details is read from disk.
TEST_F(AmbientPhotoControllerTest, ShouldPopulateDetailsWhenReadFromCache) {
backend_controller()->SetFetchScreenUpdateInfoResponseSize(0);
Init();
FetchImage();
FastForwardByPhotoRefreshInterval();
// Topics is empty. Will read from cache, which is empty.
PhotoWithDetails image;
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/&image,
/*next_image=*/nullptr);
EXPECT_TRUE(image.IsNull());
// Save a file to check if it gets read for display.
std::string details("image details");
WriteCacheDataBlocking(/*cache_index=*/0,
CreateEncodedImageForTesting(gfx::Size(10, 10)),
&details);
// Reset variables in photo controller.
Init();
FetchImage();
ASSERT_TRUE(RunUntilNextTopicsAdded(/*num_expected_topics=*/1));
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/&image,
/*next_image=*/nullptr);
EXPECT_FALSE(image.IsNull());
EXPECT_EQ(image.details, details);
}
// Test that image is read from disk when image decoding failed.
TEST_F(AmbientPhotoControllerTest, ShouldReadCacheWhenImageDecodingFailed) {
WriteCacheDataBlocking(/*cache_index=*/0,
CreateEncodedImageForTesting(gfx::Size(10, 10)));
WriteCacheDataBlocking(/*cache_index=*/1,
CreateEncodedImageForTesting(gfx::Size(20, 20)));
SetDownloadPhotoData("invalid-image-data");
photo_controller()->StartScreenUpdate();
ASSERT_TRUE(RunUntilImagesReady());
photo_controller()->StopScreenUpdate();
photo_controller()->StartScreenUpdate();
ASSERT_TRUE(RunUntilImagesReady());
photo_controller()->StopScreenUpdate();
}
// Test that image will refresh when have more topics.
TEST_F(AmbientPhotoControllerTest, ShouldResumeWhenHaveMoreTopics) {
backend_controller()->SetFetchScreenUpdateInfoResponseSize(0);
Init();
FetchImage();
task_environment()->RunUntilIdle();
// Topics is empty. Will read from cache, which is empty.
PhotoWithDetails image;
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/nullptr,
/*next_image=*/&image);
EXPECT_TRUE(image.IsNull());
// Backend starts returning topics again, so the `AmbientTopicQueue` should
// not longer be empty.
backend_controller()->SetFetchScreenUpdateInfoResponseSize(kTopicsBatchSize);
task_environment()->FastForwardBy(kTopicFetchInterval);
FetchTopics();
task_environment()->RunUntilIdle();
photo_controller()->ambient_backend_model()->GetCurrentAndNextImages(
/*current_image=*/nullptr,
/*next_image=*/&image);
EXPECT_FALSE(image.IsNull());
}
TEST_F(AmbientPhotoControllerTest, ShouldDownloadBackupImagesWhenScheduled) {
SetDownloadPhotoDataForUrl(
GURL(backend_controller()->GetBackupPhotoUrls()[0]),
CreateEncodedImageForTesting(gfx::Size(10, 10)));
SetDownloadPhotoDataForUrl(
GURL(backend_controller()->GetBackupPhotoUrls()[1]),
CreateEncodedImageForTesting(gfx::Size(20, 20)));
ScheduleFetchBackupImages();
EXPECT_TRUE(
photo_controller()->backup_photo_refresh_timer_for_testing().IsRunning());
// Timer is running but download has not started yet.
EXPECT_TRUE(GetSavedCacheIndices(/*backup=*/true).empty());
task_environment()->FastForwardBy(kBackupPhotoRefreshDelay);
// Timer should have stopped.
EXPECT_FALSE(
photo_controller()->backup_photo_refresh_timer_for_testing().IsRunning());
// Should have been two cache writes to backup data.
const auto& backup_data = GetBackupCachedFiles();
ASSERT_EQ(backup_data.size(), 2u);
ASSERT_TRUE(base::Contains(backup_data, 0));
ASSERT_TRUE(base::Contains(backup_data, 1));
for (const auto& i : backup_data) {
EXPECT_TRUE(i.second.primary_photo().details().empty());
EXPECT_TRUE(i.second.related_photo().image().empty());
EXPECT_TRUE(i.second.related_photo().details().empty());
}
}
TEST_F(AmbientPhotoControllerTest, ShouldResetTimerWhenBackupImagesFail) {
ScheduleFetchBackupImages();
EXPECT_TRUE(
photo_controller()->backup_photo_refresh_timer_for_testing().IsRunning());
// Simulate an error in DownloadToFile.
SetDownloadPhotoDataForUrl(
GURL(backend_controller()->GetBackupPhotoUrls()[0]), "");
SetDownloadPhotoDataForUrl(
GURL(backend_controller()->GetBackupPhotoUrls()[1]), "");
task_environment()->FastForwardBy(kBackupPhotoRefreshDelay);
EXPECT_TRUE(GetBackupCachedFiles().empty());
// Timer should have restarted.
EXPECT_TRUE(
photo_controller()->backup_photo_refresh_timer_for_testing().IsRunning());
}
TEST_F(AmbientPhotoControllerTest,
ShouldStartDownloadBackupImagesOnAmbientModeStart) {
ScheduleFetchBackupImages();
EXPECT_TRUE(
photo_controller()->backup_photo_refresh_timer_for_testing().IsRunning());
SetDownloadPhotoDataForUrl(
GURL(backend_controller()->GetBackupPhotoUrls()[0]),
CreateEncodedImageForTesting(gfx::Size(10, 10)));
SetDownloadPhotoDataForUrl(
GURL(backend_controller()->GetBackupPhotoUrls()[1]),
CreateEncodedImageForTesting(gfx::Size(20, 20)));
photo_controller()->StartScreenUpdate();
// Download should have started immediately.
EXPECT_FALSE(
photo_controller()->backup_photo_refresh_timer_for_testing().IsRunning());
task_environment()->RunUntilIdle();
// Download has triggered and backup cache directory is created. Should be
// two cache writes to backup cache.
const auto& backup_data = GetBackupCachedFiles();
ASSERT_EQ(backup_data.size(), 2u);
ASSERT_TRUE(base::Contains(backup_data, 0));
ASSERT_TRUE(base::Contains(backup_data, 1));
for (const auto& i : backup_data) {
EXPECT_TRUE(i.second.primary_photo().details().empty());
EXPECT_TRUE(i.second.related_photo().image().empty());
EXPECT_TRUE(i.second.related_photo().details().empty());
}
}
TEST_F(AmbientPhotoControllerTest, UsesBackupCacheAfterPrimaryCacheCleared) {
ScheduleFetchBackupImages();
photo_controller()->StartScreenUpdate();
task_environment()->RunUntilIdle();
photo_controller()->StopScreenUpdate();
// At this point, both the primary and backup cache should be filled with
// photos from the last "screen update". ClearCache() should only clear the
// primary cache, leaving photos in the backup cache to use.
ASSERT_FALSE(GetBackupCachedFiles().empty());
ambient_photo_cache::Clear(ambient_photo_cache::Store::kPrimary);
// Simulate an IMAX failure to leave the photo controller no choice but to
// resort to the backup cache.
backend_controller()->SetFetchScreenUpdateInfoResponseSize(0);
photo_controller()->StartScreenUpdate();
// Running until OnImagesReady() ensures the backup photos were loaded and
// ambient UI can successfully start.
ASSERT_TRUE(RunUntilImagesReady());
}
TEST_F(AmbientPhotoControllerTest, ShouldNotLoadDuplicateImages) {
testing::NiceMock<MockAmbientBackendModelObserver> mock_backend_observer;
base::ScopedObservation<AmbientBackendModel, AmbientBackendModelObserver>
scoped_observation{&mock_backend_observer};
scoped_observation.Observe(photo_controller()->ambient_backend_model());
// All images downloaded will be identical.
std::string image_data = CreateEncodedImageForTesting(gfx::Size(10, 10));
SetDownloadPhotoData(image_data);
photo_controller()->StartScreenUpdate();
ASSERT_TRUE(RunUntilNextTopicsAdded(/*num_expected_topics=*/1));
// Should contain hash of downloaded data.
EXPECT_TRUE(photo_controller()->ambient_backend_model()->IsHashDuplicate(
base::SHA1HashString(image_data)));
// Only one image should have been loaded.
EXPECT_FALSE(photo_controller()->ambient_backend_model()->ImagesReady());
// Now expect a call because second image is loaded.
EXPECT_CALL(mock_backend_observer, OnImagesReady).Times(1);
std::string image_data_2 = CreateEncodedImageForTesting(gfx::Size(20, 20));
SetDownloadPhotoData(image_data_2);
ASSERT_TRUE(RunUntilImagesReady());
// Second image should have been loaded.
EXPECT_TRUE(photo_controller()->ambient_backend_model()->IsHashDuplicate(
base::SHA1HashString(image_data_2)));
EXPECT_TRUE(photo_controller()->ambient_backend_model()->ImagesReady());
}
TEST_F(AmbientPhotoControllerTest, IsScreenUpdateActive) {
ASSERT_FALSE(photo_controller()->IsScreenUpdateActive());
photo_controller()->StartScreenUpdate();
EXPECT_TRUE(photo_controller()->IsScreenUpdateActive());
photo_controller()->StopScreenUpdate();
EXPECT_FALSE(photo_controller()->IsScreenUpdateActive());
}
TEST_F(AmbientPhotoControllerAnimationTest, AnimationPreparesInitialTopicSet) {
photo_controller()->StartScreenUpdate();
ASSERT_TRUE(RunUntilImagesReady());
EXPECT_THAT(photo_controller()->ambient_backend_model()->all_decoded_topics(),
SizeIs(photo_config().GetNumDecodedTopicsToBuffer()));
}
TEST_F(AmbientPhotoControllerAnimationTest,
AnimationRefreshesTopicSetEachCycle) {
photo_controller()->StartScreenUpdate();
// Animation starts rendering. This should trigger an image refresh.
ASSERT_TRUE(RunUntilImagesReady());
base::circular_deque<PhotoWithDetails> old_photos =
photo_controller()->ambient_backend_model()->all_decoded_topics();
ASSERT_TRUE(RunUntilNextTopicsAdded(photo_config().topic_set_size));
base::circular_deque<PhotoWithDetails> new_photos =
photo_controller()->ambient_backend_model()->all_decoded_topics();
EXPECT_THAT(new_photos, SizeIs(photo_config().GetNumDecodedTopicsToBuffer()));
ASSERT_THAT(old_photos.size(), Eq(new_photos.size()));
// Verify that the new set actually has 2 new photos and 2 photos from the
// old set.
EXPECT_THAT(new_photos[0], BackedBySameImageAs(old_photos[2]));
EXPECT_THAT(new_photos[1], BackedBySameImageAs(old_photos[3]));
EXPECT_THAT(old_photos, Not(Contains(BackedBySameImageAs(new_photos[2]))));
EXPECT_THAT(old_photos, Not(Contains(BackedBySameImageAs(new_photos[3]))));
old_photos = new_photos;
// Animation cycle ends and another image refresh starts.
photo_controller()->OnMarkerHit(AmbientPhotoConfig::Marker::kUiCycleEnded);
ASSERT_TRUE(RunUntilNextTopicsAdded(photo_config().topic_set_size));
new_photos =
photo_controller()->ambient_backend_model()->all_decoded_topics();
EXPECT_THAT(new_photos, SizeIs(photo_config().GetNumDecodedTopicsToBuffer()));
ASSERT_THAT(old_photos.size(), Eq(new_photos.size()));
EXPECT_THAT(new_photos[0], BackedBySameImageAs(old_photos[2]));
EXPECT_THAT(new_photos[1], BackedBySameImageAs(old_photos[3]));
EXPECT_THAT(old_photos, Not(Contains(BackedBySameImageAs(new_photos[2]))));
EXPECT_THAT(old_photos, Not(Contains(BackedBySameImageAs(new_photos[3]))));
}
TEST_F(AmbientPhotoControllerAnimationTest,
StopsRefreshingImagesAfterTargetAmountBuffered) {
photo_controller()->StartScreenUpdate();
ASSERT_TRUE(RunUntilImagesReady());
ASSERT_TRUE(RunUntilNextTopicsAdded(photo_config().topic_set_size));
// Fast forward time to make sure no more images are prepared after
// |kNumDynamicAssets| has been added.
base::circular_deque<PhotoWithDetails> old_photos =
photo_controller()->ambient_backend_model()->all_decoded_topics();
task_environment()->FastForwardBy(base::Minutes(1));
base::circular_deque<PhotoWithDetails> new_photos =
photo_controller()->ambient_backend_model()->all_decoded_topics();
EXPECT_THAT(photo_controller()->ambient_backend_model()->all_decoded_topics(),
SizeIs(photo_config().GetNumDecodedTopicsToBuffer()));
EXPECT_THAT(new_photos, Pointwise(BackedBySameImage(), old_photos));
}
TEST_F(AmbientPhotoControllerAnimationTest,
AnimationRefreshesAfterIncompleteTopicSet) {
photo_controller()->StartScreenUpdate();
ASSERT_TRUE(RunUntilImagesReady());
base::circular_deque<PhotoWithDetails> old_photos =
photo_controller()->ambient_backend_model()->all_decoded_topics();
ASSERT_TRUE(RunUntilNextTopicsAdded(photo_config().topic_set_size / 2));
base::circular_deque<PhotoWithDetails> new_photos =
photo_controller()->ambient_backend_model()->all_decoded_topics();
EXPECT_THAT(new_photos, SizeIs(photo_config().GetNumDecodedTopicsToBuffer()));
ASSERT_THAT(old_photos.size(), Eq(new_photos.size()));
EXPECT_THAT(new_photos[0], BackedBySameImageAs(old_photos[1]));
EXPECT_THAT(new_photos[1], BackedBySameImageAs(old_photos[2]));
EXPECT_THAT(new_photos[2], BackedBySameImageAs(old_photos[3]));
EXPECT_THAT(old_photos, Not(Contains(BackedBySameImageAs(new_photos[3]))));
old_photos = new_photos;
// Cycle ends when only half of target amount refreshed.
photo_controller()->OnMarkerHit(AmbientPhotoConfig::Marker::kUiCycleEnded);
ASSERT_TRUE(RunUntilNextTopicsAdded(photo_config().topic_set_size));
// Fast forward time to make sure no more images are prepared after
// |photo_config().topic_set_size| has been added.
task_environment()->FastForwardBy(base::Minutes(1));
new_photos =
photo_controller()->ambient_backend_model()->all_decoded_topics();
EXPECT_THAT(new_photos, SizeIs(photo_config().GetNumDecodedTopicsToBuffer()));
ASSERT_THAT(old_photos.size(), Eq(new_photos.size()));
EXPECT_THAT(new_photos[0], BackedBySameImageAs(old_photos[2]));
EXPECT_THAT(new_photos[1], BackedBySameImageAs(old_photos[3]));
EXPECT_THAT(old_photos, Not(Contains(BackedBySameImageAs(new_photos[2]))));
EXPECT_THAT(old_photos, Not(Contains(BackedBySameImageAs(new_photos[3]))));
}
TEST_F(AmbientPhotoControllerAnimationTest,
HandlesMarkerWhenInitialTopicSetIncomplete) {
constexpr base::TimeDelta kPhotoDownloadDelay = base::Seconds(5);
constexpr base::TimeDelta kTimeoutAfterFirstPhoto = base::Seconds(10);
SetPhotoDownloadDelay(kPhotoDownloadDelay);
photo_controller()->StartScreenUpdate();
task_environment()->FastForwardBy(kPhotoDownloadDelay +
kTimeoutAfterFirstPhoto);
ASSERT_TRUE(photo_controller()->ambient_backend_model()->ImagesReady());
ASSERT_THAT(photo_controller()->ambient_backend_model()->all_decoded_topics(),
SizeIs(3));
// UI starts rendering when only 3/4 of the initial topic set is prepared.
// The controller should immediately start preparing another 2 topics (the
// size of 1 topic set).
task_environment()->FastForwardBy(kPhotoDownloadDelay * 2);
ASSERT_THAT(photo_controller()->ambient_backend_model()->all_decoded_topics(),
SizeIs(photo_config().GetNumDecodedTopicsToBuffer()));
// Fast forward time to make sure no more images are prepared after
// |photo_config().topic_set_size| has been added.
base::circular_deque<PhotoWithDetails> photos_before =
photo_controller()->ambient_backend_model()->all_decoded_topics();
task_environment()->FastForwardBy(base::Minutes(1));
base::circular_deque<PhotoWithDetails> photos_after =
photo_controller()->ambient_backend_model()->all_decoded_topics();
EXPECT_THAT(photos_after, Pointwise(BackedBySameImage(), photos_before));
}
TEST_F(AmbientPhotoControllerEmptyConfigTest, CallsOnImagesReadyImmediately) {
photo_controller()->StartScreenUpdate();
ASSERT_TRUE(RunUntilImagesReady());
EXPECT_THAT(photo_controller()->ambient_backend_model()->all_decoded_topics(),
IsEmpty());
task_environment()->FastForwardBy(base::Minutes(1));
EXPECT_TRUE(photo_controller()->ambient_backend_model()->ImagesReady());
EXPECT_THAT(photo_controller()->ambient_backend_model()->all_decoded_topics(),
IsEmpty());
}
} // namespace ash
Codebase Browser
chromium