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/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 "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;

[twifkak, 2016/11/17 21:52:04]

FYI 40e6 is a float literal, which (by way of the constexpr) is getting cast at
compile time to an int. In this case, 40e6 is precise, so it works out. It feels
weird, but 53 bits ought to be enough for anybody, so I think it's fine.

[jamartin, 2016/11/18 03:55:32]

Acknowledged.

+
 // 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);
 
+  void OnCacheBackendReceived(int net_error_code);

[twifkak, 2016/11/17 21:52:04]

Add function doc.

[jamartin, 2016/11/18 03:55:32]

Done.

+
+  // Cache size is required to figure out whether on not we can proceed with
+  // StartPrecaching.
+  void OnCacheSizeReceived(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 HTTP cache. Used to get the current cache
+  // size. It is not owned and is reset on demand via callbacks.
+  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_