add file:// handling to mac and linux builds

net/url_request/url_request_file_job.cc

 // Copyright (c) 2006-2008 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.
 
 // For loading files, we make use of overlapped i/o to ensure that reading from
 // the filesystem (e.g., a network filesystem) does not block the calling
 // thread.  An alternative approach would be to use a background thread or pool
 // of threads, but it seems better to leverage the operating system's ability
 // to do background file reads for us.
 //
@@ skipping 10 matching lines @@
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/worker_pool.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/url_request/url_request.h"
+#if defined(OS_WIN)
 #include "net/url_request/url_request_file_dir_job.h"
+#endif
 
 #if defined(OS_WIN)
 class URLRequestFileJob::AsyncResolver :
     public base::RefCountedThreadSafe<URLRequestFileJob::AsyncResolver> {
  public:
   explicit AsyncResolver(URLRequestFileJob* owner)
       : owner_(owner), owner_loop_(MessageLoop::current()) {
   }
 
   void Resolve(const std::wstring& file_path) {
@@ skipping 25 matching lines @@
   MessageLoop* owner_loop_;
 };
 #endif
 
 // static
 URLRequestJob* URLRequestFileJob::Factory(
     URLRequest* request, const std::string& scheme) {
   std::wstring file_path;
   if (net::FileURLToFilePath(request->url(), &file_path)) {
     if (file_path[file_path.size() - 1] == file_util::kPathSeparator) {
+#if defined(OS_WIN)
       // Only directories have trailing slashes.
       return new URLRequestFileDirJob(request, file_path);
+#endif
     }
   }
 
   // Use a regular file request job for all non-directories (including invalid
   // file names).
   URLRequestFileJob* job = new URLRequestFileJob(request);
   job->file_path_ = file_path;
   return job;
 }
 
 URLRequestFileJob::URLRequestFileJob(URLRequest* request)
     : URLRequestJob(request),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           io_callback_(this, &URLRequestFileJob::DidRead)),
       is_directory_(false) {
 }
 
 URLRequestFileJob::~URLRequestFileJob() {
 #if defined(OS_WIN)
   DCHECK(!async_resolver_);
 #endif
 }
 
 void URLRequestFileJob::Start() {
+#if defined(OS_WIN)
   // Resolve UNC paths on a background thread.
   if (!file_path_.compare(0, 2, L"\\\\")) {
     DCHECK(!async_resolver_);
     async_resolver_ = new AsyncResolver(this);
     WorkerPool::PostTask(FROM_HERE, NewRunnableMethod(
         async_resolver_.get(), &AsyncResolver::Resolve, file_path_), true);
-  } else {
-    file_util::FileInfo file_info;
-    bool exists = file_util::GetFileInfo(file_path_, &file_info);
+    return;
+  }
+#endif
+  file_util::FileInfo file_info;
+  bool exists = file_util::GetFileInfo(file_path_, &file_info);
 
-    // Continue asynchronously.
-    MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &URLRequestFileJob::DidResolve, exists, file_info));
-  }
+  // Continue asynchronously.
+  MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
+      this, &URLRequestFileJob::DidResolve, exists, file_info));
 }
 
 void URLRequestFileJob::Kill() {
   stream_.Close();
 
 #if defined(OS_WIN)
   if (async_resolver_) {
     async_resolver_->Cancel();
     async_resolver_ = NULL;
   }
@@ skipping 100 matching lines @@
     return false;
 
   *location = net::FilePathToFileURL(new_path);
   *http_status_code = 301;
   return true;
 #else
   return false;
 #endif
 }