Bug 1211984 - PR fixes, added dynamic cache size

mozilla-mobile · Nov 2, 2015 · 7d760a1 · rnewman · Nov 2, 2015 · 7d760a1
1 parent b24153a
commit 7d760a1
Show file tree

Hide file tree

Showing 5 changed files with 28 additions and 22 deletions.
diff --git a/Client/Frontend/Home/TopSitesPanel.swift b/Client/Frontend/Home/TopSitesPanel.swift
@@ -82,7 +82,9 @@ class TopSitesPanel: UIViewController {
             make.edges.equalTo(self.view)
         }
         self.collection = collection
-        self.refreshHistory(maxFrecencyLimit)
+
+        self.profile.history.setTopSitesCacheSize(Int32(maxFrecencyLimit))
+        self.refreshTopSites(maxFrecencyLimit)
     }
 
     deinit {
@@ -92,7 +94,7 @@ class TopSitesPanel: UIViewController {
     func notificationReceived(notification: NSNotification) {
         switch notification.name {
         case NotificationFirefoxAccountChanged:
-            refreshHistory(maxFrecencyLimit)
+            refreshTopSites(maxFrecencyLimit)
             break
         default:
             // no need to do anything at all
@@ -135,15 +137,13 @@ class TopSitesPanel: UIViewController {
         }
     }
 
-    private func refreshHistory(frequencyLimit: Int) {
+    private func refreshTopSites(frequencyLimit: Int) {
         // Reload right away with whatever is in the cache, then check to see if the cache is invalid. If it's invalid,
         // invalidate the cache and requery. This allows us to always show results right away if they are cached but
         // also load in the up-to-date results asynchronously if needed
-        reloadTopSitesWithLimit(frequencyLimit) >>== {
-            self.profile.history.invalidateTopSitesIfNeeded().upon { result in
-                if result {
-                    self.reloadTopSitesWithLimit(frequencyLimit)
-                }
+        reloadTopSitesWithLimit(frequencyLimit) >>> {
+            return self.profile.history.invalidateTopSitesIfNeeded() >>== { result in
+                return result ? self.reloadTopSitesWithLimit(frequencyLimit) : succeed()
             }
         }
     }

diff --git a/Providers/Profile.swift b/Providers/Profile.swift
@@ -234,6 +234,7 @@ public class BrowserProfile: Profile {
         }
     }
 
+    // These selectors run on which ever thread sent the notifications (not the main thread)
     @objc
     func onProfileDidFinishSyncing(notification: NSNotification) {
         history.setTopSitesNeedsInvalidation()

diff --git a/Storage/History.swift b/Storage/History.swift
@@ -29,7 +29,8 @@ public protocol BrowserHistory {
 
     func getTopSitesWithLimit(limit: Int) -> Deferred<Maybe<Cursor<Site>>>
     func setTopSitesNeedsInvalidation()
-    func invalidateTopSitesIfNeeded() -> Deferred<Bool>
+    func invalidateTopSitesIfNeeded() -> Deferred<Maybe<Bool>>
+    func setTopSitesCacheSize(size: Int32)
 }
 
 /**

diff --git a/Storage/SQL/SQLiteHistory.swift b/Storage/SQL/SQLiteHistory.swift
@@ -8,8 +8,6 @@ import XCGLogger
 
 private let log = Logger.syncLogger
 
-private let TopSitesCacheSize = 100
-
 class NoSuchRecordError: MaybeErrorType {
     let guid: GUID
     init(guid: GUID) {
@@ -268,18 +266,23 @@ extension SQLiteHistory: BrowserHistory {
         prefs.setBool(false, forKey: PrefsKeys.KeyTopSitesCacheIsValid)
     }
 
-    public func invalidateTopSitesIfNeeded() -> Deferred<Bool> {
-        let deferred = Deferred<Bool>()
-        if !(prefs.boolForKey(PrefsKeys.KeyTopSitesCacheIsValid) ?? false) {
-            purgeTopSitesCache() >>== {
-                self.updateTopSitesCacheWithLimit(TopSitesCacheSize) >>== {
-                    deferred.fill(true)
-                }
-            }
-        } else {
-            deferred.fill(false)
+    public func invalidateTopSitesIfNeeded() -> Deferred<Maybe<Bool>> {
+        if prefs.boolForKey(PrefsKeys.KeyTopSitesCacheIsValid) ?? false {
+            return deferMaybe(false)
+        }
+
+        let cacheSize = Int(prefs.intForKey(PrefsKeys.KeyTopSitesCacheSize) ?? 0)
+        return purgeTopSitesCache()
+            >>> { self.updateTopSitesCacheWithLimit(cacheSize) }
+            >>> always(true)
+    }
+
+    public func setTopSitesCacheSize(size: Int32) {
+        let oldValue = prefs.intForKey(PrefsKeys.KeyTopSitesCacheSize) ?? 0
+        if oldValue != size {
+            prefs.setInt(size, forKey: PrefsKeys.KeyTopSitesCacheSize)
+            setTopSitesNeedsInvalidation()
         }
-        return deferred
     }
 
     private func updateTopSitesCacheWithLimit(limit : Int) -> Success {

diff --git a/Utils/Prefs.swift b/Utils/Prefs.swift
@@ -8,6 +8,7 @@ public struct PrefsKeys {
     public static let KeyLastRemoteTabSyncTime = "lastRemoteTabSyncTime"
     public static let KeyLastSyncFinishTime = "lastSyncFinishTime"
     public static let KeyTopSitesCacheIsValid = "topSitesCacheIsValid"
+    public static let KeyTopSitesCacheSize = "topSitesCacheSize"
 }
 
 public protocol Prefs {