Refactoring: ProtocolHandler::MaybeCreateJob takes NetworkDelegate as argument

chrome/browser/extensions/extension_protocols.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 "chrome/browser/extensions/extension_protocols.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
@@ skipping 13 matching lines @@
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/resource_request_info.h"
 #include "googleurl/src/url_util.h"
 #include "grit/component_extension_resources_map.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_context.h"

[erikwright (departed), 2012/08/21 02:05:01]

why add this?

[shalev, 2012/08/22 20:34:10]

Done.

 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_file_job.h"
 #include "net/url_request/url_request_simple_job.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using content::ResourceRequestInfo;
 using extensions::Extension;
 
 namespace {
@@ skipping 17 matching lines @@
 }
 
 void ReadMimeTypeFromFile(const FilePath& filename,
                           std::string* mime_type,
                           bool* result) {
   *result = net::GetMimeTypeFromFile(filename, mime_type);
 }
 
 class URLRequestResourceBundleJob : public net::URLRequestSimpleJob {
  public:
-  URLRequestResourceBundleJob(
-      net::URLRequest* request, const FilePath& filename, int resource_id,
-      const std::string& content_security_policy, bool send_cors_header)
-      : net::URLRequestSimpleJob(request),
+  URLRequestResourceBundleJob(net::URLRequest* request,
+                              net::NetworkDelegate* network_delegate,
+                              const FilePath& filename,
+                              int resource_id,
+                              const std::string& content_security_policy,
+                              bool send_cors_header)
+      : net::URLRequestSimpleJob(request, network_delegate),
         filename_(filename),
         resource_id_(resource_id),
         weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
     response_info_.headers = BuildHttpHeaders(content_security_policy,
                                               send_cors_header);
   }
 
   // Overridden from URLRequestSimpleJob:
   virtual int GetData(std::string* mime_type,
                       std::string* charset,
@@ skipping 53 matching lines @@
   int resource_id_;
 
   net::HttpResponseInfo response_info_;
 
   mutable base::WeakPtrFactory<URLRequestResourceBundleJob> weak_factory_;
 };
 
 class GeneratedBackgroundPageJob : public net::URLRequestSimpleJob {
  public:
   GeneratedBackgroundPageJob(net::URLRequest* request,
+                             net::NetworkDelegate* network_delegate,
                              const scoped_refptr<const Extension> extension,
                              const std::string& content_security_policy)
-      : net::URLRequestSimpleJob(request),
+      : net::URLRequestSimpleJob(request, network_delegate),
         extension_(extension) {
     const bool send_cors_headers = false;
     response_info_.headers = BuildHttpHeaders(content_security_policy,
                                               send_cors_headers);
   }
 
   // Overridden from URLRequestSimpleJob:
   virtual int GetData(std::string* mime_type,
                       std::string* charset,
                       std::string* data,
@@ skipping 23 matching lines @@
 };
 
 void ReadResourceFilePath(const ExtensionResource& resource,
                           FilePath* file_path) {
   *file_path = resource.GetFilePath();
 }
 
 class URLRequestExtensionJob : public net::URLRequestFileJob {
  public:
   URLRequestExtensionJob(net::URLRequest* request,
+                         net::NetworkDelegate* network_delegate,
                          const std::string& extension_id,
                          const FilePath& directory_path,
                          const std::string& content_security_policy,
                          bool send_cors_header)
-    : net::URLRequestFileJob(request, FilePath()),
+    : net::URLRequestFileJob(request, network_delegate, FilePath()),
       // TODO(tc): Move all of these files into resources.pak so we don't break
       // when updating on Linux.
       resource_(extension_id, directory_path,
                 extension_file_util::ExtensionURLToRelativeFilePath(
                     request->url())),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
       response_info_.headers = BuildHttpHeaders(content_security_policy,
                                                 send_cors_header);
   }
 
@@ skipping 87 matching lines @@
     : public net::URLRequestJobFactory::ProtocolHandler {
  public:
   ExtensionProtocolHandler(bool is_incognito,
                            ExtensionInfoMap* extension_info_map)
       : is_incognito_(is_incognito),
         extension_info_map_(extension_info_map) {}
 
   virtual ~ExtensionProtocolHandler() {}
 
   virtual net::URLRequestJob* MaybeCreateJob(
-      net::URLRequest* request) const OVERRIDE;
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const OVERRIDE;
 
  private:
   const bool is_incognito_;
   ExtensionInfoMap* const extension_info_map_;
   DISALLOW_COPY_AND_ASSIGN(ExtensionProtocolHandler);
 };
 
 // Creates URLRequestJobs for extension:// URLs.
 net::URLRequestJob*
-ExtensionProtocolHandler::MaybeCreateJob(net::URLRequest* request) const {
+ExtensionProtocolHandler::MaybeCreateJob(
+    net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
   // TODO(mpcomplete): better error code.
   if (!AllowExtensionResourceLoad(
            request, is_incognito_, extension_info_map_)) {
-    return new net::URLRequestErrorJob(request, net::ERR_ADDRESS_UNREACHABLE);
+    return new net::URLRequestErrorJob(
+        request, network_delegate, net::ERR_ADDRESS_UNREACHABLE);
   }
 
   // chrome-extension://extension-id/resource/path.js
   const std::string& extension_id = request->url().host();
   const Extension* extension =
       extension_info_map_->extensions().GetByID(extension_id);
   FilePath directory_path;
   if (extension)
     directory_path = extension->path();
   if (directory_path.value().empty()) {
@@ skipping 16 matching lines @@
     if ((extension->manifest_version() >= 2 ||
              extension->HasWebAccessibleResources()) &&
         extension->IsResourceWebAccessible(resource_path))
       send_cors_header = true;
   }
 
   std::string path = request->url().path();
   if (path.size() > 1 &&
       path.substr(1) == extension_filenames::kGeneratedBackgroundPageFilename) {
     return new GeneratedBackgroundPageJob(
-        request, extension, content_security_policy);
+        request, network_delegate, extension, content_security_policy);
   }
 
   FilePath resources_path;
   FilePath relative_path;
   // Try to load extension resources from chrome resource file if
   // directory_path is a descendant of resources_path. resources_path
   // corresponds to src/chrome/browser/resources in source tree.
   if (PathService::Get(chrome::DIR_RESOURCES, &resources_path) &&
       // Since component extension resources are included in
       // component_extension_resources.pak file in resources_path, calculate
       // extension relative path against resources_path.
       resources_path.AppendRelativePath(directory_path, &relative_path)) {
     relative_path = relative_path.Append(
         extension_file_util::ExtensionURLToRelativeFilePath(request->url()));
     relative_path = relative_path.NormalizePathSeparators();
 
     // TODO(tc): Make a map of FilePath -> resource ids so we don't have to
     // covert to FilePaths all the time.  This will be more useful as we add
     // more resources.
     for (size_t i = 0; i < kComponentExtensionResourcesSize; ++i) {
       FilePath bm_resource_path =
           FilePath().AppendASCII(kComponentExtensionResources[i].name);
       bm_resource_path = bm_resource_path.NormalizePathSeparators();
       if (relative_path == bm_resource_path) {
-        return new URLRequestResourceBundleJob(request, relative_path,
-            kComponentExtensionResources[i].value, content_security_policy,
+        return new URLRequestResourceBundleJob(
+            request,
+            network_delegate,
+            relative_path,
+            kComponentExtensionResources[i].value,
+            content_security_policy,
             send_cors_header);
       }
     }
   }
 
-  return new URLRequestExtensionJob(request, extension_id, directory_path,
-                                    content_security_policy, send_cors_header);
+  return new URLRequestExtensionJob(request,
+                                    network_delegate,
+                                    extension_id,
+                                    directory_path,
+                                    content_security_policy,
+                                    send_cors_header);
 }
 
 }  // namespace
 
 net::URLRequestJobFactory::ProtocolHandler* CreateExtensionProtocolHandler(
     bool is_incognito,
     ExtensionInfoMap* extension_info_map) {
   return new ExtensionProtocolHandler(is_incognito, extension_info_map);
 }