[Offline Pages] Add cached offline page utils and show usage in settings.

components/offline_pages/core/cached_offline_page_utils_unittest.cc

+// Copyright 2016 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/cached_offline_page_utils.h"
+
+#include <stdint.h>
+#include <map>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/memory/weak_ptr.h"
+#include "base/test/simple_test_clock.h"
+#include "base/time/time.h"
+#include "components/offline_pages/core/client_policy_controller.h"
+#include "components/offline_pages/core/offline_page_item.h"
+#include "components/offline_pages/core/offline_page_model_query.h"
+#include "components/offline_pages/core/offline_page_types.h"
+#include "components/offline_pages/core/stub_offline_page_model.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace offline_pages {
+
+namespace {
+// Constants for test OfflinePageItems.
+const char kTemporaryNamespace[] = "temporary_namespace";
+const char kPersistentNamespace[] = "persistent_namespace";
+const GURL kTestUrl("http://foo.com/bar.html");
+const GURL kTestUrl2("http://bar.com/foo)");
+const int64_t kOfflineId1 = 1234LL;
+const int64_t kOfflineId2 = 5678LL;
+const int64_t kOfflineId3 = 42LL;
+const ClientId kTempClientId1(kTemporaryNamespace, "1234");
+const ClientId kTempClientId2(kTemporaryNamespace, "5678");
+const ClientId kPersistentClientId(kPersistentNamespace, "42");
+const int64_t kTestFileSize1 = 131415LL;
+const int64_t kTestFileSize2 = 666666LL;
+const base::FilePath kTestFilePath =
+    base::FilePath(FILE_PATH_LITERAL("file_path"));
+}  // namespace
+
+class CachedOfflinePageTestModel : public StubOfflinePageModel {
+ public:
+  CachedOfflinePageTestModel();
+  ~CachedOfflinePageTestModel() override;
+
+  void GetPagesMatchingQuery(
+      std::unique_ptr<OfflinePageModelQuery> query,
+      const MultipleOfflinePageItemCallback& callback) override;
+  void DeletePagesMatchingQuery(std::unique_ptr<OfflinePageModelQuery> query,
+                                const DeletePageCallback& callback) override;
+  void GetAllPages(const MultipleOfflinePageItemCallback& callback) override;
+
+  ClientPolicyController* GetPolicyController() override;
+
+  void AddOfflinePage(const OfflinePageItem& page);
+
+ private:
+  std::map<int64_t, OfflinePageItem> offline_pages_;
+  std::unique_ptr<ClientPolicyController> policy_controller_;
+};
+
+CachedOfflinePageTestModel::CachedOfflinePageTestModel()
+    : policy_controller_(new ClientPolicyController()) {
+  // Adds the policies for test namespaces.
+  policy_controller_->AddPolicyForTest(
+      kTemporaryNamespace,
+      OfflinePageClientPolicyBuilder(kTemporaryNamespace,
+                                     LifetimePolicy::LifetimeType::TEMPORARY,
+                                     kUnlimitedPages, kUnlimitedPages));
+  policy_controller_->AddPolicyForTest(
+      kPersistentNamespace,
+      OfflinePageClientPolicyBuilder(kPersistentNamespace,
+                                     LifetimePolicy::LifetimeType::PERSISTENT,
+                                     kUnlimitedPages, kUnlimitedPages)
+          .SetIsRemovedOnCacheReset(false));
+}
+
+CachedOfflinePageTestModel::~CachedOfflinePageTestModel() {}
+
+void CachedOfflinePageTestModel::GetPagesMatchingQuery(
+    std::unique_ptr<OfflinePageModelQuery> query,
+    const MultipleOfflinePageItemCallback& callback) {
+  std::vector<OfflinePageItem> result;
+  for (const auto& page : offline_pages_) {
+    if (query->Matches(page.second))
+      result.push_back(page.second);
+  }
+  callback.Run(result);
+}
+
+void CachedOfflinePageTestModel::DeletePagesMatchingQuery(
+    std::unique_ptr<OfflinePageModelQuery> query,
+    const DeletePageCallback& callback) {
+  auto iter = offline_pages_.begin();
+  while (iter != offline_pages_.end()) {
+    if (query->Matches(iter->second))
+      iter = offline_pages_.erase(iter);
+    else
+      ++iter;
+  }
+  callback.Run(DeletePageResult::SUCCESS);
+}
+
+void CachedOfflinePageTestModel::GetAllPages(
+    const MultipleOfflinePageItemCallback& callback) {
+  MultipleOfflinePageItemResult result;

[carlosk, 2017/05/03 18:13:52]

nit: use either MultipleOfflinePageItemResult (here) or
std::vector<OfflinePageItem> (in GetPagesMatchingQuery) consistently.

[romax, 2017/05/03 19:46:22]

Done.

+  for (const auto& page : offline_pages_)
+    result.push_back(page.second);
+  callback.Run(result);
+}
+
+ClientPolicyController* CachedOfflinePageTestModel::GetPolicyController() {
+  return policy_controller_.get();
+}
+
+void CachedOfflinePageTestModel::AddOfflinePage(const OfflinePageItem& page) {
+  offline_pages_[page.offline_id] = page;
+}
+
+class CachedOfflinePageUtilsTest
+    : public testing::Test,
+      public base::SupportsWeakPtr<CachedOfflinePageUtilsTest> {
+ public:
+  CachedOfflinePageUtilsTest();
+
+  // testing::Test
+  void SetUp() override;
+  void TearDown() override;
+
+  void AddPage(const GURL& url,
+               const int64_t offline_id,
+               const ClientId& client_id,
+               const base::FilePath& path,
+               const int64_t file_size,
+               const base::Time& creation_time);
+  MultipleOfflinePageItemResult GetAllPages();
+
+  void OnSizeCalculated(int64_t size);
+  void OnDeleteDone(DeletePageResult result);
+  void OnGetMultipleOfflinePageItemsResult(
+      MultipleOfflinePageItemResult* storage,
+      const MultipleOfflinePageItemResult& result);
+
+  OfflinePageModel* model() { return model_.get(); }
+  base::SimpleTestClock* clock() { return clock_.get(); }
+
+  int64_t last_cache_size() { return last_cache_size_; }
+
+ private:
+  std::unique_ptr<CachedOfflinePageTestModel> model_;
+  std::unique_ptr<base::SimpleTestClock> clock_;
+  int64_t last_cache_size_;
+  DeletePageResult last_delete_result_;
+};
+
+CachedOfflinePageUtilsTest::CachedOfflinePageUtilsTest()
+    : model_(new CachedOfflinePageTestModel),
+      clock_(new base::SimpleTestClock()),
+      last_cache_size_(0) {}
+
+void CachedOfflinePageUtilsTest::SetUp() {
+  clock_->SetNow(base::Time::Now());
+}
+
+void CachedOfflinePageUtilsTest::TearDown() {
+  model_.reset();
+  clock_.reset();
+}
+
+void CachedOfflinePageUtilsTest::AddPage(const GURL& url,
+                                         const int64_t offline_id,
+                                         const ClientId& client_id,
+                                         const base::FilePath& path,
+                                         const int64_t file_size,
+                                         const base::Time& creation_time) {
+  OfflinePageItem page(url, offline_id, client_id, path, file_size,
+                       creation_time);
+  model_->AddOfflinePage(page);
+}
+
+MultipleOfflinePageItemResult CachedOfflinePageUtilsTest::GetAllPages() {
+  MultipleOfflinePageItemResult result;
+  model()->GetAllPages(base::Bind(
+      &CachedOfflinePageUtilsTest::OnGetMultipleOfflinePageItemsResult,
+      AsWeakPtr(), base::Unretained(&result)));
+  return result;
+}
+
+void CachedOfflinePageUtilsTest::OnSizeCalculated(int64_t size) {
+  last_cache_size_ = size;
+}
+
+void CachedOfflinePageUtilsTest::OnDeleteDone(DeletePageResult result) {
+  last_delete_result_ = result;
+}
+
+void CachedOfflinePageUtilsTest::OnGetMultipleOfflinePageItemsResult(
+    MultipleOfflinePageItemResult* storage,
+    const MultipleOfflinePageItemResult& result) {
+  *storage = result;
+}
+
+TEST_F(CachedOfflinePageUtilsTest, TestGetCachedOfflinePageSizeBetween) {
+  // Time 00:00:00.
+  AddPage(kTestUrl, kOfflineId1, kTempClientId1, kTestFilePath, kTestFileSize1,
+          clock()->Now());
+  // time 02:00:00.
+  clock()->Advance(base::TimeDelta::FromHours(2));
+  AddPage(kTestUrl, kOfflineId2, kPersistentClientId, kTestFilePath,
+          kTestFileSize1, clock()->Now());
+  // time 03:00:00.
+  clock()->Advance(base::TimeDelta::FromHours(3));

[carlosk, 2017/05/03 18:13:52]

Advance adds time to the current "now". So this is in fact 05:00:00.
If you think it's clearer you could use absolute times and use SetNow instead.

[romax, 2017/05/03 19:46:22]

Done.

+  AddPage(kTestUrl2, kOfflineId3, kTempClientId2, kTestFilePath, kTestFileSize2,
+          clock()->Now());

[carlosk, 2017/05/03 18:13:52]

I'd also suggest adding an ulterior temporary entry to check the upper time
limit is also being enforced.

[romax, 2017/05/03 19:46:22]

Done.

+
+  // Get size from 01:00:00 till now. Only kOfflineId3 will be calculated.
+  CachedOfflinePageUtils::GetCachedOfflinePageSizeBetween(
+      model(),
+      base::Bind(&CachedOfflinePageUtilsTest::OnSizeCalculated, AsWeakPtr()),
+      clock()->Now() - base::TimeDelta::FromHours(2), clock()->Now());

[carlosk, 2017/05/03 18:13:52]

Given how Advance works this begin time will not include the persistent entry as
I think you intended to do.

[romax, 2017/05/03 19:46:22]

Acknowledged.

+  EXPECT_EQ(last_cache_size(), kTestFileSize2);
+}
+
+TEST_F(CachedOfflinePageUtilsTest, TestDeleteCachedOfflinePage) {
+  // Time 00:00:00.
+  AddPage(kTestUrl, kOfflineId1, kTempClientId1, kTestFilePath, kTestFileSize1,
+          clock()->Now());
+  // time 02:00:00.
+  clock()->Advance(base::TimeDelta::FromHours(2));
+  AddPage(kTestUrl, kOfflineId2, kPersistentClientId, kTestFilePath,
+          kTestFileSize1, clock()->Now());
+  // time 03:00:00.
+  clock()->Advance(base::TimeDelta::FromHours(3));
+  AddPage(kTestUrl2, kOfflineId3, kTempClientId2, kTestFilePath, kTestFileSize2,
+          clock()->Now());
+  ASSERT_EQ(3UL, GetAllPages().size());

[carlosk, 2017/05/03 18:13:52]

As the test pages used in all current tests are the same move this code into
SetUp and avoid duplication in both.

[romax, 2017/05/03 19:46:22]

Done.

+
+  // Delete cached offlin pages, and there will be one left.

[carlosk, 2017/05/03 18:13:52]

/offlin/offline/s

[romax, 2017/05/03 19:46:22]

Done.

+  CachedOfflinePageUtils::DeleteCachedOfflinePage(
+      model(),
+      base::Bind(&CachedOfflinePageUtilsTest::OnDeleteDone, AsWeakPtr()));
+  EXPECT_EQ(1UL, GetAllPages().size());
+}
+}  // namespace offline_pages