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

chrome/browser/browsing_data/cache_counter.cc

 // Copyright (c) 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/browsing_data/cache_counter.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/browsing_data/content/conditional_cache_counting_helper.h"
 #include "components/browsing_data/core/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/net_errors.h"
 
+#if defined(OS_ANDROID)
+#include "chrome/browser/android/offline_pages/offline_page_utils.h"
+#endif  // OS_ANDROID
+
 CacheCounter::CacheResult::CacheResult(const CacheCounter* source,
                                        int64_t cache_size,
                                        bool is_upper_limit)
     : FinishedResult(source, cache_size),
       cache_size_(cache_size),
       is_upper_limit_(is_upper_limit) {}
 
 CacheCounter::CacheResult::~CacheResult() {}
 
 CacheCounter::CacheCounter(Profile* profile)
@@ skipping 14 matching lines @@
   weak_ptr_factory_.InvalidateWeakPtrs();
   base::WeakPtr<browsing_data::ConditionalCacheCountingHelper> counter =
       browsing_data::ConditionalCacheCountingHelper::CreateForRange(
           content::BrowserContext::GetDefaultStoragePartition(profile_),
           GetPeriodStart(), base::Time::Max())
           ->CountAndDestroySelfWhenFinished(
               base::Bind(&CacheCounter::OnCacheSizeCalculated,
                          weak_ptr_factory_.GetWeakPtr()));
 }
 
-void CacheCounter::OnCacheSizeCalculated(int64_t result_bytes,
+void CacheCounter::OnCacheSizeCalculated(int64_t cache_bytes,

[dewittj, 2017/05/09 01:29:54]

nit: rename to OnBrowsingDataCacheSizeCalculated

[romax, 2017/05/09 21:08:45]

Done.

                                          bool is_upper_limit) {
   // A value less than 0 means a net error code.
-  if (result_bytes < 0)
+  if (cache_bytes < 0)
     return;

[dewittj, 2017/05/09 01:29:53]

It's not clear that we should return here anymore.  I'm also not clear what the
comment above the if is supposed to mean, can you explain?

[romax, 2017/05/09 21:08:45]

if this value is <0, it means there was an error during counting browsing data
cache. In this case, it would just return which will keep a 'Calculating...'
string on UI side.
I'd still like to return here since there's one part which cannot be counted
correctly and whatever number we show will be wrong, so why not just fail the
whole counting?

+
+#if defined(OS_ANDROID)
+  if (offline_pages::OfflinePageUtils::GetCachedOfflinePageSizeBetween(

[dullweber, 2017/05/09 07:56:01]

Could you start both cache calculations in parallel? Then you wouldn't have to
pass the cache_bytes and is_upper_limit through your function.

Both functions could have the same on_cache_size_calculated(size, upperlimit)
callback, which accumulates the size and tracks if both tasks have returned.

(upper_limit is used because some browser cache backends can't efficiently
determine the size of a subset of the cache, so we just use the total size)

[romax, 2017/05/09 21:08:45]

Done.
But in order to reuse the callback I changed the order of the argument so that
the base::Bind can work for the offline page counter.

+          profile_,
+          base::Bind(&CacheCounter::OnOfflinePageSizeCalculated,
+                     weak_ptr_factory_.GetWeakPtr(), cache_bytes,
+                     is_upper_limit),
+          GetPeriodStart(), base::Time::Max())) {
+    return;
+  }
+#endif  // OS_ANDROID
   auto result =
-      base::MakeUnique<CacheResult>(this, result_bytes, is_upper_limit);
+      base::MakeUnique<CacheResult>(this, cache_bytes, is_upper_limit);
   ReportResult(std::move(result));
 }
+
+#if defined(OS_ANDROID)

[dewittj, 2017/05/09 01:29:53]

I'd not make this android-only, and just call it with 0 offline page bytes at
the end of OnCacheSizeCalculated, removing the ReporrtResult duplication.

[romax, 2017/05/09 21:08:45]

Done.

+void CacheCounter::OnOfflinePageSizeCalculated(
+    int64_t cache_bytes,

[dewittj, 2017/05/09 01:29:53]

rename to cached_browsing_data_bytes

[romax, 2017/05/09 21:08:45]

Done.

+    bool is_upper_limit,

[dewittj, 2017/05/09 01:29:54]

do we need to compute the upper limit?  Why is this passthrough?

[romax, 2017/05/09 21:08:45]

we don't need to compute it (or it can be always false). It is only used by the
browsing data cache for the reason described by dullweber@ above. This is
passing through because the place where ReportResult is handled will have a
special handling if is_upper_limit is true.

+    int64_t cached_offline_page_bytes) {
+  auto result = base::MakeUnique<CacheResult>(
+      this, cached_offline_page_bytes + cache_bytes, is_upper_limit);
+  ReportResult(std::move(result));
+}
+#endif  // OS_ANDROID