DEBUG counter logging

chrome/browser/android/offline_pages/offline_page_utils_unittest.cc

 // Copyright 2015 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 "chrome/browser/android/offline_pages/offline_page_utils.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/test/scoped_feature_list.h"
+#include "base/test/simple_test_clock.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/android/offline_pages/offline_page_model_factory.h"
 #include "chrome/browser/android/offline_pages/offline_page_tab_helper.h"
 #include "chrome/browser/android/offline_pages/request_coordinator_factory.h"
 #include "chrome/browser/android/offline_pages/test_offline_page_model_builder.h"
 #include "chrome/browser/android/offline_pages/test_request_coordinator_builder.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/offline_pages/core/background/network_quality_provider_stub.h"
 #include "components/offline_pages/core/background/request_coordinator.h"
 #include "components/offline_pages/core/client_namespace_constants.h"
 #include "components/offline_pages/core/offline_page_feature.h"
 #include "components/offline_pages/core/offline_page_model.h"
+#include "components/offline_pages/core/offline_page_model_impl.h"
 #include "components/offline_pages/core/offline_page_test_archiver.h"
 #include "components/offline_pages/core/offline_page_test_store.h"
 #include "components/offline_pages/core/offline_page_types.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/base/filename_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace offline_pages {
 namespace {
 
 const GURL kTestPage1Url("http://test.org/page1");
 const GURL kTestPage2Url("http://test.org/page2");
 const GURL kTestPage3Url("http://test.org/page3");
 const GURL kTestPage4Url("http://test.org/page4");
 const int64_t kTestFileSize = 876543LL;
 const char* kTestPage1ClientId = "1234";
 const char* kTestPage2ClientId = "5678";
 const char* kTestPage3ClientId = "7890";
+const char* kTestPage4ClientId = "42";
 
 void CheckDuplicateDownloadsCallback(
     OfflinePageUtils::DuplicateCheckResult* out_result,
     OfflinePageUtils::DuplicateCheckResult result) {
   DCHECK(out_result);
   *out_result = result;
 }
 
 void GetAllRequestsCallback(
     std::vector<std::unique_ptr<SavePageRequest>>* out_requests,
@@ skipping 20 matching lines @@
 
   // Return number of matches found.
   int FindRequestByNamespaceAndURL(const std::string& name_space,
                                    const GURL& url);
 
   // Necessary callbacks for the offline page model.
   void OnSavePageDone(SavePageResult result, int64_t offlineId);
   void OnClearAllDone();
   void OnExpirePageDone(bool success);
   void OnGetURLDone(const GURL& url);
+  void OnSizeInBytesCalculated(int64_t size);
 
   // OfflinePageTestArchiver::Observer implementation:
   void SetLastPathCreatedByArchiver(const base::FilePath& file_path) override;
 
   TestingProfile* profile() { return &profile_; }
   content::WebContents* web_contents() const { return web_contents_.get(); }
 
   int64_t offline_id() const { return offline_id_; }
+  int64_t last_cache_size() { return last_cache_size_; }
+
+  void CreateCachedOfflinePages(base::SimpleTestClock* clock);
 
  private:
   void CreateOfflinePages();
   void CreateRequests();
   std::unique_ptr<OfflinePageTestArchiver> BuildArchiver(
       const GURL& url,
       const base::FilePath& file_name);
 
   content::TestBrowserThreadBundle browser_thread_bundle_;
   int64_t offline_id_;
   GURL url_;
   TestingProfile profile_;
   std::unique_ptr<content::WebContents> web_contents_;
   base::test::ScopedFeatureList scoped_feature_list_;
+  int64_t last_cache_size_;
 };
 
 OfflinePageUtilsTest::OfflinePageUtilsTest() = default;
 
 OfflinePageUtilsTest::~OfflinePageUtilsTest() {}
 
 void OfflinePageUtilsTest::SetUp() {
   // Enables offline pages feature.
   // TODO(jianli): Remove this once the feature is completely enabled.
   scoped_feature_list_.InitAndEnableFeature(
@@ skipping 48 matching lines @@
 }
 
 void OfflinePageUtilsTest::OnClearAllDone() {
   // Result ignored here.
 }
 
 void OfflinePageUtilsTest::OnGetURLDone(const GURL& url) {
   url_ = url;
 }
 
+void OfflinePageUtilsTest::OnSizeInBytesCalculated(int64_t size) {
+  last_cache_size_ = size;
+}
+
 void OfflinePageUtilsTest::SetLastPathCreatedByArchiver(
     const base::FilePath& file_path) {}
 
 void OfflinePageUtilsTest::CreateOfflinePages() {
   // Create page 1.
   std::unique_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
       kTestPage1Url, base::FilePath(FILE_PATH_LITERAL("page1.mhtml"))));
   offline_pages::ClientId client_id;
   client_id.name_space = kDownloadNamespace;
   client_id.id = kTestPage1ClientId;
@@ skipping 11 matching lines @@
       RequestCoordinatorFactory::GetForBrowserContext(profile());
 
   RequestCoordinator::SavePageLaterParams params;
   params.url = kTestPage3Url;
   params.client_id =
       offline_pages::ClientId(kDownloadNamespace, kTestPage3ClientId);
   request_coordinator->SavePageLater(params);
   RunUntilIdle();
 }
 
