[Offline Pages] Implement ClearStorageTask.

Implemented ClearStorageTask, which is responsible for clearing expired
temporary pages from metadata store, and their associated archive files.
This is replacing the functionality of the OfflinePageStorageManager.

Bug: 753595
Change-Id: I037923a1293950998446e9992e247155063d0b5a
Reviewed-on: https://chromium-review.googlesource.com/674057
Commit-Queue: Yafei Duan <romax@chromium.org>
Reviewed-by: Filip Gorski <fgorski@chromium.org>
Cr-Commit-Position: refs/heads/master@{#504237}

components/offline_pages/core/BUILD.gn

@@ -18,6 +18,8 @@ static_library("core") {
     "client_policy_controller.h",
     "model/add_page_task.cc",
     "model/add_page_task.h",
+    "model/clear_storage_task.cc",
+    "model/clear_storage_task.h",
     "model/create_archive_task.cc",
     "model/create_archive_task.h",
     "model/delete_page_task.cc",
@@ -98,6 +100,7 @@ static_library("test_support") {
     "//base",
     "//base/test:test_support",
     "//components/keyed_service/core",
+    "//sql:sql",
     "//testing/gtest",
     "//url",
   ]
@@ -120,6 +123,7 @@ source_set("unit_tests") {
   sources = [
     "archive_manager_unittest.cc",
     "client_policy_controller_unittest.cc",
+    "model/clear_storage_task_unittest.cc",
     "model/create_archive_task_unittest.cc",
     "model/delete_page_task_unittest.cc",
     "model/get_pages_task_unittest.cc",

components/offline_pages/core/model/clear_storage_task.h

+// Copyright 2017 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_CLEAR_STORAGE_TASK_H_
+#define COMPONENTS_OFFLINE_PAGES_CORE_MODEL_CLEAR_STORAGE_TASK_H_
+
+#include <utility>
+
+#include "base/memory/weak_ptr.h"
+#include "components/offline_pages/core/archive_manager.h"
+#include "components/offline_pages/core/offline_page_types.h"
+#include "components/offline_pages/core/task.h"
+
+namespace base {
+class Time;
+}  // namespace base
+
+namespace offline_pages {
+
+class ClientPolicyController;
+class OfflinePageMetadataStoreSQL;
+
+// This task is responsible for clearing expired temporary pages from metadata
+// store and disk. The task needs to be provided with a |last_start_time| in
+// order to decide if it's going to do the clearing.
+// The callback will provide the time when the task starts, how many pages are
+// cleared and a ClearStorageResult.
+class ClearStorageTask : public Task {
+ public:
+  // The name of histogram enum is OfflinePagesClearStorageResult.
+  enum class ClearStorageResult {
+    SUCCESS,                                // Cleared successfully.
+    UNNECESSARY,                            // No expired pages.
+    DEPRECATED_EXPIRE_FAILURE,              // Expiration failed. (DEPRECATED)
+    DELETE_FAILURE,                         // Deletion failed.
+    DEPRECATED_EXPIRE_AND_DELETE_FAILURES,  // Both expiration and deletion
+                                            // failed. (DEPRECATED)
+    // NOTE: always keep this entry at the end. Add new result types only
+    // immediately above this line. Make sure to update the corresponding
+    // histogram enum accordingly.
+    RESULT_COUNT,
+  };
+
+  // Callback used when calling ClearPagesIfNeeded.
+  // base::Time: the starting time of this clear storage attempt.
+  // size_t: the number of cleared pages.
+  // ClearStorageResult: result of clearing pages in storage.
+  typedef base::OnceCallback<
+      void(const base::Time&, size_t, ClearStorageResult)>
+      ClearStorageCallback;
+
+  ClearStorageTask(OfflinePageMetadataStoreSQL* store,
+                   ArchiveManager* archive_manager,
+                   ClientPolicyController* policy_controller,
+                   const base::Time& last_start_time,
+                   const base::Time& clearup_time,
+                   ClearStorageCallback callback);
+  ~ClearStorageTask() override;
+
+  // Task implementation.
+  void Run() override;
+
+ private:
+  void OnGetStorageStatsDone(const ArchiveManager::StorageStats& stats);
+  void OnClearPagesDone(std::pair<size_t, DeletePageResult> result);
+  void InformClearStorageDone(size_t pages_cleared, ClearStorageResult result);
+
+  // The store containing the pages to be cleared. Not owned.
+  OfflinePageMetadataStoreSQL* store_;
+  // The archive manager owning the archive directories to delete pages from.
+  // Not owned.
+  ArchiveManager* archive_manager_;
+  // The policy controller which is used to determine if a page needs to be
+  // cleared. Not owned.
+  ClientPolicyController* policy_controller_;
+  ClearStorageCallback callback_;
+  base::Time last_start_time_;
+  base::Time clearup_time_;
+
+  base::WeakPtrFactory<ClearStorageTask> weak_ptr_factory_;
+  DISALLOW_COPY_AND_ASSIGN(ClearStorageTask);
+};
+
+}  // namespace offline_pages
+
+#endif  // COMPONENTS_OFFLINE_PAGES_CORE_MODEL_CLEAR_STORAGE_TASK_H_

components/offline_pages/core/model/delete_page_task.cc

@@ -44,7 +44,7 @@ DeletedPageInfoWrapper::DeletedPageInfoWrapper() = default;
 DeletedPageInfoWrapper::DeletedPageInfoWrapper(
     const DeletedPageInfoWrapper& other) = default;
 
-bool DeleteArchiveSync(base::FilePath file_path) {
+bool DeleteArchiveSync(const base::FilePath& file_path) {
   // Delete the file only, |false| for recursive.
   return base::DeleteFile(file_path, false);
 }

components/offline_pages/core/model/offline_page_item_generator.cc

@@ -4,6 +4,7 @@
 
 #include "components/offline_pages/core/model/offline_page_item_generator.h"
 
+#include "base/files/file_util.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/offline_pages/core/model/offline_store_utils.h"
@@ -23,6 +24,17 @@ OfflinePageItem OfflinePageItemGenerator::CreateItem() {
   item.request_origin = request_origin_;
   item.url = url_;
   item.original_url = original_url_;
+  item.file_size = file_size_;
+  item.last_access_time = last_access_time_;
+  return item;
+}
+
+OfflinePageItem OfflinePageItemGenerator::CreateItemWithTempFileInDir(
+    const base::FilePath& temp_dir) {
+  OfflinePageItem item = CreateItem();
+  base::FilePath path;
+  base::CreateTemporaryFileInDir(temp_dir, &path);
+  item.file_path = path;
   return item;
 }
 
@@ -43,4 +55,13 @@ void OfflinePageItemGenerator::SetOriginalUrl(const GURL& url) {
   original_url_ = url;
 }
 
+void OfflinePageItemGenerator::SetFileSize(int64_t file_size) {
+  file_size_ = file_size;
+}
+
+void OfflinePageItemGenerator::SetLastAccessTime(
+    const base::Time& last_access_time) {
+  last_access_time_ = last_access_time;
+}
+
 }  // namespace offline_pages

components/offline_pages/core/model/offline_page_item_generator.h

@@ -20,17 +20,22 @@ class OfflinePageItemGenerator {
   ~OfflinePageItemGenerator();
 
   OfflinePageItem CreateItem();
+  OfflinePageItem CreateItemWithTempFileInDir(const base::FilePath& temp_dir);
 
   void SetNamespace(const std::string& name_space);
   void SetRequestOrigin(const std::string& request_origin);
   void SetUrl(const GURL& url);
   void SetOriginalUrl(const GURL& url);
+  void SetFileSize(int64_t);
+  void SetLastAccessTime(const base::Time& time);
 
  private:
   std::string namespace_;
   std::string request_origin_;
   GURL url_;
   GURL original_url_;
+  int64_t file_size_;
+  base::Time last_access_time_;
 };
 }  // namespace offline_pages
 

components/offline_pages/core/model/offline_store_utils.h

@@ -12,6 +12,10 @@
 
 namespace offline_pages {
 
+#define OFFLINE_CACHED_NAMESPACES                                       \
+  "(\"bookmark\", \"last_n\", \"custom_tabs\", \"suggested_articles\"," \
+  " \"default\")"
+
 class OfflineStoreUtils {
  public:
   // Converts an ItemActionStatus to AddPageResult.

components/offline_pages/core/offline_page_metadata_store_test_util.cc

@@ -7,10 +7,25 @@
 #include "base/bind.h"
 #include "base/callback_forward.h"
 #include "components/offline_pages/core/offline_page_types.h"
+#include "sql/connection.h"
+#include "sql/statement.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
 
+namespace {
+
+int64_t GetPageCountSync(sql::Connection* db) {
+  const char kSql[] = "SELECT count(*) FROM offlinepages_v1";
+  sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE, kSql));
+  if (statement.Step()) {
+    return statement.ColumnInt64(0);
+  }
+  return 0UL;
+}
+
+}  // namespace
+
 OfflinePageMetadataStoreTestUtil::OfflinePageMetadataStoreTestUtil(
     scoped_refptr<base::TestSimpleTaskRunner> task_runner)
     : task_runner_(task_runner) {}
@@ -51,4 +66,14 @@ void OfflinePageMetadataStoreTestUtil::InsertItem(const OfflinePageItem& page) {
   EXPECT_EQ(ItemActionStatus::SUCCESS, status);
 }
 
+int64_t OfflinePageMetadataStoreTestUtil::GetPageCount() {
+  int64_t page_count = 0;
+  store_->Execute(base::BindOnce(&GetPageCountSync),
+                  base::BindOnce([](int64_t* out_count,
+                                    int64_t count) { *out_count = count; },
+                                 &page_count));
+  task_runner_->RunUntilIdle();
+  return page_count;
+}
+
 }  // namespace offline_pages

components/offline_pages/core/offline_page_metadata_store_test_util.h

@@ -40,6 +40,9 @@ class OfflinePageMetadataStoreTestUtil {
   // Inserts an offline page item into the store.
   void InsertItem(const OfflinePageItem& item);
 
+  // Gets the total number of pages in the store.
+  int64_t GetPageCount();
+
   OfflinePageMetadataStoreSQL* store() { return store_.get(); }
 
   base::SimpleTestClock* clock() { return &clock_; }

components/offline_pages/core/offline_page_storage_manager_unittest.cc

@@ -45,6 +45,23 @@ struct PageSettings {
   int fresh_pages_count;
   int expired_pages_count;
 };
+
+class TestArchiveManager : public ArchiveManager {
+ public:
+  explicit TestArchiveManager(StorageStats stats) : stats_(stats) {}
+
+  void GetStorageStats(const base::Callback<
+                       void(const ArchiveManager::StorageStats& storage_stats)>&
+                           callback) const override {
+    callback.Run(stats_);
+  }
+
+  void SetValues(ArchiveManager::StorageStats stats) { stats_ = stats; }
+
+ private:
+  StorageStats stats_;
+};
+
 }  // namespace
 
 class OfflinePageTestModel : public OfflinePageModelImpl {
@@ -174,22 +191,6 @@ void OfflinePageTestModel::AddPages(const PageSettings& setting) {
   }
 }
 
-class TestArchiveManager : public ArchiveManager {
- public:
-  explicit TestArchiveManager(StorageStats stats) : stats_(stats) {}
-
-  void GetStorageStats(const base::Callback<
-                       void(const ArchiveManager::StorageStats& storage_stats)>&
-                           callback) const override {
-    callback.Run(stats_);
-  }
-
-  void SetValues(ArchiveManager::StorageStats stats) { stats_ = stats; }
-
- private:
-  StorageStats stats_;
-};
-
 class OfflinePageStorageManagerTest : public testing::Test {
  public:
   OfflinePageStorageManagerTest();