Merge services into a shared IOService in dart:io, and use a native port.

runtime/bin/directory.cc

 // Copyright (c) 2012, 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.
 
 #include "bin/directory.h"
 
 #include "bin/dartutils.h"
 #include "bin/thread.h"
 #include "include/dart_api.h"
 #include "platform/assert.h"
 
 
 namespace dart {
 namespace bin {
 
-// Forward declaration.
-static void DirectoryService(Dart_Port, Dart_Port, Dart_CObject*);
-
-NativeService Directory::directory_service_("DirectoryService",
-                                            DirectoryService,
-                                            16);
-
-
 void FUNCTION_NAME(Directory_Current)(Dart_NativeArguments args) {
   char* current = Directory::Current();
   if (current != NULL) {
     Dart_SetReturnValue(args, DartUtils::NewString(current));
     free(current);
   } else {
     Dart_Handle err = DartUtils::NewDartOSError();
     if (Dart_IsError(err)) Dart_PropagateError(err);
     Dart_SetReturnValue(args, err);
   }
@@ skipping 107 matching lines @@
                NULL);
   SyncDirectoryListing sync_listing(results,
                                     DartUtils::GetStringValue(path),
                                     DartUtils::GetBooleanValue(recursive),
                                     DartUtils::GetBooleanValue(follow_links));
   Directory::List(&sync_listing);
   Dart_SetReturnValue(args, results);
 }
 
 
-static CObject* DirectoryCreateRequest(const CObjectArray& request) {
-  if (request.Length() == 2 && request[1]->IsString()) {
-    CObjectString path(request[1]);
+CObject* Directory::CreateRequest(const CObjectArray& request) {
+  if (request.Length() == 1 && request[0]->IsString()) {
+    CObjectString path(request[0]);
     if (Directory::Create(path.CString())) {
       return CObject::True();
     } else {
       return CObject::NewOSError();
     }
   }
   return CObject::IllegalArgumentError();
 }
 
 
-static CObject* DirectoryDeleteRequest(const CObjectArray& request) {
-  if (request.Length() == 3 && request[1]->IsString() && request[2]->IsBool()) {
-    CObjectString path(request[1]);
-    CObjectBool recursive(request[2]);
+CObject* Directory::DeleteRequest(const CObjectArray& request) {
+  if (request.Length() == 2 && request[0]->IsString() && request[1]->IsBool()) {
+    CObjectString path(request[0]);
+    CObjectBool recursive(request[1]);
     if (Directory::Delete(path.CString(), recursive.Value())) {
       return CObject::True();
     } else {
       return CObject::NewOSError();
     }
   }
   return CObject::IllegalArgumentError();
 }
 
 
-static CObject* DirectoryExistsRequest(const CObjectArray& request) {
+CObject* Directory::ExistsRequest(const CObjectArray& request) {
   static const int kExists = 1;
   static const int kDoesNotExist = 0;
-  if (request.Length() == 2 && request[1]->IsString()) {
-    CObjectString path(request[1]);
+  if (request.Length() == 1 && request[0]->IsString()) {
+    CObjectString path(request[0]);
     Directory::ExistsResult result = Directory::Exists(path.CString());
     if (result == Directory::EXISTS) {
       return new CObjectInt32(CObject::NewInt32(kExists));
     } else if (result == Directory::DOES_NOT_EXIST) {
       return new CObjectInt32(CObject::NewInt32(kDoesNotExist));
     } else {
       return CObject::NewOSError();
     }
   }
   return CObject::IllegalArgumentError();
 }
 
 
-static CObject* DirectoryCreateTempRequest(const CObjectArray& request) {
-  if (request.Length() == 2 && request[1]->IsString()) {
-    CObjectString path(request[1]);
+CObject* Directory::CreateTempRequest(const CObjectArray& request) {
+  if (request.Length() == 1 && request[0]->IsString()) {
+    CObjectString path(request[0]);
     char* result = Directory::CreateTemp(path.CString());
     if (result != NULL) {
       CObject* temp_dir = new CObjectString(CObject::NewString(result));
       free(result);
       return temp_dir;
     } else {
       return CObject::NewOSError();
     }
   }
   return CObject::IllegalArgumentError();
 }
 
 static CObject* CreateIllegalArgumentError() {
   // Respond with an illegal argument list error message.
   CObjectArray* error = new CObjectArray(CObject::NewArray(3));
   error->SetAt(0, new CObjectInt32(
       CObject::NewInt32(AsyncDirectoryListing::kListError)));
   error->SetAt(1, CObject::Null());
   error->SetAt(2, CObject::IllegalArgumentError());
   return error;
 }
 
-static CObject* DirectoryListStartRequest(const CObjectArray& request) {
-  if (request.Length() == 4 &&
-      request[1]->IsString() &&
-      request[2]->IsBool() &&
-      request[3]->IsBool()) {
-    CObjectString path(request[1]);
-    CObjectBool recursive(request[2]);
-    CObjectBool follow_links(request[3]);
+CObject* Directory::ListStartRequest(const CObjectArray& request) {
+  if (request.Length() == 3 &&
+      request[0]->IsString() &&
+      request[1]->IsBool() &&
+      request[2]->IsBool()) {
+    CObjectString path(request[0]);
+    CObjectBool recursive(request[1]);
+    CObjectBool follow_links(request[2]);
     AsyncDirectoryListing* dir_listing =
         new AsyncDirectoryListing(path.CString(),
                                   recursive.Value(),
                                   follow_links.Value());
     if (dir_listing->error()) {
       // Report error now, so we capture the correct OSError.
       CObject* err = CObject::NewOSError();
       delete dir_listing;
       CObjectArray* error = new CObjectArray(CObject::NewArray(3));
       error->SetAt(0, new CObjectInt32(
           CObject::NewInt32(AsyncDirectoryListing::kListError)));
-      error->SetAt(1, request[1]);
+      error->SetAt(1, request[0]);
       error->SetAt(2, err);
       return error;
     }
     // TODO(ajohnsen): Consider returning the first few results.
     return new CObjectIntptr(CObject::NewIntptr(
         reinterpret_cast<intptr_t>(dir_listing)));
   }
   return CreateIllegalArgumentError();
 }
 
 
-static CObject* DirectoryListNextRequest(const CObjectArray& request) {
-  if (request.Length() == 2 &&
-      request[1]->IsIntptr()) {
-    CObjectIntptr ptr(request[1]);
+CObject* Directory::ListNextRequest(const CObjectArray& request) {
+  if (request.Length() == 1 &&
+      request[0]->IsIntptr()) {
+    CObjectIntptr ptr(request[0]);
     AsyncDirectoryListing* dir_listing =
         reinterpret_cast<AsyncDirectoryListing*>(ptr.Value());
     const int kArraySize = 128;
     CObjectArray* response = new CObjectArray(CObject::NewArray(kArraySize));
     dir_listing->SetArray(response, kArraySize);
     Directory::List(dir_listing);
     // In case the listing ended before it hit the buffer length, we need to
     // override the array length.
     response->AsApiCObject()->value.as_array.length = dir_listing->index();
     return response;
   }
   return CreateIllegalArgumentError();
 }
 
 
-static CObject* DirectoryListStopRequest(const CObjectArray& request) {
-  if (request.Length() == 2 && request[1]->IsIntptr()) {
-    CObjectIntptr ptr(request[1]);
+CObject* Directory::ListStopRequest(const CObjectArray& request) {
+  if (request.Length() == 1 && request[0]->IsIntptr()) {
+    CObjectIntptr ptr(request[0]);
     AsyncDirectoryListing* dir_listing =
         reinterpret_cast<AsyncDirectoryListing*>(ptr.Value());
     delete dir_listing;
     return new CObjectBool(CObject::Bool(true));
   }
   return CreateIllegalArgumentError();
 }
 
 
-static CObject* DirectoryRenameRequest(const CObjectArray& request,
-                                       Dart_Port response_port) {
-  if (request.Length() == 3 &&
-      request[1]->IsString() &&
-      request[2]->IsString()) {
-    CObjectString path(request[1]);
-    CObjectString new_path(request[2]);
+CObject* Directory::RenameRequest(const CObjectArray& request) {
+  if (request.Length() == 2 &&
+      request[0]->IsString() &&
+      request[1]->IsString()) {
+    CObjectString path(request[0]);
+    CObjectString new_path(request[1]);
     bool completed = Directory::Rename(path.CString(), new_path.CString());
     if (completed) return CObject::True();
     return CObject::NewOSError();
   }
   return CObject::IllegalArgumentError();
 }
 
 
-static void DirectoryService(Dart_Port dest_port_id,
-                             Dart_Port reply_port_id,
-                             Dart_CObject* message) {
-  CObject* response = CObject::IllegalArgumentError();
-  CObjectArray request(message);
-  if (message->type == Dart_CObject_kArray) {
-    if (request.Length() > 1 && request[0]->IsInt32()) {
-      CObjectInt32 requestType(request[0]);
-      switch (requestType.Value()) {
-        case Directory::kCreateRequest:
-          response = DirectoryCreateRequest(request);
-          break;
-        case Directory::kDeleteRequest:
-          response = DirectoryDeleteRequest(request);
-          break;
-        case Directory::kExistsRequest:
-          response = DirectoryExistsRequest(request);
-          break;
-        case Directory::kCreateTempRequest:
-          response = DirectoryCreateTempRequest(request);
-          break;
-        case Directory::kListStartRequest:
-          response = DirectoryListStartRequest(request);
-          break;
-        case Directory::kListNextRequest:
-          response = DirectoryListNextRequest(request);
-          break;
-        case Directory::kListStopRequest:
-          response = DirectoryListStopRequest(request);
-          break;
-        case Directory::kRenameRequest:
-          response = DirectoryRenameRequest(request, reply_port_id);
-          break;
-        default:
-          UNREACHABLE();
-      }
-    }
-  }
-
-  Dart_PostCObject(reply_port_id, response->AsApiCObject());
-}
-
-
-Dart_Port Directory::GetServicePort() {
-  return directory_service_.GetServicePort();
-}
-
-
-void FUNCTION_NAME(Directory_NewServicePort)(Dart_NativeArguments args) {
-  Dart_SetReturnValue(args, Dart_Null());
-  Dart_Port service_port = Directory::GetServicePort();
-  if (service_port != ILLEGAL_PORT) {
-    // Return a send port for the service port.
-    Dart_Handle send_port = Dart_NewSendPort(service_port);
-    Dart_SetReturnValue(args, send_port);
-  }
-}
-
-
 bool AsyncDirectoryListing::AddFileSystemEntityToResponse(Response type,
                                                           char* arg) {
   array_->SetAt(index_++, new CObjectInt32(CObject::NewInt32(type)));
   if (arg != NULL) {
     array_->SetAt(index_++, new CObjectString(CObject::NewString(arg)));
   } else {
     array_->SetAt(index_++, CObject::Null());
   }
   return index_ < length_;
 }
@@ skipping 104 matching lines @@
   if (listing->error()) {
     listing->HandleError("Invalid path");
     listing->HandleDone();
   } else {
     while (ListNext(listing)) {}
   }
 }
 
 }  // namespace bin
 }  // namespace dart