+void OfflinePageUtilsTest::CreateCachedOfflinePages(
+    base::SimpleTestClock* clock) {
+  // Add 4 temporary pages to the model used for test cases. And setting current
+  // time as the 00:00:00 time anchor.
+  offline_pages::ClientId client_id;
+  client_id.name_space = kBookmarkNamespace;
+
+  clock->SetNow(base::Time::Now());
+  // Time 01:00:00.
+  clock->Advance(base::TimeDelta::FromHours(1));
+  std::unique_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
+      kTestPage1Url, base::FilePath(FILE_PATH_LITERAL("page1.mhtml"))));
+  client_id.id = kTestPage1ClientId;
+  SavePage(kTestPage1Url, client_id, std::move(archiver));
+  // time 02:00:00.
+  clock->Advance(base::TimeDelta::FromHours(1));
+  archiver = BuildArchiver(kTestPage2Url,
+                           base::FilePath(FILE_PATH_LITERAL("page2.mhtml")));
+  client_id.id = kTestPage2ClientId;
+  SavePage(kTestPage2Url, client_id, std::move(archiver));
+  // time 03:00:00.
+  clock->Advance(base::TimeDelta::FromHours(1));
+  archiver = BuildArchiver(kTestPage3Url,
+                           base::FilePath(FILE_PATH_LITERAL("page3.mhtml")));
+  client_id.id = kTestPage3ClientId;
+  SavePage(kTestPage3Url, client_id, std::move(archiver));
+  // Add a temporary page to test boundary at 10:00:00.
+  clock->Advance(base::TimeDelta::FromHours(7));
+  archiver = BuildArchiver(kTestPage4Url,
+                           base::FilePath(FILE_PATH_LITERAL("page4.mhtml")));
+  client_id.id = kTestPage4ClientId;
+  SavePage(kTestPage4Url, client_id, std::move(archiver));
+  // Reset clock->to 03:00:00.
+  clock->SetNow(clock->Now() - base::TimeDelta::FromHours(7));
+}
+
 std::unique_ptr<OfflinePageTestArchiver> OfflinePageUtilsTest::BuildArchiver(
     const GURL& url,
     const base::FilePath& file_name) {
   std::unique_ptr<OfflinePageTestArchiver> archiver(new OfflinePageTestArchiver(
       this, url, OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED,
       base::string16(), kTestFileSize, base::ThreadTaskRunnerHandle::Get()));
   archiver->set_filename(file_name);
   return archiver;
 }
 
@@ skipping 79 matching lines @@
   EXPECT_TRUE(OfflinePageUtils::EqualsIgnoringFragment(
       GURL("http://example.com/"), GURL("http://example.com/#test")));
   EXPECT_TRUE(OfflinePageUtils::EqualsIgnoringFragment(
       GURL("http://example.com/#test"), GURL("http://example.com/")));
   EXPECT_TRUE(OfflinePageUtils::EqualsIgnoringFragment(
       GURL("http://example.com/#test"), GURL("http://example.com/#test2")));
   EXPECT_FALSE(OfflinePageUtils::EqualsIgnoringFragment(
       GURL("http://example.com/"), GURL("http://test.com/#test")));
 }
 
+TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeBetween) {
+  // Set a test clock before adding cached offline pages.
+  // The clock will be at 03:00:00 after adding pages.
+  OfflinePageModel* model =
+      OfflinePageModelFactory::GetForBrowserContext(profile());
+  base::SimpleTestClock clock;
+  static_cast<OfflinePageModelImpl*>(model)->set_testing_clock(&clock);
+  CreateCachedOfflinePages(&clock);
+
+  // Advance the clock so that we don't hit the time check boundary.
+  clock.Advance(base::TimeDelta::FromMinutes(5));
+
+  // Get the size of cached offline pages between 01:05:00 and 03:05:00.
+  bool ret = OfflinePageUtils::GetCachedOfflinePageSizeBetween(
+      profile(),
+      base::Bind(&OfflinePageUtilsTest::OnSizeInBytesCalculated, AsWeakPtr()),
+      clock.Now() - base::TimeDelta::FromHours(2), clock.Now());
+  RunUntilIdle();
+  EXPECT_TRUE(ret);
+  EXPECT_EQ(kTestFileSize * 2, last_cache_size());
+}
+
+TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeNoPageInModel) {
+  // Set a test clock before adding cached offline pages.
+  // The clock will be at 03:00:00 after adding pages.
+  OfflinePageModel* model =
+      OfflinePageModelFactory::GetForBrowserContext(profile());
+  base::SimpleTestClock clock;
+  static_cast<OfflinePageModelImpl*>(model)->set_testing_clock(&clock);
+
+  // Advance the clock so that we don't hit the time check boundary.
+  clock.Advance(base::TimeDelta::FromMinutes(5));
+
+  // Get the size of cached offline pages between 01:05:00 and 03:05:00.
+  bool ret = OfflinePageUtils::GetCachedOfflinePageSizeBetween(
+      profile(),
+      base::Bind(&OfflinePageUtilsTest::OnSizeInBytesCalculated, AsWeakPtr()),
+      clock.Now() - base::TimeDelta::FromHours(2), clock.Now());
+  RunUntilIdle();
+  EXPECT_TRUE(ret);
+  EXPECT_EQ(0, last_cache_size());
+}
+
+TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeNoPageInRange) {
+  // Set a test clock before adding cached offline pages.
+  // The clock will be at 03:00:00 after adding pages.
+  OfflinePageModel* model =
+      OfflinePageModelFactory::GetForBrowserContext(profile());
+  base::SimpleTestClock clock;
+  static_cast<OfflinePageModelImpl*>(model)->set_testing_clock(&clock);
+  CreateCachedOfflinePages(&clock);
+
+  // Advance the clock so that we don't hit the time check boundary.
+  clock.Advance(base::TimeDelta::FromMinutes(5));
+
+  // Get the size of cached offline pages between 03:04:00 and 03:05:00.
+  bool ret = OfflinePageUtils::GetCachedOfflinePageSizeBetween(
+      profile(),
+      base::Bind(&OfflinePageUtilsTest::OnSizeInBytesCalculated, AsWeakPtr()),
+      clock.Now() - base::TimeDelta::FromMinutes(1), clock.Now());
+  RunUntilIdle();
+  EXPECT_TRUE(ret);
+  EXPECT_EQ(0, last_cache_size());
+}
+
+TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeAllPagesInRange) {
+  // Set a test clock before adding cached offline pages.
+  // The clock will be at 03:00:00 after adding pages.
+  OfflinePageModel* model =
+      OfflinePageModelFactory::GetForBrowserContext(profile());
+  base::SimpleTestClock clock;
+  static_cast<OfflinePageModelImpl*>(model)->set_testing_clock(&clock);
+  CreateCachedOfflinePages(&clock);
+
+  // Advance the clock to 23:00:00.
+  clock.Advance(base::TimeDelta::FromHours(20));
+
+  // Get the size of cached offline pages between -01:00:00 and 23:00:00.
+  bool ret = OfflinePageUtils::GetCachedOfflinePageSizeBetween(
+      profile(),
+      base::Bind(&OfflinePageUtilsTest::OnSizeInBytesCalculated, AsWeakPtr()),
+      clock.Now() - base::TimeDelta::FromHours(24), clock.Now());
+  RunUntilIdle();
+  EXPECT_TRUE(ret);
+  EXPECT_EQ(kTestFileSize * 4, last_cache_size());
+}
+
+TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeAllPagesInvalidRange) {
+  // Set a test clock before adding cached offline pages.
+  // The clock will be at 03:00:00 after adding pages.
+  OfflinePageModel* model =
+      OfflinePageModelFactory::GetForBrowserContext(profile());
+  base::SimpleTestClock clock;
+  static_cast<OfflinePageModelImpl*>(model)->set_testing_clock(&clock);
+  CreateCachedOfflinePages(&clock);
+
+  // Advance the clock to 23:00:00.
+  clock.Advance(base::TimeDelta::FromHours(20));
+
+  // Get the size of cached offline pages between 23:00:00 and -01:00:00, which
+  // is an invalid range, the return value will be false and there will be no
+  // callback.
+  bool ret = OfflinePageUtils::GetCachedOfflinePageSizeBetween(
+      profile(),
+      base::Bind(&OfflinePageUtilsTest::OnSizeInBytesCalculated, AsWeakPtr()),
+      clock.Now(), clock.Now() - base::TimeDelta::FromHours(24));
+  RunUntilIdle();
+  EXPECT_FALSE(ret);
+}
+
 }  // namespace offline_pages