automate subscription refreshes

browser/ui/webui/brave_adblock_ui.cc

@@ -205,7 +205,7 @@ void AdblockDOMHandler::HandleRefreshSubscription(const base::ListValue* args) {
   }
   g_brave_browser_process->ad_block_service()
       ->subscription_service_manager()
-      ->RefreshSubscription(list_url);
+      ->RefreshSubscription(list_url, true);
   // TODO callback and show the result when finished
 }
 

components/brave_shields/browser/BUILD.gn

@@ -47,6 +47,7 @@ static_library("browser") {
 
   deps = [
     "//base",
+    "//base/util/timer:timer",
     "//brave/common:pref_names",
     "//brave/components/adblock_rust_ffi",
     "//brave/components/brave_component_updater/browser",

components/brave_shields/browser/ad_block_subscription_service.cc

@@ -19,6 +19,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
+#include "base/util/timer/wall_clock_timer.h"
 #include "brave/common/pref_names.h"
 #include "brave/components/adblock_rust_ffi/src/wrapper.h"
 #include "brave/components/brave_shields/browser/ad_block_service.h"
@@ -28,6 +29,10 @@
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
 
+namespace {
+const base::TimeDelta kListUpdateInterval = base::TimeDelta::FromDays(7);
+}
+
 namespace brave_shields {
 
 FilterListSubscriptionInfo BuildInfoFromDict(const GURL& list_url,
@@ -53,24 +58,48 @@ FilterListSubscriptionInfo BuildInfoFromDict(const GURL& list_url,
 }
 
 // Constructor for a new subscription
+// |refresh_callback| will not be called; the new list download should be
+// initiated by the caller. |refresh_callback| will only initiate a
+// low-priority background download, whereas it should be immediate when
+// initiated by a user adding a new subscription.
 AdBlockSubscriptionService::AdBlockSubscriptionService(
     const GURL& list_url,
+    AdBlockSubscriptionService::RefreshSubscriptionCallback refresh_callback,
     brave_component_updater::BraveComponent::Delegate* delegate)
-    : AdBlockBaseService(delegate), list_url_(list_url), enabled_(true) {}
+    : AdBlockBaseService(delegate),
+      refresh_callback_(refresh_callback),
+      list_url_(list_url),
+      enabled_(true) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+}
 
 // Constructor from cached information
 AdBlockSubscriptionService::AdBlockSubscriptionService(
     const FilterListSubscriptionInfo& cached_info,
+    AdBlockSubscriptionService::RefreshSubscriptionCallback refresh_callback,
     brave_component_updater::BraveComponent::Delegate* delegate)
     : AdBlockBaseService(delegate),
+      refresh_callback_(refresh_callback),
       list_url_(cached_info.list_url),
       enabled_(cached_info.enabled),
       last_update_attempt_(cached_info.last_update_attempt),
       last_successful_update_attempt_(
           cached_info.last_successful_update_attempt) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   GetTaskRunner()->PostTask(
       FROM_HERE, base::BindOnce(&AdBlockSubscriptionService::ReloadFilters,
                                 base::Unretained(this)));
+
+  const base::Time next_update = last_update_attempt_ + kListUpdateInterval;
+  const base::TimeDelta until_next_update = next_update - base::Time::Now();
+  // Schedule the next update for the list - either immediately, or in the
+  // future with a delayed task
+  if (until_next_update <= base::TimeDelta::FromSeconds(0)) {
+    content::GetUIThreadTaskRunner({base::TaskPriority::BEST_EFFORT})
+        ->PostTask(FROM_HERE, refresh_callback_);
+  } else {
+    update_timer_.Start(FROM_HERE, next_update, refresh_callback_);
+  }
 }
 
 AdBlockSubscriptionService::~AdBlockSubscriptionService() {}
@@ -114,6 +143,19 @@ void AdBlockSubscriptionService::OnSuccessfulDownload() {
   last_successful_update_attempt_ = last_update_attempt_;
 
   ReloadFilters();
+
+  content::GetUIThreadTaskRunner({})->PostTask(
+      FROM_HERE,
+      base::BindOnce(&AdBlockSubscriptionService::ScheduleRefreshOnUIThread,
+                     base::Unretained(this),
+                     last_update_attempt_ + kListUpdateInterval));
+}
+
+void AdBlockSubscriptionService::ScheduleRefreshOnUIThread(
+    base::Time next_download_time) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  update_timer_.Start(FROM_HERE, next_download_time, refresh_callback_);
 }
 
 void AdBlockSubscriptionService::OnComponentReady(
@@ -125,14 +167,18 @@ void AdBlockSubscriptionService::OnComponentReady(
 
 std::unique_ptr<AdBlockSubscriptionService> AdBlockSubscriptionServiceFactory(
     const GURL& list_url,
+    AdBlockSubscriptionService::RefreshSubscriptionCallback refresh_callback,
     brave_component_updater::BraveComponent::Delegate* delegate) {
-  return std::make_unique<AdBlockSubscriptionService>(list_url, delegate);
+  return std::make_unique<AdBlockSubscriptionService>(
+      list_url, refresh_callback, delegate);
 }
 
 std::unique_ptr<AdBlockSubscriptionService> AdBlockSubscriptionServiceFactory(
     const FilterListSubscriptionInfo& cached_info,
+    AdBlockSubscriptionService::RefreshSubscriptionCallback refresh_callback,
     brave_component_updater::BraveComponent::Delegate* delegate) {
-  return std::make_unique<AdBlockSubscriptionService>(cached_info, delegate);
+  return std::make_unique<AdBlockSubscriptionService>(
+      cached_info, refresh_callback, delegate);
 }
 
 }  // namespace brave_shields

components/brave_shields/browser/ad_block_subscription_service.h

@@ -14,6 +14,7 @@
 
 #include "base/files/file_path.h"
 #include "base/time/time.h"
+#include "base/util/timer/wall_clock_timer.h"
 #include "brave/components/brave_shields/browser/ad_block_base_service.h"
 
 class AdBlockServiceTest;
@@ -44,13 +45,17 @@ FilterListSubscriptionInfo BuildInfoFromDict(const GURL& list_url,
 // for a custom filter list subscription.
 class AdBlockSubscriptionService : public AdBlockBaseService {
  public:
+  using RefreshSubscriptionCallback = base::RepeatingCallback<void()>;
+
   // Constructor for a new subscription
   explicit AdBlockSubscriptionService(
       const GURL& list_url,
+      RefreshSubscriptionCallback refresh_callback,
       brave_component_updater::BraveComponent::Delegate* delegate);
   // Constructor from cached information
   explicit AdBlockSubscriptionService(
       const FilterListSubscriptionInfo& cached_info,
+      RefreshSubscriptionCallback refresh_callback,
       brave_component_updater::BraveComponent::Delegate* delegate);
   ~AdBlockSubscriptionService() override;
 
@@ -75,6 +80,9 @@ class AdBlockSubscriptionService : public AdBlockBaseService {
       const std::string& component_id,
       const std::string& component_base64_public_key);
   void ReloadFilters();
+  void ScheduleRefreshOnUIThread(base::Time next_download_time);
+
+  RefreshSubscriptionCallback refresh_callback_;
 
   std::string list_contents_;
 
@@ -86,6 +94,8 @@ class AdBlockSubscriptionService : public AdBlockBaseService {
   base::Time last_update_attempt_;
   base::Time last_successful_update_attempt_;
 
+  util::WallClockTimer update_timer_;
+
   base::WeakPtrFactory<AdBlockSubscriptionService> weak_factory_{this};
 
   AdBlockSubscriptionService(const AdBlockSubscriptionService&) = delete;
@@ -96,10 +106,12 @@ class AdBlockSubscriptionService : public AdBlockBaseService {
 // Creates the AdBlockSubscriptionService
 std::unique_ptr<AdBlockSubscriptionService> AdBlockSubscriptionServiceFactory(
     const GURL& list_url,
+    AdBlockSubscriptionService::RefreshSubscriptionCallback refresh_callback,
     brave_component_updater::BraveComponent::Delegate* delegate);
 
 std::unique_ptr<AdBlockSubscriptionService> AdBlockSubscriptionServiceFactory(
-    const FilterListSubscriptionInfo& list_url,
+    const FilterListSubscriptionInfo& info,
+    AdBlockSubscriptionService::RefreshSubscriptionCallback refresh_callback,
     brave_component_updater::BraveComponent::Delegate* delegate);
 
 }  // namespace brave_shields

components/brave_shields/browser/ad_block_subscription_service_manager.cc

@@ -95,8 +95,12 @@ AdBlockSubscriptionServiceManager::~AdBlockSubscriptionServiceManager() {}
 
 void AdBlockSubscriptionServiceManager::CreateSubscription(
     const GURL list_url) {
+  auto refresh_callback = base::BindRepeating(
+      &AdBlockSubscriptionServiceManager::RefreshSubscription,
+      base::Unretained(this), list_url, false);
+
   auto subscription_service =
-      AdBlockSubscriptionServiceFactory(list_url, delegate_);
+      AdBlockSubscriptionServiceFactory(list_url, refresh_callback, delegate_);
   subscription_service->Start();
 
   base::PostTask(
@@ -154,10 +158,12 @@ void AdBlockSubscriptionServiceManager::DeleteSubscription(
 }
 
 void AdBlockSubscriptionServiceManager::RefreshSubscription(
-    const SubscriptionIdentifier& id) {
+    const SubscriptionIdentifier& id,
+    bool from_ui) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   auto it = subscription_services_.find(id);
   DCHECK(it != subscription_services_.end());
-  download_manager_->StartDownload(it->second->GetInfo().list_url, true);
+  download_manager_->StartDownload(it->second->GetInfo().list_url, from_ui);
 }
 
 void AdBlockSubscriptionServiceManager::InitializeDownloadManager(
@@ -191,10 +197,16 @@ void AdBlockSubscriptionServiceManager::StartSubscriptionServices() {
     const base::Value* list_subscription_dict =
         list_subscriptions_dict->FindDictKey(uuid);
     if (list_subscription_dict) {
-      info = BuildInfoFromDict(GURL(uuid), list_subscription_dict);
+      const GURL list_url = GURL(uuid);
+
+      info = BuildInfoFromDict(list_url, list_subscription_dict);
+
+      auto refresh_callback = base::BindRepeating(
+          &AdBlockSubscriptionServiceManager::RefreshSubscription,
+          base::Unretained(this), list_url, false);
 
       auto subscription_service =
-          AdBlockSubscriptionServiceFactory(info, delegate_);
+          AdBlockSubscriptionServiceFactory(info, refresh_callback, delegate_);
       subscription_service->Start();
 
       subscription_services_.insert(

components/brave_shields/browser/ad_block_subscription_service_manager.h

@@ -54,7 +54,7 @@ class AdBlockSubscriptionServiceManager : public ProfileManagerObserver {
   std::vector<FilterListSubscriptionInfo> GetSubscriptions() const;
   void EnableSubscription(const SubscriptionIdentifier& id, bool enabled);
   void DeleteSubscription(const SubscriptionIdentifier& id);
-  void RefreshSubscription(const SubscriptionIdentifier& id);
+  void RefreshSubscription(const SubscriptionIdentifier& id, bool from_ui);
   void CreateSubscription(const GURL list_url);
 
   bool IsInitialized() const;