Show the exact cache size for time ranges if supported

components/browsing_data/content/conditional_cache_counting_helper.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/browsing_data/content/conditional_cache_counting_helper.h"
 
 #include "base/callback.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 39 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 base::WeakPtr<ConditionalCacheCountingHelper>
 ConditionalCacheCountingHelper::CountAndDestroySelfWhenFinished(
     const CacheCountCallback& result_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!result_callback.is_null());
   result_callback_ = result_callback;
   calculation_result_ = 0;
+  is_upper_limit_ = false;
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ConditionalCacheCountingHelper::CountHttpCacheOnIOThread,
                  base::Unretained(this)));
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 bool ConditionalCacheCountingHelper::IsFinished() {
   return is_finished_;
 }
 
 void ConditionalCacheCountingHelper::Finished() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!is_finished_);
   is_finished_ = true;
-  result_callback_.Run(calculation_result_);
+  result_callback_.Run(calculation_result_, is_upper_limit_);
   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
 }
 
 void ConditionalCacheCountingHelper::CountHttpCacheOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   next_cache_state_ = CacheState::NONE;
   DCHECK_EQ(CacheState::NONE, next_cache_state_);
   DCHECK(main_context_getter_.get());
   DCHECK(media_context_getter_.get());
 
@@ skipping 47 matching lines @@
                                 ? CacheState::CREATE_MEDIA
                                 : CacheState::DONE;
 
         // |cache_| can be null if it cannot be initialized.
         if (cache_) {
           if (begin_time_.is_null() && end_time_.is_max()) {
             rv = cache_->CalculateSizeOfAllEntries(
                 base::Bind(&ConditionalCacheCountingHelper::DoCountCache,
                            base::Unretained(this)));
           } else {
-            // TODO(dullweber): Readd code for counting with timeout.
-            // TODO(dullweber): Implement faster counting for SimpleBackendImpl.
-            rv = cache_->CalculateSizeOfAllEntries(
+            rv = cache_->CalculateSizeOfEntriesBetween(
+                begin_time_, end_time_,
                 base::Bind(&ConditionalCacheCountingHelper::DoCountCache,
                            base::Unretained(this)));
+            if (rv == net::ERR_NOT_IMPLEMENTED) {
+              is_upper_limit_ = true;
+              rv = cache_->CalculateSizeOfAllEntries(
+                  base::Bind(&ConditionalCacheCountingHelper::DoCountCache,
+                             base::Unretained(this)));
+            }
           }
           cache_ = NULL;
         }
         break;
       }
       case CacheState::DONE: {
         cache_ = NULL;
         next_cache_state_ = CacheState::NONE;
         // Notify the UI thread that we are done.
         BrowserThread::PostTask(
             BrowserThread::UI, FROM_HERE,
             base::Bind(&ConditionalCacheCountingHelper::Finished,
                        base::Unretained(this)));
         return;
       }
       case CacheState::NONE: {
         NOTREACHED() << "bad state";
         return;
       }
     }
   }
 }
 
 }  // namespace browsing_data