Allowing following of symlinks for script resources from extensions

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/base64.h"
 #include "base/compiler_specific.h"
@@ skipping 265 matching lines @@
 }
 
 class URLRequestExtensionJob : public net::URLRequestFileJob {
  public:
   URLRequestExtensionJob(net::URLRequest* request,
                          net::NetworkDelegate* network_delegate,
                          const std::string& extension_id,
                          const base::FilePath& directory_path,
                          const base::FilePath& relative_path,
                          const std::string& content_security_policy,
-                         bool send_cors_header)
+                         bool send_cors_header,
+                         bool follow_symlinks_anywhere)
     : net::URLRequestFileJob(
           request, network_delegate, base::FilePath(),
           BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
                   base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)),
       directory_path_(directory_path),
       // TODO(tc): Move all of these files into resources.pak so we don't break
       // when updating on Linux.
       resource_(extension_id, directory_path, relative_path),
       content_security_policy_(content_security_policy),
       send_cors_header_(send_cors_header),
       weak_factory_(this) {
+    if (follow_symlinks_anywhere) {
+      resource_.set_follow_symlinks_anywhere();
+    }
   }
 
   virtual void GetResponseInfo(net::HttpResponseInfo* info) OVERRIDE {
     *info = response_info_;
   }
 
   virtual void Start() OVERRIDE {
     base::FilePath* read_file_path = new base::FilePath;
     base::Time* last_modified_time = new base::Time();
     bool posted = BrowserThread::PostBlockingPoolTaskAndReply(
@@ skipping 210 matching lines @@
     if (URLIsForExtensionIcon(request->url(), disabled_extension))
       directory_path = disabled_extension->path();
     if (directory_path.value().empty()) {
       LOG(WARNING) << "Failed to GetPathForExtension: " << extension_id;
       return NULL;
     }
   }
 
   std::string content_security_policy;
   bool send_cors_header = false;
+  bool follow_symlinks_anywhere = false;
   if (extension) {
     std::string resource_path = request->url().path();
     content_security_policy =
         extensions::CSPInfo::GetResourceContentSecurityPolicy(extension,
                                                               resource_path);
     if ((extension->manifest_version() >= 2 ||
          extensions::WebAccessibleResourcesInfo::HasWebAccessibleResources(
              extension)) &&
         extensions::WebAccessibleResourcesInfo::IsResourceWebAccessible(
             extension, resource_path))
       send_cors_header = true;
+
+    follow_symlinks_anywhere =
+        (extension->creation_flags() & Extension::FOLLOW_SYMLINKS_ANYWHERE)
+        != 0;
   }
 
   std::string path = request->url().path();
   if (path.size() > 1 &&
       path.substr(1) == extensions::kGeneratedBackgroundPageFilename) {
     return new GeneratedBackgroundPageJob(
         request, network_delegate, extension, content_security_policy);
   }
 
   base::FilePath resources_path;
@@ skipping 61 matching lines @@
       return NULL;
     }
   }
 
   return new URLRequestExtensionJob(request,
                                     network_delegate,
                                     extension_id,
                                     directory_path,
                                     relative_path,
                                     content_security_policy,
-                                    send_cors_header);
+                                    send_cors_header,
+                                    follow_symlinks_anywhere);
 }
 
 }  // namespace
 
 net::URLRequestJobFactory::ProtocolHandler* CreateExtensionProtocolHandler(
     bool is_incognito,
     extensions::InfoMap* extension_info_map) {
   return new ExtensionProtocolHandler(is_incognito, extension_info_map);
 }