Refactoring: ProtocolHandler::MaybeCreateJob takes NetworkDelegate as argument

webkit/appcache/view_appcache_internals_job.cc

 // Copyright (c) 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 <algorithm>
 #include <string>
 
 #include "webkit/appcache/view_appcache_internals_job.h"
 
 #include "base/base64.h"
@@ skipping 293 matching lines @@
 
 GURL ClearQuery(const GURL& url) {
   GURL::Replacements replacements;
   replacements.ClearQuery();
   return url.ReplaceComponents(replacements);
 }
 
 // Simple base class for the job subclasses defined here.
 class BaseInternalsJob : public net::URLRequestSimpleJob {
  protected:
-  BaseInternalsJob(net::URLRequest* request, AppCacheService* service)
-      : URLRequestSimpleJob(request), appcache_service_(service) {}
+  BaseInternalsJob(net::URLRequest* request,
+                   net::NetworkDelegate* network_delegate,
+                   AppCacheService* service)
+      : URLRequestSimpleJob(request, network_delegate),
+        appcache_service_(service) {}
   virtual ~BaseInternalsJob() {}
 
   AppCacheService* appcache_service_;
 };
 
 // Job that lists all appcaches in the system.
 class MainPageJob : public BaseInternalsJob {
  public:
-  MainPageJob(net::URLRequest* request, AppCacheService* service)
-      : BaseInternalsJob(request, service),
+  MainPageJob(net::URLRequest* request,
+              net::NetworkDelegate* network_delegate,
+              AppCacheService* service)
+      : BaseInternalsJob(request, network_delegate, service),
         ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   }
 
   virtual void Start() {
     DCHECK(request_);
     info_collection_ = new AppCacheInfoCollection;
     appcache_service_->GetAllAppCacheInfo(
         info_collection_, base::Bind(&MainPageJob::OnGotInfoComplete,
                                      weak_factory_.GetWeakPtr()));
   }
