Do not precache when the cache size is small

components/precache/content/precache_manager.h

 // Copyright 2013 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_PRECACHE_CONTENT_PRECACHE_MANAGER_H_
 #define COMPONENTS_PRECACHE_CONTENT_PRECACHE_MANAGER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <list>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "components/history/core/browser/history_types.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/precache/core/precache_fetcher.h"
+#include "net/disk_cache/disk_cache.h"
+#include "net/http/http_cache.h"
 #include "url/gurl.h"
 
 namespace base {
 class FilePath;
 class Time;
 class TimeDelta;
 }
 
 namespace content {
 class BrowserContext;
@@ skipping 12 matching lines @@
 }
 
 namespace precache {
 
 class PrecacheDatabase;
 class PrecacheUnfinishedWork;
 
 // Visible for test.
 size_t NumTopHosts();
 
+// Minimum required cache size (inclusive).
+constexpr int kMinCacheSizeBytes = 40e6;

[gavinp, 2016/12/08 17:33:47]

minor nit: I find 40 * 1000 * 1000 an itsy bitsy bit more readable here. I just
can't quite count the e6 the same way; but that is likely my own problem.

[jamartin, 2016/12/08 22:43:58]

Done.

+
 // Class that manages all precaching-related activities. Owned by the
 // BrowserContext that it is constructed for. Use
 // PrecacheManagerFactory::GetForBrowserContext to get an instance of this
 // class. All methods must be called on the UI thread unless indicated
 // otherwise.
 // TODO(sclittle): Delete precache history when browsing history is deleted.
 // http://crbug.com/326549
 class PrecacheManager : public KeyedService,
                         public PrecacheFetcher::PrecacheDelegate,
                         public base::SupportsWeakPtr<PrecacheManager> {
@@ skipping 56 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(PrecacheManagerTest,
                            RecordStatsForFetchDuringPrecaching);
   FRIEND_TEST_ALL_PREFIXES(PrecacheManagerTest, RecordStatsForFetchHTTP);
   FRIEND_TEST_ALL_PREFIXES(PrecacheManagerTest, RecordStatsForFetchHTTPS);
   FRIEND_TEST_ALL_PREFIXES(PrecacheManagerTest, RecordStatsForFetchInTopHosts);
   FRIEND_TEST_ALL_PREFIXES(PrecacheManagerTest,
                            RecordStatsForFetchWithEmptyURL);
   FRIEND_TEST_ALL_PREFIXES(PrecacheManagerTest, RecordStatsForFetchWithNonHTTP);
   FRIEND_TEST_ALL_PREFIXES(PrecacheManagerTest,
                            RecordStatsForFetchWithSizeZero);
+  FRIEND_TEST_ALL_PREFIXES(PrecacheManagerTest,
+                           StartPrecachingStopsOnSmallCaches);
+  FRIEND_TEST_ALL_PREFIXES(PrecacheManagerTest,
+                           StartPrecachingWithGoodSizedCache);
 
   enum class AllowedType {
     ALLOWED,
     DISALLOWED,
     PENDING
   };
 
   // From KeyedService.
   void Shutdown() override;
 
   // From PrecacheFetcher::PrecacheDelegate.
   void OnDone() override;
 
   // Callback when fetching unfinished work from storage is done.
   void OnGetUnfinishedWorkDone(
       std::unique_ptr<PrecacheUnfinishedWork> unfinished_work);
 
   // From history::HistoryService::TopHosts.
   void OnHostsReceived(const history::TopHostsList& host_counts);
 
   // Initializes and Starts a PrecacheFetcher with unfinished work.
   void InitializeAndStartFetcher();
 
   // From history::HistoryService::TopHosts. Used for the control group, which
   // gets the list of TopHosts for metrics purposes, but otherwise does nothing.
   void OnHostsReceivedThenDone(const history::TopHostsList& host_counts);
 
+  // Chain of callbacks for StartPrecaching that make sure that we only precache
+  // if there is a cache big enough.
+  void PrecacheIfCacheIsBigEnough(
+      scoped_refptr<net::URLRequestContextGetter> url_request_context_getter);
+  void OnCacheBackendReceived(int net_error_code);
+  void OnCacheSizeReceived(int cache_size_bytes);
+  void OnCacheSizeReceivedInUIThread(int cache_size_bytes);
+
   // Returns true if precaching is allowed for the browser context.
   AllowedType PrecachingAllowed() const;
 
   // Update precache-related metrics in response to a URL being fetched.
   void RecordStatsForFetch(const GURL& url,
                            const GURL& referrer,
                            const base::TimeDelta& latency,
                            const base::Time& fetch_time,
                            const net::HttpResponseInfo& info,
                            int64_t size);
@@ skipping 27 matching lines @@
   // canceled.
   PrecacheCompletionCallback precache_completion_callback_;
 
   // The PrecacheDatabase for tracking precache metrics. Should only be used on
   // the DB thread.
   std::unique_ptr<PrecacheDatabase> precache_database_;
 
   // Flag indicating whether or not precaching is currently in progress.
   bool is_precaching_;
 
+  // Pointer to the backend of the cache. Required to get the size of the cache.
+  // It is not owned and it is reset on demand via callbacks.
+  // It should only be accessed from the IO thread.
+  disk_cache::Backend* cache_backend_;
+
+  // The minimum cache size allowed for precaching. We allow this to be modified
+  // for testing purposes.
+  int min_cache_size_bytes_ = kMinCacheSizeBytes;
+
   // Work that hasn't yet finished.
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work_;
 
   DISALLOW_COPY_AND_ASSIGN(PrecacheManager);
 };
 
 }  // namespace precache
 
 #endif  // COMPONENTS_PRECACHE_CONTENT_PRECACHE_MANAGER_H_