Allow embedder to use custom ResourceRequestAllowedNotifier

components/web_resource/web_resource_service.cc

 // Copyright 2012 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/web_resource/web_resource_service.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 26 matching lines @@
     PrefService* prefs,
     const GURL& web_resource_server,
     const std::string& application_locale,
     const char* last_update_time_pref_name,
     int start_fetch_delay_ms,
     int cache_update_delay_ms,
     net::URLRequestContextGetter* request_context,
     const char* disable_network_switch,
     const ParseJSONCallback& parse_json_callback)
     : prefs_(prefs),
-      resource_request_allowed_notifier_(prefs, disable_network_switch),
+      resource_request_allowed_notifier_(
+          new ResourceRequestAllowedNotifier(prefs, disable_network_switch)),
+      fetch_scheduled_(false),
       in_fetch_(false),
       web_resource_server_(web_resource_server),
       application_locale_(application_locale),
       last_update_time_pref_name_(last_update_time_pref_name),
       start_fetch_delay_ms_(start_fetch_delay_ms),
       cache_update_delay_ms_(cache_update_delay_ms),
       request_context_(request_context),
       parse_json_callback_(parse_json_callback),
       weak_ptr_factory_(this) {
-  resource_request_allowed_notifier_.Init(this);
+  resource_request_allowed_notifier_->Init(this);
   DCHECK(prefs);
 }
 
 void WebResourceService::StartAfterDelay() {
   // If resource requests are not allowed, we'll get a callback when they are.
-  if (resource_request_allowed_notifier_.ResourceRequestsAllowed())
+  if (resource_request_allowed_notifier_->ResourceRequestsAllowed())
     OnResourceRequestsAllowed();
 }
 
 WebResourceService::~WebResourceService() {
 }
 
 void WebResourceService::OnURLFetchComplete(const net::URLFetcher* source) {
   // Delete the URLFetcher when this function exits.
   std::unique_ptr<net::URLFetcher> clean_up_fetcher(url_fetcher_.release());
 
@@ skipping 19 matching lines @@
     // Stop loading new web resource data, and silently exit.
     // We do not call parse_json_callback_, so we need to call EndFetch()
     // ourselves.
     EndFetch();
   }
 }
 
 // Delay initial load of resource data into cache so as not to interfere
 // with startup time.
 void WebResourceService::ScheduleFetch(int64_t delay_ms) {
+  if (fetch_scheduled_)
+    return;
+  fetch_scheduled_ = true;
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&WebResourceService::StartFetch,
                             weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(delay_ms));
 }
 
+void WebResourceService::SetResourceRequestAllowedNotifier(
+    std::unique_ptr<ResourceRequestAllowedNotifier> notifier) {
+  resource_request_allowed_notifier_ = std::move(notifier);
+  resource_request_allowed_notifier_->Init(this);
+}
+
+bool WebResourceService::GetFetchScheduled() const {
+  return fetch_scheduled_;
+}
+
 // Initializes the fetching of data from the resource server.  Data
 // load calls OnURLFetchComplete.
 void WebResourceService::StartFetch() {
+  // Set to false so that next fetch can be scheduled after this fetch or
+  // if we recieve notification that resource is allowed.
+  fetch_scheduled_ = false;
+  // Check whether fetching is allowed.
+  if (!resource_request_allowed_notifier_->ResourceRequestsAllowed())
+    return;
+
   // First, put our next cache load on the MessageLoop.
   ScheduleFetch(cache_update_delay_ms_);
 
   // Set cache update time in preferences.
   prefs_->SetString(last_update_time_pref_name_,
                     base::DoubleToString(base::Time::Now().ToDoubleT()));
 
   // If we are still fetching data, exit.
   if (in_fetch_)
     return;
@@ skipping 63 matching lines @@
       // Wait at least |start_fetch_delay_ms_|.
       if (ms_until_update > start_fetch_delay_ms_)
         delay = ms_until_update;
     }
   }
   // Start fetch and wait for UpdateResourceCache.
   ScheduleFetch(delay);
 }
 
 }  // namespace web_resource