@@ skipping 40 matching lines @@
   }
 
   base::WeakPtrFactory<MainPageJob> weak_factory_;
   scoped_refptr<AppCacheInfoCollection> info_collection_;
   DISALLOW_COPY_AND_ASSIGN(MainPageJob);
 };
 
 // Job that redirects back to the main appcache internals page.
 class RedirectToMainPageJob : public BaseInternalsJob {
  public:
-  RedirectToMainPageJob(net::URLRequest* request, AppCacheService* service)
-      : BaseInternalsJob(request, service) {}
+  RedirectToMainPageJob(net::URLRequest* request,
+                        net::NetworkDelegate* network_delegate,
+                        AppCacheService* service)
+      : BaseInternalsJob(request, network_delegate, service) {}
 
   virtual int GetData(std::string* mime_type,
                       std::string* charset,
                       std::string* data,
                       const net::CompletionCallback& callback) const OVERRIDE {
     return net::OK;  // IsRedirectResponse induces a redirect.
   }
 
   virtual bool IsRedirectResponse(GURL* location, int* http_status_code) {
     *location = ClearQuery(request_->url());
     *http_status_code = 307;
     return true;
   }
 
  protected:
   virtual ~RedirectToMainPageJob() {}
 };
 
 // Job that removes an appcache and then redirects back to the main page.
 class RemoveAppCacheJob : public RedirectToMainPageJob {
  public:
   RemoveAppCacheJob(
-      net::URLRequest* request, AppCacheService* service,
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate,
+      AppCacheService* service,
       const GURL& manifest_url)
-      : RedirectToMainPageJob(request, service),
+      : RedirectToMainPageJob(request, network_delegate, service),
         manifest_url_(manifest_url),
         ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   }
 
   virtual void Start() {
     DCHECK(request_);
 
     appcache_service_->DeleteAppCacheGroup(
         manifest_url_,base::Bind(&RemoveAppCacheJob::OnDeleteAppCacheComplete,
                                  weak_factory_.GetWeakPtr()));
   }
 
  private:
   virtual ~RemoveAppCacheJob() {}
 
   void OnDeleteAppCacheComplete(int rv) {
     StartAsync();  // Causes the base class to redirect.
   }
 
   GURL manifest_url_;
   base::WeakPtrFactory<RemoveAppCacheJob> weak_factory_;
 };
 
 
 // Job shows the details of a particular manifest url.
 class ViewAppCacheJob : public BaseInternalsJob,
                         public AppCacheStorage::Delegate {
  public:
   ViewAppCacheJob(
-      net::URLRequest* request, AppCacheService* service,
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate,
+      AppCacheService* service,
       const GURL& manifest_url)
-      : BaseInternalsJob(request, service),
+      : BaseInternalsJob(request, network_delegate, service),
         manifest_url_(manifest_url) {}
 
   virtual void Start() {
     DCHECK(request_);
     appcache_service_->storage()->LoadOrCreateGroup(manifest_url_, this);
   }
 
   // Produces a page containing the entries listing.
   virtual int GetData(std::string* mime_type,
                       std::string* charset,
@@ skipping 46 matching lines @@
   AppCacheInfo appcache_info_;
   AppCacheResourceInfoVector resource_infos_;
   DISALLOW_COPY_AND_ASSIGN(ViewAppCacheJob);
 };
 
 // Job that shows the details of a particular cached resource.
 class ViewEntryJob : public BaseInternalsJob,
                      public AppCacheStorage::Delegate {
  public:
   ViewEntryJob(
-      net::URLRequest* request, AppCacheService* service,
-      const GURL& manifest_url, const GURL& entry_url,
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate,
+      AppCacheService* service,
+      const GURL& manifest_url,
+      const GURL& entry_url,
       int64 response_id, int64 group_id)
-      : BaseInternalsJob(request, service),
+      : BaseInternalsJob(request, network_delegate, service),
         manifest_url_(manifest_url), entry_url_(entry_url),
         response_id_(response_id), group_id_(group_id), amount_read_(0) {
   }
 
   virtual void Start() {
     DCHECK(request_);
     appcache_service_->storage()->LoadResponseInfo(
         manifest_url_, group_id_, response_id_, this);
   }
 
@@ skipping 67 matching lines @@
   int64 group_id_;
   scoped_refptr<AppCacheResponseInfo> response_info_;
   scoped_refptr<net::IOBuffer> response_data_;
   int amount_read_;
   scoped_ptr<AppCacheResponseReader> reader_;
 };
 
 }  // namespace
 
 net::URLRequestJob* ViewAppCacheInternalsJobFactory::CreateJobForRequest(
-    net::URLRequest* request,  AppCacheService* service) {
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate,
+    AppCacheService* service) {
   if (!request->url().has_query())
-    return new MainPageJob(request, service);
+    return new MainPageJob(request, network_delegate, service);
 
   std::string command;
   std::string param;
   ParseQuery(request->url().query(), &command, &param);
 
   if (command == kRemoveCacheCommand)
-    return new RemoveAppCacheJob(request, service,
+    return new RemoveAppCacheJob(request, network_delegate, service,
                                  DecodeBase64URL(param));
 
   if (command == kViewCacheCommand)
-    return new ViewAppCacheJob(request, service,
+    return new ViewAppCacheJob(request, network_delegate, service,
                                DecodeBase64URL(param));
 
   std::vector<std::string> tokens;
   int64 response_id;
   int64 group_id;
   if (command == kViewEntryCommand && Tokenize(param, "|", &tokens) == 4u &&
       base::StringToInt64(tokens[2], &response_id) &&
       base::StringToInt64(tokens[3], &group_id)) {
-    return new ViewEntryJob(request, service,
+    return new ViewEntryJob(request, network_delegate, service,
                             DecodeBase64URL(tokens[0]),  // manifest url
                             DecodeBase64URL(tokens[1]),  // entry url
                             response_id, group_id);
   }
 
-  return new RedirectToMainPageJob(request, service);
+  return new RedirectToMainPageJob(request, network_delegate, service);
 }
 
 }  // namespace appcache