Inject JSON parsing in WebResource as a callback rather than inheritance

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/prefs/pref_service.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 21 matching lines @@
 namespace web_resource {
 
 WebResourceService::WebResourceService(
     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 char* disable_network_switch,
+    const ParseJSONCallback& parse_json_callback)
     : prefs_(prefs),
       resource_request_allowed_notifier_(prefs, disable_network_switch),
       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);
   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())
     OnResourceRequestsAllowed();
 }
 
 WebResourceService::~WebResourceService() {
 }
 
 void WebResourceService::OnURLFetchComplete(const net::URLFetcher* source) {
   // Delete the URLFetcher when this function exits.
   scoped_ptr<net::URLFetcher> clean_up_fetcher(url_fetcher_.release());
 
   if (source->GetStatus().is_success() && source->GetResponseCode() == 200) {
     std::string data;
     source->GetResponseAsString(&data);
     // Calls EndFetch() on completion.
     // Full JSON parsing might spawn a utility process (for security).
     // To limit the the number of simultaneously active processes
     // (on Android in particular) we short-cut the full parsing in the case of
     // trivially "empty" JSONs.
     if (data.empty() || data == "{}") {
       OnUnpackFinished(make_scoped_ptr(new base::DictionaryValue()).Pass());
     } else {
-      ParseJSON(data, base::Bind(&WebResourceService::OnUnpackFinished,
-                                 weak_ptr_factory_.GetWeakPtr()),
-                base::Bind(&WebResourceService::OnUnpackError,
-                           weak_ptr_factory_.GetWeakPtr()));
+      parse_json_callback_.Run(data,
+                               base::Bind(&WebResourceService::OnUnpackFinished,
+                                          weak_ptr_factory_.GetWeakPtr()),
+                               base::Bind(&WebResourceService::OnUnpackError,
+                                          weak_ptr_factory_.GetWeakPtr()));
     }
   } else {
     // Don't parse data if attempt to download was unsuccessful.
     // Stop loading new web resource data, and silently exit.
-    // We do not call ParseJSON(), so we need to call EndFetch() ourselves.
+    // 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 delay_ms) {
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&WebResourceService::StartFetch,
                             weak_ptr_factory_.GetWeakPtr()),
@@ skipping 76 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