Remove the Path class from dart:io

pkg/http_server/lib/src/virtual_directory.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of http_server;
 
 /**
  * A [VirtualDirectory] can serve files and directory-listing from a root path,
  * to [HttpRequest]s.
  *
@@ skipping 59 matching lines @@
   Function _errorCallback;
   Function _dirCallback;
 
   _VirtualDirectory(this.root);
 
   void serve(Stream<HttpRequest> requests) {
     requests.listen(serveRequest);
   }
 
   void serveRequest(HttpRequest request) {
-    _locateResource(new Path('.'), request.uri.pathSegments.iterator..moveNext())
+    _locateResource('.', request.uri.pathSegments.iterator..moveNext())
         .then((entity) {
           if (entity == null) {
             _serveErrorPage(HttpStatus.NOT_FOUND, request);
             return;
           }
           if (entity is File) {
             _serveFile(entity, request);
           } else if (entity is Directory) {
             _serveDirectory(entity, request);
           } else {
             _serveErrorPage(HttpStatus.NOT_FOUND, request);
           }
         });
   }
 
   void setDirectoryHandler(void callback(Directory dir, HttpRequest request)) {
     _dirCallback = callback;
   }
 
   void setErrorPageHandler(void callback(HttpRequest request)) {
     _errorCallback = callback;
   }
 
-  Future<FileSystemEntity> _locateResource(Path path,
+  Future<FileSystemEntity> _locateResource(String path,
                                            Iterator<String> segments) {
-    path = path.canonicalize();
-    if (path.segments().first == "..") return new Future.value(null);
-    Path fullPath() => new Path(root).join(path);
-    return FileSystemEntity.type(fullPath().toNativePath(), followLinks: false)
+    path = normalize(path);
+    if (split(path).first == "..") return new Future.value(null);
+    String fullPath() => join(root, path);
+    return FileSystemEntity.type(fullPath(), followLinks: false)
         .then((type) {
           switch (type) {
             case FileSystemEntityType.FILE:
               if (segments.current == null) {
-                return new File.fromPath(fullPath());
+                return new File(fullPath());
               }
               break;
 
             case FileSystemEntityType.DIRECTORY:
               if (segments.current == null) {
                 if (allowDirectoryListing) {
-                  return new Directory.fromPath(fullPath());
+                  return new Directory(fullPath());
                 }
               } else {
                 if (_invalidPathRegExp.hasMatch(segments.current)) break;
-                return _locateResource(path.append(segments.current),
+                return _locateResource(join(path, segments.current),
                                        segments..moveNext());
               }
               break;
 
             case FileSystemEntityType.LINK:
               if (followLinks) {
-                return new Link.fromPath(fullPath()).target()
+                return new Link(fullPath()).target()
                     .then((target) {
-                      var targetPath = new Path(target).canonicalize();
-                      if (targetPath.isAbsolute) return null;
-                      targetPath = path.directoryPath.join(targetPath);
+                      String targetPath = normalize(target);
+                      if (isAbsolute(targetPath)) return null;
+                      targetPath = join(dirname(path), targetPath);
                       return _locateResource(targetPath, segments);
                     });
               }
               break;
           }
           // Return `null` on fall-through, to indicate NOT_FOUND.
           return null;
         });
   }
 
@@ skipping 100 matching lines @@
 $server
 </body>
 </html>
 ''';
 
       response.write(header);
 
       void add(String name, String modified, var size) {
         if (size == null) size = "-";
         if (modified == null) modified = "";
-        var p = new Path(path).append(name).canonicalize().toString();
+        var p = normalize(join(path, name));
         var entry =
 '''  <tr>
     <td><a href="$p">$name</a></td>
     <td>$modified</td>
     <td style="text-align: right">$size</td>
   </tr>''';
         response.write(entry);
       }
 
       if (path != '/') {
         add('../', null, null);
       }
 
       dir.list(followLinks: true).listen((entity) {
         // TODO(ajohnsen): Consider async dir listing.
         if (entity is File) {
           var stat = entity.statSync();
-          add(new Path(entity.path).filename,
+          add(basename(entity.path),
               stat.modified.toString(),
               stat.size);
         } else if (entity is Directory) {
-          add(new Path(entity.path).filename + '/',
+          add(basename(entity.path) + '/',
               entity.statSync().modified.toString(),
               null);
         }
       }, onError: (e) {
       }, onDone: () {
         response.write(footer);
         response.close();
       });
     }, onError: (e) => response.close());
   }
@@ skipping 76 matching lines @@
 
   Future close() => new Future.value();
 
   void setMimeType(var bytes) {
     var mimeType = lookupMimeType(path, headerBytes: bytes);
     if (mimeType != null) {
       response.headers.contentType = ContentType.parse(mimeType);
     }
   }
 }