Add offline pages model tasks for thumbnails

These are all the tasks required to save, load, and cleanup
thumbnails.

base change: https://chromium-review.googlesource.com/c/chromium/src/+/984952

Bug: 794828
Change-Id: I1ce081f53913a9b4c24b7f00a9d173c3fc061696
Reviewed-on: https://chromium-review.googlesource.com/985014
Commit-Queue: Dan H <harringtond@chromium.org>
Reviewed-by: Carlos Knippschild <carlosk@chromium.org>
Cr-Commit-Position: refs/heads/master@{#547444}

components/offline_pages/core/BUILD.gn

@@ -22,6 +22,8 @@ static_library("core") {
     "model/add_page_task.h",
     "model/add_page_to_download_manager_task.cc",
     "model/add_page_to_download_manager_task.h",
+    "model/cleanup_thumbnails_task.cc",
+    "model/cleanup_thumbnails_task.h",
     "model/clear_digest_task.cc",
     "model/clear_digest_task.h",
     "model/clear_storage_task.cc",
@@ -32,6 +34,8 @@ static_library("core") {
     "model/delete_page_task.h",
     "model/get_pages_task.cc",
     "model/get_pages_task.h",
+    "model/get_thumbnail_task.cc",
+    "model/get_thumbnail_task.h",
     "model/mark_page_accessed_task.cc",
     "model/mark_page_accessed_task.h",
     "model/offline_page_model_taskified.cc",
@@ -44,6 +48,8 @@ static_library("core") {
     "model/start_offline_page_upgrade_task.h",
     "model/startup_maintenance_task.cc",
     "model/startup_maintenance_task.h",
+    "model/store_thumbnail_task.cc",
+    "model/store_thumbnail_task.h",
     "offline_event_logger.cc",
     "offline_event_logger.h",
     "offline_page_archiver.cc",
@@ -149,16 +155,19 @@ source_set("unit_tests") {
     "client_policy_controller_unittest.cc",
     "model/add_page_task_unittest.cc",
     "model/add_page_to_download_manager_task_unittest.cc",
+    "model/cleanup_thumbnails_task_unittest.cc",
     "model/clear_digest_task_unittest.cc",
     "model/clear_storage_task_unittest.cc",
     "model/complete_offline_page_upgrade_task_unittest.cc",
     "model/delete_page_task_unittest.cc",
     "model/get_pages_task_unittest.cc",
+    "model/get_thumbnail_task_unittest.cc",
     "model/mark_page_accessed_task_unittest.cc",
     "model/offline_page_model_taskified_unittest.cc",
     "model/offline_page_model_utils_unittest.cc",
     "model/start_offline_page_upgrade_task_unittest.cc",
     "model/startup_maintenance_task_unittest.cc",
+    "model/store_thumbnail_task_unittest.cc",
     "offline_event_logger_unittest.cc",
     "offline_page_archiver_unittest.cc",
     "offline_page_feature_unittest.cc",

components/offline_pages/core/model/cleanup_thumbnails_task.cc

+// Copyright 2018 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 "components/offline_pages/core/model/cleanup_thumbnails_task.h"
+
+#include "components/offline_pages/core/offline_page_metadata_store_sql.h"
+#include "components/offline_pages/core/offline_store_utils.h"
+#include "sql/connection.h"
+#include "sql/statement.h"
+#include "sql/transaction.h"
+
+namespace offline_pages {
+
+namespace {
+typedef base::OnceCallback<void(CleanupThumbnailsTask::Result)> ResultCallback;
+
+CleanupThumbnailsTask::Result CleanupThumbnailsSync(base::Time now,
+                                                    sql::Connection* db) {
+  const char kSql[] =
+      "DELETE FROM page_thumbnails "
+      "WHERE offline_id IN ("
+      "  SELECT pt.offline_id from page_thumbnails pt"
+      "  LEFT OUTER JOIN offlinepages_v1 op"
+      "  ON pt.offline_id = op.offline_id "
+      "  WHERE op.offline_id IS NULL "
+      "  AND pt.expiration < ?"
+      ")";
+  sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindInt64(0, store_utils::ToDatabaseTime(now));
+  if (!statement.Run())
+    return CleanupThumbnailsTask::Result();
+
+  return CleanupThumbnailsTask::Result{true, db->GetLastChangeCount()};
+}
+
+}  // namespace
+
+CleanupThumbnailsTask::CleanupThumbnailsTask(
+    OfflinePageMetadataStoreSQL* store,
+    base::Time now,
+    CleanupThumbnailsCallback complete_callback)
+    : store_(store),
+      now_(now),
+      complete_callback_(std::move(complete_callback)),
+      weak_ptr_factory_(this) {}
+
+CleanupThumbnailsTask::~CleanupThumbnailsTask() = default;
+
+void CleanupThumbnailsTask::Run() {
+  store_->Execute(base::BindOnce(CleanupThumbnailsSync, now_),
+                  base::BindOnce(&CleanupThumbnailsTask::Complete,
+                                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void CleanupThumbnailsTask::Complete(Result result) {
+  TaskComplete();
+  std::move(complete_callback_).Run(result.success);
+}
+
+}  // namespace offline_pages

components/offline_pages/core/model/cleanup_thumbnails_task.h

+// Copyright 2018 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.
+
+#ifndef COMPONENTS_OFFLINE_PAGES_CORE_MODEL_CLEANUP_THUMBNAILS_TASK_H_
+#define COMPONENTS_OFFLINE_PAGES_CORE_MODEL_CLEANUP_THUMBNAILS_TASK_H_
+
+#include <vector>
+
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "components/offline_pages/core/offline_page_thumbnail.h"
+#include "components/offline_pages/core/offline_page_types.h"
+#include "components/offline_pages/core/task.h"
+
+namespace offline_pages {
+class OfflinePageMetadataStoreSQL;
+
+// CleanupThumbnailsTask deletes thumbnails from page_thumbnails if they
+// are no longer needed.
+class CleanupThumbnailsTask : public Task {
+ public:
+  struct Result {
+    bool success = false;
+    int removed_thumbnails = 0;
+  };
+
+  CleanupThumbnailsTask(OfflinePageMetadataStoreSQL* store,
+                        base::Time now,
+                        CleanupThumbnailsCallback complete_callback);
+  ~CleanupThumbnailsTask() override;
+
+  // Task implementation:
+  void Run() override;
+
+ private:
+  void Complete(Result result);
+  OfflinePageMetadataStoreSQL* store_;
+  base::Time now_;
+
+  CleanupThumbnailsCallback complete_callback_;
+  base::WeakPtrFactory<CleanupThumbnailsTask> weak_ptr_factory_;
+  DISALLOW_COPY_AND_ASSIGN(CleanupThumbnailsTask);
+};
+
+}  // namespace offline_pages
+
+#endif  // COMPONENTS_OFFLINE_PAGES_CORE_MODEL_CLEANUP_THUMBNAILS_TASK_H_

components/offline_pages/core/model/cleanup_thumbnails_task_unittest.cc

+// Copyright 2018 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 "components/offline_pages/core/model/cleanup_thumbnails_task.h"
+
+#include <memory>
+
+#include "base/test/bind_test_util.h"
+#include "base/test/mock_callback.h"
+#include "components/offline_pages/core/model/get_thumbnail_task.h"
+#include "components/offline_pages/core/model/model_task_test_base.h"
+#include "components/offline_pages/core/model/store_thumbnail_task.h"
+#include "components/offline_pages/core/offline_store_utils.h"
+
+namespace offline_pages {
+namespace {
+
+class CleanupThumbnailsTaskTest : public ModelTaskTestBase {
+ public:
+  ~CleanupThumbnailsTaskTest() override {}
+
+  std::unique_ptr<OfflinePageThumbnail> ReadThumbnail(int64_t offline_id) {
+    std::unique_ptr<OfflinePageThumbnail> thumb;
+    auto callback = [&](std::unique_ptr<OfflinePageThumbnail> result) {
+      thumb = std::move(result);
+    };
+    RunTask(std::make_unique<GetThumbnailTask>(
+        store(), offline_id, base::BindLambdaForTesting(callback)));
+    return thumb;
+  }
+
+  OfflinePageThumbnail MustReadThumbnail(int64_t offline_id) {
+    std::unique_ptr<OfflinePageThumbnail> thumb = ReadThumbnail(offline_id);
+    CHECK(thumb);
+    return *thumb;
+  }
+};
+
+TEST_F(CleanupThumbnailsTaskTest, CleanupAllCombinations) {
+  // Two conditions contribute to thumbnail cleanup: does a corresponding
+  // OfflinePageItem exist, and is the thumbnail expired. All four combinations
+  // of these states are tested.
+  const base::Time kTimeLive = store_utils::FromDatabaseTime(1000);
+  const base::Time kTimeExpired = store_utils::FromDatabaseTime(999);
+
+  // 1. Has item, not expired.
+  OfflinePageItem item1 = generator()->CreateItem();
+  store_test_util()->InsertItem(item1);
+  OfflinePageThumbnail thumb1(item1.offline_id, kTimeLive, "thumb1");
+  RunTask(
+      std::make_unique<StoreThumbnailTask>(store(), thumb1, base::DoNothing()));
+
+  // 2. Has item, expired.
+  OfflinePageItem item2 = generator()->CreateItem();
+  store_test_util()->InsertItem(item2);
+
+  OfflinePageThumbnail thumb2(item2.offline_id, kTimeLive, "thumb2");
+  RunTask(
+      std::make_unique<StoreThumbnailTask>(store(), thumb2, base::DoNothing()));
+
+  // 3. No item, not expired.
+  OfflinePageThumbnail thumb3(store_utils::GenerateOfflineId(), kTimeLive,
+                              "thumb3");
+  RunTask(
+      std::make_unique<StoreThumbnailTask>(store(), thumb3, base::DoNothing()));
+
+  // 4. No item, expired. This one gets removed.
+  OfflinePageThumbnail thumb4(store_utils::GenerateOfflineId(), kTimeExpired,
+                              "thumb4");
+  RunTask(
+      std::make_unique<StoreThumbnailTask>(store(), thumb4, base::DoNothing()));
+
+  base::MockCallback<StoreThumbnailTask::CompleteCallback> callback;
+  EXPECT_CALL(callback, Run(true)).Times(1);
+
+  RunTask(std::make_unique<CleanupThumbnailsTask>(store(), kTimeLive,
+                                                  callback.Get()));
+  EXPECT_EQ(thumb1, MustReadThumbnail(thumb1.offline_id));
+  EXPECT_EQ(thumb2, MustReadThumbnail(thumb2.offline_id));
+  EXPECT_EQ(thumb3, MustReadThumbnail(thumb3.offline_id));
+  EXPECT_EQ(nullptr, ReadThumbnail(thumb4.offline_id).get());
+}
+
+}  // namespace
+}  // namespace offline_pages

components/offline_pages/core/model/get_thumbnail_task.cc

+// Copyright 2018 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 "components/offline_pages/core/model/get_thumbnail_task.h"
+
+#include "components/offline_pages/core/offline_page_metadata_store_sql.h"
+#include "components/offline_pages/core/offline_store_utils.h"
+#include "sql/connection.h"
+#include "sql/statement.h"
+#include "sql/transaction.h"
+
+namespace offline_pages {
+
+namespace {
+
+std::unique_ptr<OfflinePageThumbnail> GetThumbnailSync(int64_t offline_id,
+                                                       sql::Connection* db) {
+  std::unique_ptr<OfflinePageThumbnail> result;
+  static const char kSql[] =
+      "SELECT offline_id, expiration, thumbnail FROM page_thumbnails"
+      " WHERE offline_id = ?";
+  sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindInt64(0, offline_id);
+
+  if (!statement.Step()) {
+    return result;
+  }
+  result = std::make_unique<OfflinePageThumbnail>();
+
+  result->offline_id = statement.ColumnInt64(0);
+  int64_t expiration = statement.ColumnInt64(1);
+  result->expiration = store_utils::FromDatabaseTime(expiration);
+  if (!statement.ColumnBlobAsString(2, &result->thumbnail))
+    result.reset();
+
+  return result;
+}
+
+}  // namespace
+
+GetThumbnailTask::GetThumbnailTask(OfflinePageMetadataStoreSQL* store,
+                                   int64_t offline_id,
+                                   CompleteCallback complete_callback)
+    : store_(store),
+      offline_id_(offline_id),
+      complete_callback_(std::move(complete_callback)),
+      weak_ptr_factory_(this) {}
+
+GetThumbnailTask::~GetThumbnailTask() = default;
+
+void GetThumbnailTask::Run() {
+  store_->Execute(base::BindOnce(GetThumbnailSync, std::move(offline_id_)),
+                  base::BindOnce(&GetThumbnailTask::Complete,
+                                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void GetThumbnailTask::Complete(std::unique_ptr<OfflinePageThumbnail> result) {
+  TaskComplete();
+  std::move(complete_callback_).Run(std::move(result));
+}
+
+}  // namespace offline_pages

components/offline_pages/core/model/get_thumbnail_task.h

+// Copyright 2018 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.
+
+#ifndef COMPONENTS_OFFLINE_PAGES_CORE_MODEL_GET_THUMBNAIL_TASK_H_
+#define COMPONENTS_OFFLINE_PAGES_CORE_MODEL_GET_THUMBNAIL_TASK_H_
+
+#include <vector>
+
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "components/offline_pages/core/offline_page_thumbnail.h"
+#include "components/offline_pages/core/task.h"
+
+namespace offline_pages {
+class OfflinePageMetadataStoreSQL;
+
+// GetThumbnailTask reads a thumbnail from the page_thumbnails table.
+class GetThumbnailTask : public Task {
+ public:
+  typedef base::OnceCallback<void(std::unique_ptr<OfflinePageThumbnail>)>
+      CompleteCallback;
+
+  GetThumbnailTask(OfflinePageMetadataStoreSQL* store,
+                   int64_t offline_id,
+                   CompleteCallback complete_callback);
+  ~GetThumbnailTask() override;
+
+  // Task implementation:
+  void Run() override;
+
+ private:
+  typedef std::unique_ptr<OfflinePageThumbnail> Result;
+
+  void Complete(Result result);
+
+  OfflinePageMetadataStoreSQL* store_;
+  int64_t offline_id_;
+  base::OnceCallback<void(std::unique_ptr<OfflinePageThumbnail>)>
+      complete_callback_;
+  base::WeakPtrFactory<GetThumbnailTask> weak_ptr_factory_;
+  DISALLOW_COPY_AND_ASSIGN(GetThumbnailTask);
+};
+
+}  // namespace offline_pages
+
+#endif  // COMPONENTS_OFFLINE_PAGES_CORE_MODEL_GET_THUMBNAIL_TASK_H_

components/offline_pages/core/model/get_thumbnail_task_unittest.cc

+// Copyright 2018 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 "components/offline_pages/core/model/get_thumbnail_task.h"
+
+#include <memory>
+
+#include "base/bind_helpers.h"
+#include "base/files/scoped_temp_dir.h"
+#include "base/test/bind_test_util.h"
+#include "base/test/mock_callback.h"
+#include "components/offline_pages/core/model/model_task_test_base.h"
+#include "components/offline_pages/core/model/offline_page_item_generator.h"
+#include "components/offline_pages/core/model/store_thumbnail_task.h"
+#include "components/offline_pages/core/offline_page_metadata_store_test_util.h"
+#include "components/offline_pages/core/offline_store_utils.h"
+#include "components/offline_pages/core/test_task_runner.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using testing::_;
+
+namespace offline_pages {
+namespace {
+
+class GetThumbnailTaskTest : public ModelTaskTestBase {
+ public:
+  ~GetThumbnailTaskTest() override = default;
+
+  std::unique_ptr<OfflinePageThumbnail> ReadThumbnail(int64_t offline_id) {
+    std::unique_ptr<OfflinePageThumbnail> thumb;
+    auto callback = [&](std::unique_ptr<OfflinePageThumbnail> result) {
+      thumb = std::move(result);
+    };
+    RunTask(std::make_unique<GetThumbnailTask>(
+        store(), offline_id, base::BindLambdaForTesting(callback)));
+    return thumb;
+  }
+
+  OfflinePageThumbnail MustReadThumbnail(int64_t offline_id) {
+    std::unique_ptr<OfflinePageThumbnail> thumb = ReadThumbnail(offline_id);
+    CHECK(thumb);
+    return *thumb;
+  }
+};
+
+TEST_F(GetThumbnailTaskTest, NotFound) {
+  OfflinePageThumbnail thumb;
+  thumb.offline_id = 1;
+  thumb.expiration = store_utils::FromDatabaseTime(1234);
+  thumb.thumbnail = "123abc";
+
+  bool called = false;
+  auto callback = base::BindLambdaForTesting(
+      [&](std::unique_ptr<OfflinePageThumbnail> result) {
+        called = true;
+        EXPECT_FALSE(result);
+      });
+
+  RunTask(std::make_unique<GetThumbnailTask>(store(), 1, std::move(callback)));
+  EXPECT_TRUE(called);
+}
+
+TEST_F(GetThumbnailTaskTest, Found) {
+  OfflinePageThumbnail thumb;
+  thumb.offline_id = 1;
+  thumb.expiration = store_utils::FromDatabaseTime(1234);
+  thumb.thumbnail = "123abc";
+  RunTask(
+      std::make_unique<StoreThumbnailTask>(store(), thumb, base::DoNothing()));
+
+  bool called = false;
+  auto callback = base::BindLambdaForTesting(
+      [&](std::unique_ptr<OfflinePageThumbnail> result) {
+        called = true;
+        ASSERT_TRUE(result);
+        EXPECT_EQ(thumb, *result);
+      });
+
+  RunTask(
+      std::make_unique<GetThumbnailTask>(store(), thumb.offline_id, callback));
+  EXPECT_TRUE(called);
+}
+
+}  // namespace
+}  // namespace offline_pages

components/offline_pages/core/model/store_thumbnail_task.cc

+// Copyright 2018 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 "components/offline_pages/core/model/store_thumbnail_task.h"
+
+#include "components/offline_pages/core/offline_page_metadata_store_sql.h"
+#include "components/offline_pages/core/offline_store_utils.h"
+#include "sql/connection.h"
+#include "sql/statement.h"
+#include "sql/transaction.h"
+
+namespace offline_pages {
+
+namespace {
+
+bool StoreThumbnailSync(const OfflinePageThumbnail& thumbnail,
+                        sql::Connection* db) {
+  static const char kSql[] =
+      "INSERT OR REPLACE INTO page_thumbnails (offline_id, expiration, "
+      "thumbnail) VALUES (?, ?, ?)";
+  sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindInt64(0, thumbnail.offline_id);
+  statement.BindInt64(1, store_utils::ToDatabaseTime(thumbnail.expiration));
+  statement.BindString(2, thumbnail.thumbnail);
+  return statement.Run();
+}
+
+}  // namespace
+
+StoreThumbnailTask::StoreThumbnailTask(
+    OfflinePageMetadataStoreSQL* store,
+    OfflinePageThumbnail thumbnail,
+    base::OnceCallback<void(bool)> complete_callback)
+    : store_(store),
+      thumbnail_(std::move(thumbnail)),
+      complete_callback_(std::move(complete_callback)),
+      weak_ptr_factory_(this) {}
+
+StoreThumbnailTask::~StoreThumbnailTask() = default;
+
+void StoreThumbnailTask::Run() {
+  store_->Execute(base::BindOnce(StoreThumbnailSync, std::move(thumbnail_)),
+                  base::BindOnce(&StoreThumbnailTask::Complete,
+                                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void StoreThumbnailTask::Complete(bool success) {
+  TaskComplete();
+  std::move(complete_callback_).Run(success);
+}
+
+}  // namespace offline_pages

components/offline_pages/core/model/store_thumbnail_task.h

+// Copyright 2018 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.
+
+#ifndef COMPONENTS_OFFLINE_PAGES_CORE_MODEL_STORE_THUMBNAIL_TASK_H_
+#define COMPONENTS_OFFLINE_PAGES_CORE_MODEL_STORE_THUMBNAIL_TASK_H_
+
+#include <vector>
+
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "components/offline_pages/core/offline_page_thumbnail.h"
+#include "components/offline_pages/core/task.h"
+
+namespace offline_pages {
+class OfflinePageMetadataStoreSQL;
+
+// StoreThumbnailTask stores a thumbnail in the page_thumbnails table.
+class StoreThumbnailTask : public Task {
+ public:
+  typedef base::OnceCallback<void(bool)> CompleteCallback;
+
+  StoreThumbnailTask(OfflinePageMetadataStoreSQL* store,
+                     OfflinePageThumbnail thumbnail,
+                     CompleteCallback complete_callback);
+  ~StoreThumbnailTask() override;
+
+  // Task implementation:
+  void Run() override;
+
+ private:
+  void Complete(bool success);
+
+  OfflinePageMetadataStoreSQL* store_;
+  OfflinePageThumbnail thumbnail_;
+  CompleteCallback complete_callback_;
+  base::WeakPtrFactory<StoreThumbnailTask> weak_ptr_factory_;
+  DISALLOW_COPY_AND_ASSIGN(StoreThumbnailTask);
+};
+
+}  // namespace offline_pages
+
+#endif  // COMPONENTS_OFFLINE_PAGES_CORE_MODEL_STORE_THUMBNAIL_TASK_H_

components/offline_pages/core/model/store_thumbnail_task_unittest.cc

+// Copyright 2018 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 "components/offline_pages/core/model/store_thumbnail_task.h"
+
+#include <memory>
+
+#include "base/test/bind_test_util.h"
+#include "base/test/mock_callback.h"
+#include "components/offline_pages/core/model/get_thumbnail_task.h"
+#include "components/offline_pages/core/model/model_task_test_base.h"
+#include "components/offline_pages/core/offline_store_utils.h"
+
+namespace offline_pages {
+namespace {
+
+class StoreThumbnailTaskTest : public ModelTaskTestBase {
+ public:
+  ~StoreThumbnailTaskTest() override {}
+
+  std::unique_ptr<OfflinePageThumbnail> ReadThumbnail(int64_t offline_id) {
+    std::unique_ptr<OfflinePageThumbnail> thumb;
+    auto callback = [&](std::unique_ptr<OfflinePageThumbnail> result) {
+      thumb = std::move(result);
+    };
+    RunTask(std::make_unique<GetThumbnailTask>(
+        store(), offline_id, base::BindLambdaForTesting(callback)));
+    return thumb;
+  }
+
+  OfflinePageThumbnail MustReadThumbnail(int64_t offline_id) {
+    std::unique_ptr<OfflinePageThumbnail> thumb = ReadThumbnail(offline_id);
+    CHECK(thumb);
+    return *thumb;
+  }
+};
+
+TEST_F(StoreThumbnailTaskTest, Success) {
+  OfflinePageThumbnail thumb;
+  thumb.offline_id = 1;
+  thumb.expiration = store_utils::FromDatabaseTime(1234);
+  thumb.thumbnail = "123abc";
+  base::MockCallback<StoreThumbnailTask::CompleteCallback> callback;
+  EXPECT_CALL(callback, Run(true)).Times(1);
+
+  RunTask(std::make_unique<StoreThumbnailTask>(store(), thumb, callback.Get()));
+  EXPECT_EQ(thumb, MustReadThumbnail(thumb.offline_id));
+}
+
+TEST_F(StoreThumbnailTaskTest, AlreadyExists) {
+  // Store the same thumbnail twice. The second operation should overwrite the
+  // first.
+  OfflinePageThumbnail thumb;
+  thumb.offline_id = 1;
+  thumb.expiration = store_utils::FromDatabaseTime(1234);
+  thumb.thumbnail = "123abc";
+  base::MockCallback<StoreThumbnailTask::CompleteCallback> callback;
+  EXPECT_CALL(callback, Run(true)).Times(2);
+
+  RunTask(std::make_unique<StoreThumbnailTask>(store(), thumb, callback.Get()));
+  EXPECT_EQ(thumb, MustReadThumbnail(thumb.offline_id));
+
+  thumb.thumbnail += "_extradata";
+  thumb.expiration = store_utils::FromDatabaseTime(12345);
+  RunTask(std::make_unique<StoreThumbnailTask>(store(), thumb, callback.Get()));
+  EXPECT_EQ(thumb, MustReadThumbnail(thumb.offline_id));
+}
+
+}  // namespace
+}  // namespace offline_pages

components/offline_pages/core/offline_page_types.h

@@ -12,6 +12,7 @@
 
 #include "base/callback.h"
 #include "components/offline_pages/core/offline_page_item.h"
+#include "components/offline_pages/core/offline_page_thumbnail.h"
 
 class GURL;
 
@@ -103,6 +104,9 @@ typedef base::Callback<void(const MultipleOfflinePageItemResult&)>
     MultipleOfflinePageItemCallback;
 typedef base::Callback<bool(const GURL&)> UrlPredicate;
 typedef base::Callback<void(int64_t)> SizeInBytesCallback;
+typedef base::OnceCallback<void(std::unique_ptr<OfflinePageThumbnail>)>
+    GetThumbnailCallback;
+typedef base::OnceCallback<void(bool)> CleanupThumbnailsCallback;
 
 // Callback used for publishing an offline page.
 using PublishPageCallback = base::OnceCallback<void(const OfflinePageItem&)>;