chrome/browser/thumbnail/cc/etc1_thumbnail_helper.cc - chromium/src - Git at Google

 // Copyright 2023 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #ifdef UNSAFE_BUFFERS_BUILD
 // TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
 #pragma allow_unsafe_buffers
 #endif

 #include "chrome/browser/thumbnail/cc/etc1_thumbnail_helper.h"

 #include <array>

 #include "base/containers/span.h"
 #include "base/feature_list.h"
 #include "base/files/file_util.h"
 #include "base/numerics/byte_conversions.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task/bind_post_task.h"
 #include "base/task/sequenced_task_runner.h"
 #include "base/task/thread_pool.h"
 #include "build/build_config.h"
 #include "third_party/android_opengl/etc1/etc1.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkMallocPixelRef.h"
 #include "ui/android/resources/ui_resource_provider.h"
 #include "ui/display/screen.h"

 namespace thumbnail {
 namespace {

 const uint32_t kCompressedKey = 0xABABABAB;
 const uint32_t kCurrentExtraVersion = 1;

 unsigned int NextPowerOfTwo(int a) {
   DCHECK(a >= 0);
   auto x = static_cast<unsigned int>(a);
   --x;
   x |= x >> 1u;
   x |= x >> 2u;
   x |= x >> 4u;
   x |= x >> 8u;
   x |= x >> 16u;
   return x + 1;
 }

 bool ReadBigEndianU32FromFile(base::File& file, uint32_t* out) {
   std::array<uint8_t, sizeof(*out)> buffer;
   if (file.ReadAtCurrentPos(buffer).value_or(0u) != buffer.size()) {
     return false;
   }
   *out = base::U32FromBigEndian(buffer);
   return true;
 }
 bool ReadBigEndianFloatFromFile(base::File& file, float* out) {
   std::array<uint8_t, sizeof(*out)> buffer;
   if (file.ReadAtCurrentPos(buffer).value_or(0u) != buffer.size()) {
     return false;
   }
   *out = base::FloatFromBigEndian(buffer);
   return true;
 }

 bool WriteBigEndianU32ToFile(base::File& file,
                              base::StrictNumeric<uint32_t> v) {
   return file.WriteAtCurrentPos(base::U32ToBigEndian(v)) == sizeof(v);
 }
 bool WriteBigEndianFloatToFile(base::File& file, float v) {
   return file.WriteAtCurrentPos(base::FloatToBigEndian(v)) == sizeof(v);
 }

 // TODO(khushalsagar): This is a hack to ensure correct byte size computation
 // for SkPixelRefs wrapping encoded data for ETC1 compressed bitmaps. We ideally
 // shouldn't be using SkPixelRefs to wrap encoded data.
 size_t ETC1RowBytes(int width) {
   DCHECK_EQ(width & 1, 0);
   return width / 2;
 }

 bool WriteToFile(base::File& file,
                  const gfx::Size& content_size,
                  const float scale,
                  sk_sp<SkPixelRef> compressed_data) {
   if (!file.IsValid()) {
     return false;
   }

   if (!WriteBigEndianU32ToFile(file, kCompressedKey)) {
     return false;
   }

   if (!WriteBigEndianU32ToFile(
           file, base::checked_cast<uint32_t>(content_size.width()))) {
     return false;
   }

   if (!WriteBigEndianU32ToFile(
           file, base::checked_cast<uint32_t>(content_size.height()))) {
     return false;
   }

   // Write ETC1 header.
   CHECK(compressed_data->width() >= 0);
   CHECK(compressed_data->height() >= 0);
   unsigned width = static_cast<unsigned>(compressed_data->width());
   unsigned height = static_cast<unsigned>(compressed_data->height());

   unsigned char etc1_buffer[ETC_PKM_HEADER_SIZE];
   etc1_pkm_format_header(etc1_buffer, width, height);

   int header_bytes_written = file.WriteAtCurrentPos(
       reinterpret_cast<char*>(etc1_buffer), ETC_PKM_HEADER_SIZE);
   if (header_bytes_written != ETC_PKM_HEADER_SIZE) {
     return false;
   }

   int data_size = etc1_get_encoded_data_size(width, height);
   int pixel_bytes_written = file.WriteAtCurrentPos(
       reinterpret_cast<char*>(compressed_data->pixels()), data_size);
   if (pixel_bytes_written != data_size) {
     return false;
   }

   if (!WriteBigEndianU32ToFile(file, kCurrentExtraVersion)) {
     return false;
   }

   if (!WriteBigEndianFloatToFile(file, 1.f / scale)) {
     return false;
   }

   return true;
 }

 bool ReadFromFile(base::File& file,
                   gfx::Size* out_content_size,
                   float* out_scale,
                   sk_sp<SkPixelRef>* out_pixels) {
   if (!file.IsValid()) {
     return false;
   }

   uint32_t key = 0;
   if (!ReadBigEndianU32FromFile(file, &key)) {
     return false;
   }

   if (key != kCompressedKey) {
     return false;
   }

   int content_width;
   {
     uint32_t val = 0;
     if (!ReadBigEndianU32FromFile(file, &val) || val == 0u ||
         !base::IsValueInRangeForNumericType<int>(val)) {
       return false;
     }
     content_width = base::checked_cast<int>(val);
   }

   int content_height;
   {
     uint32_t val = 0;
     if (!ReadBigEndianU32FromFile(file, &val) || val == 0u ||
         !base::IsValueInRangeForNumericType<int>(val)) {
       return false;
     }
     content_height = base::checked_cast<int>(val);
   }

   out_content_size->SetSize(content_width, content_height);

   // Read ETC1 header.
   int header_bytes_read = 0;
   unsigned char etc1_buffer[ETC_PKM_HEADER_SIZE];
   header_bytes_read = file.ReadAtCurrentPos(
       reinterpret_cast<char*>(etc1_buffer), ETC_PKM_HEADER_SIZE);
   if (header_bytes_read != ETC_PKM_HEADER_SIZE) {
     return false;
   }

   if (!etc1_pkm_is_valid(etc1_buffer)) {
     return false;
   }

   int raw_width = 0;
   raw_width = etc1_pkm_get_width(etc1_buffer);
   if (raw_width <= 0) {
     return false;
   }

   int raw_height = 0;
   raw_height = etc1_pkm_get_height(etc1_buffer);
   if (raw_height <= 0) {
     return false;
   }

   // Do some simple sanity check validation.  We can't have thumbnails larger
   // than the max display size of the screen.  We also can't have etc1 texture
   // data larger than the next power of 2 up from that.
   gfx::Size display_size =
       display::Screen::GetScreen()->GetPrimaryDisplay().GetSizeInPixel();
   int max_dimension = std::max(display_size.width(), display_size.height());

   if (content_width > max_dimension || content_height > max_dimension ||
       static_cast<size_t>(raw_width) > NextPowerOfTwo(max_dimension) ||
       static_cast<size_t>(raw_height) > NextPowerOfTwo(max_dimension)) {
     return false;
   }

   int data_size = etc1_get_encoded_data_size(raw_width, raw_height);
   sk_sp<SkData> etc1_pixel_data(SkData::MakeUninitialized(data_size));

   int pixel_bytes_read = file.ReadAtCurrentPos(
       reinterpret_cast<char*>(etc1_pixel_data->writable_data()), data_size);

   if (pixel_bytes_read != data_size) {
     return false;
   }

   SkImageInfo info = SkImageInfo::Make(
       raw_width, raw_height, kUnknown_SkColorType, kUnpremul_SkAlphaType);

   *out_pixels = SkMallocPixelRef::MakeWithData(info, ETC1RowBytes(raw_width),
                                                std::move(etc1_pixel_data));

   uint32_t extra_data_version = 0;
   if (!ReadBigEndianU32FromFile(file, &extra_data_version)) {
     return false;
   }

   *out_scale = 1.f;
   if (extra_data_version == 1u) {
     if (!ReadBigEndianFloatFromFile(file, out_scale)) {
       return false;
     }

     if (*out_scale == 0.f) {
       return false;
     }

     *out_scale = 1.f / *out_scale;
   }

   return true;
 }

 void CompressTask(SkBitmap raw_data,
                   bool supports_etc_non_power_of_two,
                   base::OnceCallback<void(sk_sp<SkPixelRef>, const gfx::Size&)>
                       post_compression_task) {
   sk_sp<SkPixelRef> compressed_data = nullptr;

   if (base::FeatureList::IsEnabled(ui::kCompressBitmapAtBackgroundPriority)) {
     compressed_data =
         ui::UIResourceProvider::CompressBitmapAtBackgroundPriority(
             raw_data, supports_etc_non_power_of_two);
   } else {
     compressed_data = ui::UIResourceProvider::CompressBitmap(
         raw_data, supports_etc_non_power_of_two);
   }
   gfx::Size content_size = compressed_data
                                ? gfx::Size(raw_data.width(), raw_data.height())
                                : gfx::Size();
   std::move(post_compression_task)
       .Run(std::move(compressed_data), content_size);
 }

 void WriteTask(base::FilePath file_path,
                sk_sp<SkPixelRef> compressed_data,
                float scale,
                const gfx::Size& content_size,
                base::OnceClosure post_write_task) {
   DCHECK(compressed_data);

   base::File file(file_path,
                   base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);

   bool success = WriteToFile(file, content_size, scale, compressed_data);

   file.Close();

   if (!success) {
     base::DeleteFile(file_path);
   }

   std::move(post_write_task).Run();
 }

 void ReadTask(
     base::FilePath file_path,
     base::OnceCallback<void(sk_sp<SkPixelRef>, float, const gfx::Size&)>
         post_read_task) {
   gfx::Size content_size;
   float scale = 0.f;
   sk_sp<SkPixelRef> compressed_data;

   if (base::PathExists(file_path)) {
     base::File file(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);

     bool valid_contents =
         ReadFromFile(file, &content_size, &scale, &compressed_data);
     file.Close();

     if (!valid_contents) {
       content_size.SetSize(0, 0);
       scale = 0.f;
       compressed_data.reset();
       base::DeleteFile(file_path);
     }
   }

   std::move(post_read_task)
       .Run(std::move(compressed_data), scale, content_size);
 }

 void DeleteTask(base::FilePath file_path) {
   if (base::PathExists(file_path)) {
     base::DeleteFile(file_path);
   }
 }

 void DecompressTask(
     base::OnceCallback<void(bool, const SkBitmap&)> post_decompression_callback,
     sk_sp<SkPixelRef> compressed_data,
     float scale,
     const gfx::Size& content_size) {
   SkBitmap raw_data_small;
   bool success = false;

   if (compressed_data) {
     gfx::Size buffer_size =
         gfx::Size(compressed_data->width(), compressed_data->height());

     SkBitmap raw_data;
     raw_data.allocPixels(SkImageInfo::MakeN32(
         buffer_size.width(), buffer_size.height(), kOpaque_SkAlphaType));
     success = etc1_decode_image(
         reinterpret_cast<unsigned char*>(compressed_data->pixels()),
         reinterpret_cast<unsigned char*>(raw_data.getPixels()),
         buffer_size.width(), buffer_size.height(), raw_data.bytesPerPixel(),
         raw_data.rowBytes());
     raw_data.setImmutable();

     if (!success) {
       // Leave raw_data_small empty for consistency with other failure modes.
     } else if (content_size == buffer_size) {
       // Shallow copy the pixel reference.
       raw_data_small = raw_data;
     } else {
       // The content size is smaller than the buffer size (likely because of
       // a power-of-two rounding), so deep copy the bitmap.
       raw_data_small.allocPixels(SkImageInfo::MakeN32(
           content_size.width(), content_size.height(), kOpaque_SkAlphaType));
       SkCanvas small_canvas(raw_data_small);
       small_canvas.drawImage(raw_data.asImage(), 0, 0);
       raw_data_small.setImmutable();
     }
   }

   std::move(post_decompression_callback).Run(success, raw_data_small);
 }

 }  // anonymous namespace

 Etc1ThumbnailHelper::Etc1ThumbnailHelper(
     const base::FilePath& base_path,
     scoped_refptr<base::SequencedTaskRunner> file_task_runner)
     : base_path_(base_path),
       default_task_runner_(base::SequencedTaskRunner::GetCurrentDefault()),
       file_task_runner_(file_task_runner) {}

 Etc1ThumbnailHelper::~Etc1ThumbnailHelper() {
   DCHECK(default_task_runner_->RunsTasksInCurrentSequence());
 }

 void Etc1ThumbnailHelper::Compress(
     SkBitmap raw_data,
     bool supports_etc_non_power_of_two,
     base::OnceCallback<void(sk_sp<SkPixelRef>, const gfx::Size&)>
         post_compression_task) {
   DCHECK(default_task_runner_->RunsTasksInCurrentSequence());
   base::ThreadPool::PostTask(
       FROM_HERE,
       {base::TaskPriority::BEST_EFFORT,
        base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
       base::BindOnce(&CompressTask, raw_data, supports_etc_non_power_of_two,
                      base::BindPostTask(default_task_runner_,
                                         std::move(post_compression_task))));
 }

 void Etc1ThumbnailHelper::Write(TabId tab_id,
                                 sk_sp<SkPixelRef> compressed_data,
                                 float scale,
                                 const gfx::Size& content_size,
                                 base::OnceClosure post_write_task) {
   DCHECK(default_task_runner_->RunsTasksInCurrentSequence());
   base::FilePath file_path = GetFilePath(tab_id);
   file_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(&WriteTask, file_path, compressed_data, scale,
                      content_size,
                      base::BindPostTask(default_task_runner_,
                                         std::move(post_write_task))));
 }

 // Note: When calling this function, please check that the correct thread is
 // being bound to for post_read_task
 void Etc1ThumbnailHelper::Read(
     TabId tab_id,
     base::OnceCallback<void(sk_sp<SkPixelRef>, float, const gfx::Size&)>
         post_read_task) {
   DCHECK(default_task_runner_->RunsTasksInCurrentSequence());
   base::FilePath file_path = GetFilePath(tab_id);
   file_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(&ReadTask, file_path, std::move(post_read_task)));
 }

 void Etc1ThumbnailHelper::Delete(TabId tab_id) {
   DCHECK(default_task_runner_->RunsTasksInCurrentSequence());
   base::FilePath file_path = GetFilePath(tab_id);
   file_task_runner_->PostTask(FROM_HERE,
                               base::BindOnce(&DeleteTask, file_path));
 }

 void Etc1ThumbnailHelper::Decompress(
     base::OnceCallback<void(bool, const SkBitmap&)> post_decompression_callback,
     sk_sp<SkPixelRef> compressed_data,
     float scale,
     const gfx::Size& content_size) {
   DCHECK(default_task_runner_->RunsTasksInCurrentSequence());
   base::ThreadPool::PostTask(
       FROM_HERE,
       {base::TaskPriority::BEST_EFFORT,
        base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
       base::BindOnce(&DecompressTask,
                      base::BindPostTask(default_task_runner_,
                                         std::move(post_decompression_callback)),
                      compressed_data, scale, content_size));
 }

 base::FilePath Etc1ThumbnailHelper::GetFilePath(TabId tab_id) {
   return base_path_.Append(base::NumberToString(tab_id));
 }

 }  // namespace thumbnail
	// Copyright 2023 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#ifdef UNSAFE_BUFFERS_BUILD
	// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
	#pragma allow_unsafe_buffers
	#endif

	#include "chrome/browser/thumbnail/cc/etc1_thumbnail_helper.h"

	#include <array>

	#include "base/containers/span.h"
	#include "base/feature_list.h"
	#include "base/files/file_util.h"
	#include "base/numerics/byte_conversions.h"
	#include "base/numerics/safe_conversions.h"
	#include "base/strings/string_number_conversions.h"
	#include "base/task/bind_post_task.h"
	#include "base/task/sequenced_task_runner.h"
	#include "base/task/thread_pool.h"
	#include "build/build_config.h"
	#include "third_party/android_opengl/etc1/etc1.h"
	#include "third_party/skia/include/core/SkData.h"
	#include "third_party/skia/include/core/SkImage.h"
	#include "third_party/skia/include/core/SkMallocPixelRef.h"
	#include "ui/android/resources/ui_resource_provider.h"
	#include "ui/display/screen.h"

	namespace thumbnail {
	namespace {

	const uint32_t kCompressedKey = 0xABABABAB;
	const uint32_t kCurrentExtraVersion = 1;

	unsigned int NextPowerOfTwo(int a) {
	DCHECK(a >= 0);
	auto x = static_cast<unsigned int>(a);
	--x;
	x \|= x >> 1u;
	x \|= x >> 2u;
	x \|= x >> 4u;
	x \|= x >> 8u;
	x \|= x >> 16u;
	return x + 1;
	}

	bool ReadBigEndianU32FromFile(base::File& file, uint32_t* out) {
	std::array<uint8_t, sizeof(*out)> buffer;
	if (file.ReadAtCurrentPos(buffer).value_or(0u) != buffer.size()) {
	return false;
	}
	*out = base::U32FromBigEndian(buffer);
	return true;
	}
	bool ReadBigEndianFloatFromFile(base::File& file, float* out) {
	std::array<uint8_t, sizeof(*out)> buffer;
	if (file.ReadAtCurrentPos(buffer).value_or(0u) != buffer.size()) {
	return false;
	}
	*out = base::FloatFromBigEndian(buffer);
	return true;
	}

	bool WriteBigEndianU32ToFile(base::File& file,
	base::StrictNumeric<uint32_t> v) {
	return file.WriteAtCurrentPos(base::U32ToBigEndian(v)) == sizeof(v);
	}
	bool WriteBigEndianFloatToFile(base::File& file, float v) {
	return file.WriteAtCurrentPos(base::FloatToBigEndian(v)) == sizeof(v);
	}

	// TODO(khushalsagar): This is a hack to ensure correct byte size computation
	// for SkPixelRefs wrapping encoded data for ETC1 compressed bitmaps. We ideally
	// shouldn't be using SkPixelRefs to wrap encoded data.
	size_t ETC1RowBytes(int width) {
	DCHECK_EQ(width & 1, 0);
	return width / 2;
	}

	bool WriteToFile(base::File& file,
	const gfx::Size& content_size,
	const float scale,
	sk_sp<SkPixelRef> compressed_data) {
	if (!file.IsValid()) {
	return false;
	}

	if (!WriteBigEndianU32ToFile(file, kCompressedKey)) {
	return false;
	}

	if (!WriteBigEndianU32ToFile(
	file, base::checked_cast<uint32_t>(content_size.width()))) {
	return false;
	}

	if (!WriteBigEndianU32ToFile(
	file, base::checked_cast<uint32_t>(content_size.height()))) {
	return false;
	}

	// Write ETC1 header.
	CHECK(compressed_data->width() >= 0);
	CHECK(compressed_data->height() >= 0);
	unsigned width = static_cast<unsigned>(compressed_data->width());
	unsigned height = static_cast<unsigned>(compressed_data->height());

	unsigned char etc1_buffer[ETC_PKM_HEADER_SIZE];
	etc1_pkm_format_header(etc1_buffer, width, height);

	int header_bytes_written = file.WriteAtCurrentPos(
	reinterpret_cast<char*>(etc1_buffer), ETC_PKM_HEADER_SIZE);
	if (header_bytes_written != ETC_PKM_HEADER_SIZE) {
	return false;
	}

	int data_size = etc1_get_encoded_data_size(width, height);
	int pixel_bytes_written = file.WriteAtCurrentPos(
	reinterpret_cast<char*>(compressed_data->pixels()), data_size);
	if (pixel_bytes_written != data_size) {
	return false;
	}

	if (!WriteBigEndianU32ToFile(file, kCurrentExtraVersion)) {
	return false;
	}

	if (!WriteBigEndianFloatToFile(file, 1.f / scale)) {
	return false;
	}

	return true;
	}

	bool ReadFromFile(base::File& file,
	gfx::Size* out_content_size,
	float* out_scale,
	sk_sp<SkPixelRef>* out_pixels) {
	if (!file.IsValid()) {
	return false;
	}

	uint32_t key = 0;
	if (!ReadBigEndianU32FromFile(file, &key)) {
	return false;
	}

	if (key != kCompressedKey) {
	return false;
	}

	int content_width;
	{
	uint32_t val = 0;
	if (!ReadBigEndianU32FromFile(file, &val) \|\| val == 0u \|\|
	!base::IsValueInRangeForNumericType<int>(val)) {
	return false;
	}
	content_width = base::checked_cast<int>(val);
	}

	int content_height;
	{
	uint32_t val = 0;
	if (!ReadBigEndianU32FromFile(file, &val) \|\| val == 0u \|\|
	!base::IsValueInRangeForNumericType<int>(val)) {
	return false;
	}
	content_height = base::checked_cast<int>(val);
	}

	out_content_size->SetSize(content_width, content_height);

	// Read ETC1 header.
	int header_bytes_read = 0;
	unsigned char etc1_buffer[ETC_PKM_HEADER_SIZE];
	header_bytes_read = file.ReadAtCurrentPos(
	reinterpret_cast<char*>(etc1_buffer), ETC_PKM_HEADER_SIZE);
	if (header_bytes_read != ETC_PKM_HEADER_SIZE) {
	return false;
	}

	if (!etc1_pkm_is_valid(etc1_buffer)) {
	return false;
	}

	int raw_width = 0;
	raw_width = etc1_pkm_get_width(etc1_buffer);
	if (raw_width <= 0) {
	return false;
	}

	int raw_height = 0;
	raw_height = etc1_pkm_get_height(etc1_buffer);
	if (raw_height <= 0) {
	return false;
	}

	// Do some simple sanity check validation. We can't have thumbnails larger
	// than the max display size of the screen. We also can't have etc1 texture
	// data larger than the next power of 2 up from that.
	gfx::Size display_size =
	display::Screen::GetScreen()->GetPrimaryDisplay().GetSizeInPixel();
	int max_dimension = std::max(display_size.width(), display_size.height());

	if (content_width > max_dimension \|\| content_height > max_dimension \|\|
	static_cast<size_t>(raw_width) > NextPowerOfTwo(max_dimension) \|\|
	static_cast<size_t>(raw_height) > NextPowerOfTwo(max_dimension)) {
	return false;
	}

	int data_size = etc1_get_encoded_data_size(raw_width, raw_height);
	sk_sp<SkData> etc1_pixel_data(SkData::MakeUninitialized(data_size));

	int pixel_bytes_read = file.ReadAtCurrentPos(
	reinterpret_cast<char*>(etc1_pixel_data->writable_data()), data_size);

	if (pixel_bytes_read != data_size) {
	return false;
	}

	SkImageInfo info = SkImageInfo::Make(
	raw_width, raw_height, kUnknown_SkColorType, kUnpremul_SkAlphaType);

	*out_pixels = SkMallocPixelRef::MakeWithData(info, ETC1RowBytes(raw_width),
	std::move(etc1_pixel_data));

	uint32_t extra_data_version = 0;
	if (!ReadBigEndianU32FromFile(file, &extra_data_version)) {
	return false;
	}

	*out_scale = 1.f;
	if (extra_data_version == 1u) {
	if (!ReadBigEndianFloatFromFile(file, out_scale)) {
	return false;
	}

	if (*out_scale == 0.f) {
	return false;
	}

	out_scale = 1.f / out_scale;
	}

	return true;
	}

	void CompressTask(SkBitmap raw_data,
	bool supports_etc_non_power_of_two,
	base::OnceCallback<void(sk_sp<SkPixelRef>, const gfx::Size&)>
	post_compression_task) {
	sk_sp<SkPixelRef> compressed_data = nullptr;

	if (base::FeatureList::IsEnabled(ui::kCompressBitmapAtBackgroundPriority)) {
	compressed_data =
	ui::UIResourceProvider::CompressBitmapAtBackgroundPriority(
	raw_data, supports_etc_non_power_of_two);
	} else {
	compressed_data = ui::UIResourceProvider::CompressBitmap(
	raw_data, supports_etc_non_power_of_two);
	}
	gfx::Size content_size = compressed_data
	? gfx::Size(raw_data.width(), raw_data.height())
	: gfx::Size();
	std::move(post_compression_task)
	.Run(std::move(compressed_data), content_size);
	}

	void WriteTask(base::FilePath file_path,
	sk_sp<SkPixelRef> compressed_data,
	float scale,
	const gfx::Size& content_size,
	base::OnceClosure post_write_task) {
	DCHECK(compressed_data);

	base::File file(file_path,
	base::File::FLAG_CREATE_ALWAYS \| base::File::FLAG_WRITE);

	bool success = WriteToFile(file, content_size, scale, compressed_data);

	file.Close();

	if (!success) {
	base::DeleteFile(file_path);
	}

	std::move(post_write_task).Run();
	}

	void ReadTask(
	base::FilePath file_path,
	base::OnceCallback<void(sk_sp<SkPixelRef>, float, const gfx::Size&)>
	post_read_task) {
	gfx::Size content_size;
	float scale = 0.f;
	sk_sp<SkPixelRef> compressed_data;

	if (base::PathExists(file_path)) {
	base::File file(file_path, base::File::FLAG_OPEN \| base::File::FLAG_READ);

	bool valid_contents =
	ReadFromFile(file, &content_size, &scale, &compressed_data);
	file.Close();

	if (!valid_contents) {
	content_size.SetSize(0, 0);
	scale = 0.f;
	compressed_data.reset();
	base::DeleteFile(file_path);
	}
	}

	std::move(post_read_task)
	.Run(std::move(compressed_data), scale, content_size);
	}

	void DeleteTask(base::FilePath file_path) {
	if (base::PathExists(file_path)) {
	base::DeleteFile(file_path);
	}
	}

	void DecompressTask(
	base::OnceCallback<void(bool, const SkBitmap&)> post_decompression_callback,
	sk_sp<SkPixelRef> compressed_data,
	float scale,
	const gfx::Size& content_size) {
	SkBitmap raw_data_small;
	bool success = false;

	if (compressed_data) {
	gfx::Size buffer_size =
	gfx::Size(compressed_data->width(), compressed_data->height());

	SkBitmap raw_data;
	raw_data.allocPixels(SkImageInfo::MakeN32(
	buffer_size.width(), buffer_size.height(), kOpaque_SkAlphaType));
	success = etc1_decode_image(
	reinterpret_cast<unsigned char*>(compressed_data->pixels()),
	reinterpret_cast<unsigned char*>(raw_data.getPixels()),
	buffer_size.width(), buffer_size.height(), raw_data.bytesPerPixel(),
	raw_data.rowBytes());
	raw_data.setImmutable();

	if (!success) {
	// Leave raw_data_small empty for consistency with other failure modes.
	} else if (content_size == buffer_size) {
	// Shallow copy the pixel reference.
	raw_data_small = raw_data;
	} else {
	// The content size is smaller than the buffer size (likely because of
	// a power-of-two rounding), so deep copy the bitmap.
	raw_data_small.allocPixels(SkImageInfo::MakeN32(
	content_size.width(), content_size.height(), kOpaque_SkAlphaType));
	SkCanvas small_canvas(raw_data_small);
	small_canvas.drawImage(raw_data.asImage(), 0, 0);
	raw_data_small.setImmutable();
	}
	}

	std::move(post_decompression_callback).Run(success, raw_data_small);
	}

	} // anonymous namespace

	Etc1ThumbnailHelper::Etc1ThumbnailHelper(
	const base::FilePath& base_path,
	scoped_refptr<base::SequencedTaskRunner> file_task_runner)
	: base_path_(base_path),
	default_task_runner_(base::SequencedTaskRunner::GetCurrentDefault()),
	file_task_runner_(file_task_runner) {}

	Etc1ThumbnailHelper::~Etc1ThumbnailHelper() {
	DCHECK(default_task_runner_->RunsTasksInCurrentSequence());
	}

	void Etc1ThumbnailHelper::Compress(
	SkBitmap raw_data,
	bool supports_etc_non_power_of_two,
	base::OnceCallback<void(sk_sp<SkPixelRef>, const gfx::Size&)>
	post_compression_task) {
	DCHECK(default_task_runner_->RunsTasksInCurrentSequence());
	base::ThreadPool::PostTask(
	FROM_HERE,
	{base::TaskPriority::BEST_EFFORT,
	base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
	base::BindOnce(&CompressTask, raw_data, supports_etc_non_power_of_two,
	base::BindPostTask(default_task_runner_,
	std::move(post_compression_task))));
	}

	void Etc1ThumbnailHelper::Write(TabId tab_id,
	sk_sp<SkPixelRef> compressed_data,
	float scale,
	const gfx::Size& content_size,
	base::OnceClosure post_write_task) {
	DCHECK(default_task_runner_->RunsTasksInCurrentSequence());
	base::FilePath file_path = GetFilePath(tab_id);
	file_task_runner_->PostTask(
	FROM_HERE,
	base::BindOnce(&WriteTask, file_path, compressed_data, scale,
	content_size,
	base::BindPostTask(default_task_runner_,
	std::move(post_write_task))));
	}

	// Note: When calling this function, please check that the correct thread is
	// being bound to for post_read_task
	void Etc1ThumbnailHelper::Read(
	TabId tab_id,
	base::OnceCallback<void(sk_sp<SkPixelRef>, float, const gfx::Size&)>
	post_read_task) {
	DCHECK(default_task_runner_->RunsTasksInCurrentSequence());
	base::FilePath file_path = GetFilePath(tab_id);
	file_task_runner_->PostTask(
	FROM_HERE,
	base::BindOnce(&ReadTask, file_path, std::move(post_read_task)));
	}

	void Etc1ThumbnailHelper::Delete(TabId tab_id) {
	DCHECK(default_task_runner_->RunsTasksInCurrentSequence());
	base::FilePath file_path = GetFilePath(tab_id);
	file_task_runner_->PostTask(FROM_HERE,
	base::BindOnce(&DeleteTask, file_path));
	}

	void Etc1ThumbnailHelper::Decompress(
	base::OnceCallback<void(bool, const SkBitmap&)> post_decompression_callback,
	sk_sp<SkPixelRef> compressed_data,
	float scale,
	const gfx::Size& content_size) {
	DCHECK(default_task_runner_->RunsTasksInCurrentSequence());
	base::ThreadPool::PostTask(
	FROM_HERE,
	{base::TaskPriority::BEST_EFFORT,
	base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
	base::BindOnce(&DecompressTask,
	base::BindPostTask(default_task_runner_,
	std::move(post_decompression_callback)),
	compressed_data, scale, content_size));
	}

	base::FilePath Etc1ThumbnailHelper::GetFilePath(TabId tab_id) {
	return base_path_.Append(base::NumberToString(tab_id));
	}

	} // namespace thumbnail