// 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/public/cpp/holding_space/holding_space_image.h"
#include <algorithm>
#include <map>
#include <set>
#include "ash/public/cpp/holding_space/holding_space_constants.h"
#include "ash/public/cpp/image_util.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/location.h"
#include "chromeos/ui/base/file_icon_util.h"
#include "ui/gfx/image/image_skia_operations.h"
#include "ui/gfx/image/image_skia_rep.h"
#include "ui/gfx/image/image_skia_source.h"
#include "ui/gfx/paint_vector_icon.h"
#include "ui/gfx/skia_util.h"
namespace ash {
namespace {
// Appearance.
constexpr int kFileTypeIconSize = 20;
// Whether image invalidation should be done without delay.
bool g_use_zero_invalidation_delay_for_testing = false;
} // namespace
// HoldingSpaceImage::ImageSkiaSource ------------------------------------------
class HoldingSpaceImage::ImageSkiaSource : public gfx::ImageSkiaSource {
public:
ImageSkiaSource(const base::WeakPtr<HoldingSpaceImage>& host,
const gfx::ImageSkia& placeholder)
: host_(host), placeholder_(placeholder) {}
ImageSkiaSource(const ImageSkiaSource&) = delete;
ImageSkiaSource& operator=(const ImageSkiaSource&) = delete;
~ImageSkiaSource() override = default;
private:
// gfx::ImageSkiaSource:
gfx::ImageSkiaRep GetImageForScale(float scale) override {
if (host_)
host_->LoadBitmap(scale);
// Use `placeholder_` while we wait for the async bitmap to resolve.
return placeholder_.GetRepresentation(scale);
}
const base::WeakPtr<HoldingSpaceImage> host_;
const gfx::ImageSkia placeholder_;
};
// HoldingSpaceImage -----------------------------------------------------------
HoldingSpaceImage::HoldingSpaceImage(const gfx::Size& max_size,
const base::FilePath& backing_file_path,
AsyncBitmapResolver async_bitmap_resolver)
: HoldingSpaceImage(max_size,
backing_file_path,
async_bitmap_resolver,
CreateDefaultPlaceholderImageSkiaResolver()) {}
HoldingSpaceImage::HoldingSpaceImage(
const gfx::Size& max_size,
const base::FilePath& backing_file_path,
AsyncBitmapResolver async_bitmap_resolver,
PlaceholderImageSkiaResolver placeholder_image_skia_resolver)
: max_size_(max_size),
backing_file_path_(backing_file_path),
async_bitmap_resolver_(async_bitmap_resolver),
placeholder_image_skia_resolver_(placeholder_image_skia_resolver) {
placeholder_ = placeholder_image_skia_resolver_.Run(
backing_file_path_, max_size_, /*dark_background=*/std::nullopt,
/*is_folder=*/std::nullopt);
CreateImageSkia();
}
HoldingSpaceImage::~HoldingSpaceImage() = default;
// static
HoldingSpaceImage::PlaceholderImageSkiaResolver
HoldingSpaceImage::CreateDefaultPlaceholderImageSkiaResolver(
bool use_light_mode_as_default) {
return base::BindRepeating(
[](bool use_light_mode_as_default,
const base::FilePath& backing_file_path, const gfx::Size& size,
const std::optional<bool>& dark_background,
const std::optional<bool>& is_folder) {
// The requested image `size` should be >= `kFileTypeIconSize` to
// give the `file_type_icon` generated below enough space to fully
// paint.
DCHECK_GE(size.height(), kFileTypeIconSize);
DCHECK_GE(size.width(), kFileTypeIconSize);
const gfx::ImageSkia file_type_icon =
is_folder.value_or(false)
? chromeos::GetIconFromType(
chromeos::IconType::kFolder,
dark_background.value_or(!use_light_mode_as_default))
: chromeos::GetIconForPath(
backing_file_path,
dark_background.value_or(!use_light_mode_as_default));
return gfx::ImageSkiaOperations::CreateSuperimposedImage(
image_util::CreateEmptyImage(size), file_type_icon);
},
use_light_mode_as_default);
}
// static
void HoldingSpaceImage::SetUseZeroInvalidationDelayForTesting(bool value) {
g_use_zero_invalidation_delay_for_testing = value;
}
bool HoldingSpaceImage::operator==(const HoldingSpaceImage& rhs) const {
return gfx::BitmapsAreEqual(*image_skia_.bitmap(), *rhs.image_skia_.bitmap());
}
base::CallbackListSubscription HoldingSpaceImage::AddImageSkiaChangedCallback(
CallbackList::CallbackType callback) const {
return callback_list_.Add(std::move(callback));
}
void HoldingSpaceImage::LoadBitmap(float scale) {
async_bitmap_resolver_.Run(
backing_file_path_, gfx::ScaleToCeiledSize(image_skia_.size(), scale),
base::BindOnce(&HoldingSpaceImage::OnBitmapLoaded,
weak_factory_.GetWeakPtr(), backing_file_path_, scale));
}
void HoldingSpaceImage::OnBitmapLoaded(const base::FilePath& file_path,
float scale,
const SkBitmap* bitmap,
base::File::Error error) {
if (!bitmap) {
DCHECK_NE(error, base::File::FILE_OK);
if (backing_file_path_ != file_path) {
// Retry load if the backing file path has changed while the image load
// was in progress.
LoadBitmap(scale);
} else {
// A new `error` may mean a better file type image can be displayed. The
// `error`, for example, may indicate that the file is in fact a folder in
// which case there is a more appropriate icon that can be shown. Notify
// subscribers to invalidate themselves.
async_bitmap_resolver_error_ = error;
callback_list_.Notify();
}
return;
}
DCHECK_EQ(error, base::File::FILE_OK);
async_bitmap_resolver_error_ = base::File::FILE_OK;
// Force invalidate `image_skia_` for `scale` so that it will request the
// updated `gfx::ImageSkiaRep` at next access.
image_skia_.RemoveRepresentation(scale);
image_skia_.AddRepresentation(gfx::ImageSkiaRep(*bitmap, scale));
image_skia_.RemoveUnsupportedRepresentationsForScale(scale);
// Update the placeholder image, so the newly loaded representation becomes
// the default for any `ImageSkia` instances created when the holding space
// image gets invalidated.
placeholder_.RemoveRepresentation(scale);
placeholder_.AddRepresentation(gfx::ImageSkiaRep(*bitmap, scale));
placeholder_.RemoveUnsupportedRepresentationsForScale(scale);
callback_list_.Notify();
}
gfx::ImageSkia HoldingSpaceImage::GetImageSkia(
const std::optional<gfx::Size>& opt_size,
bool dark_background) const {
const gfx::Size size = opt_size.value_or(max_size_);
// Requested `size` must be less than or equal to `max_size_` to avoid
// pixelation that would otherwise occur due to upscaling.
DCHECK_LE(size.height(), max_size_.height());
DCHECK_LE(size.width(), max_size_.width());
// When an error occurs, fallback to a resolved placeholder image.
if (async_bitmap_resolver_error_ &&
async_bitmap_resolver_error_ != base::File::FILE_OK) {
return placeholder_image_skia_resolver_.Run(
backing_file_path_, size, dark_background,
/*is_folder=*/async_bitmap_resolver_error_ ==
base::File::FILE_ERROR_NOT_A_FILE);
}
// Short-circuit resizing logic.
if (image_skia_.size() == size)
return image_skia_;
return image_util::ResizeAndCropImage(image_skia_, size);
}
void HoldingSpaceImage::Invalidate() {
if (invalidate_timer_.IsRunning())
return;
// Schedule an invalidation task with a delay to reduce number of image loads
// when multiple image invalidations are requested in quick succession. The
// delay is selected somewhat arbitrarily to be non trivial but still not
// easily noticeable by the user.
invalidate_timer_.Start(FROM_HERE,
g_use_zero_invalidation_delay_for_testing
? base::TimeDelta()
: base::Milliseconds(250),
base::BindOnce(&HoldingSpaceImage::OnInvalidateTimer,
base::Unretained(this)));
}
void HoldingSpaceImage::UpdateBackingFilePath(const base::FilePath& file_path) {
backing_file_path_ = file_path;
}
bool HoldingSpaceImage::UsingPlaceholder() const {
return !async_bitmap_resolver_error_ ||
*async_bitmap_resolver_error_ != base::File::FILE_OK;
}
bool HoldingSpaceImage::FireInvalidateTimerForTesting() {
if (!invalidate_timer_.IsRunning())
return false;
invalidate_timer_.FireNow();
return true;
}
void HoldingSpaceImage::OnInvalidateTimer() {
// Invalidate the existing pointers to:
// * Invalidate the previous `image_skia_`'s host pointer, and prevent it
// from requesting bitmap loads.
// * Prevent pending bitmap request callbacks from running.
weak_factory_.InvalidateWeakPtrs();
// Cache scales for which the previous `image_skia_` has reps.
std::set<float> scales;
for (const gfx::ImageSkiaRep& image_rep : image_skia_.image_reps())
scales.insert(image_rep.scale());
// Create a new `image_skia_`.
CreateImageSkia();
// If the `async_bitmap_resolver_` has not previously failed, notify
// subscribers that the `image_skia_` has been invalidated. A new bitmap will
// be asynchronously resolved at the next `GetImageSkia()` invocation.
if (!async_bitmap_resolver_error_ ||
async_bitmap_resolver_error_ == base::File::FILE_OK) {
callback_list_.Notify();
return;
}
// If the `async_bitmap_resolver_` failed previously, force asynchronous
// resolution of new bitmaps. Failure to do so would cause `GetImageSkia()`
// invocations to continue returning placeholders. Note that subscribers will
// be notified of `image_skia_` invalidation when the `async_bitmap_resolver_`
// returns.
DCHECK(!scales.empty());
for (const float& scale : scales)
image_skia_.GetRepresentation(scale);
}
void HoldingSpaceImage::CreateImageSkia() {
image_skia_ =
gfx::ImageSkia(std::make_unique<ImageSkiaSource>(
/*host=*/weak_factory_.GetWeakPtr(), placeholder_),
max_size_);
}
} // namespace ash
Codebase Browser
chromium