DevFS initial implementation

runtime/vm/service.cc

 // 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.
 
 #include "vm/service.h"
 
 #include "include/dart_api.h"
 #include "include/dart_native_api.h"
 #include "platform/globals.h"
 
 #include "vm/compiler.h"
 #include "vm/cpu.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
+#include "vm/dev_fs.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
 #include "vm/message.h"
 #include "vm/message_handler.h"
 #include "vm/native_entry.h"
 #include "vm/native_arguments.h"
 #include "vm/native_symbol.h"
 #include "vm/object.h"
 #include "vm/object_graph.h"
 #include "vm/object_id_ring.h"
@@ skipping 379 matching lines @@
   MethodParameter(const char* name, bool required)
       : name_(name), required_(required) {
   }
 
   virtual ~MethodParameter() { }
 
   virtual bool Validate(const char* value) const {
     return true;
   }
 
+  virtual bool ValidateObject(const Object& value) const {
+    return true;
+  }
+
   const char* name() const {
     return name_;
   }
 
   bool required() const {
     return required_;
   }
 
   virtual void PrintError(const char* name,
                           const char* value,
                           JSONStream* js) const {
     PrintInvalidParamError(js, name);
   }
 
+  virtual void PrintErrorObject(const char* name,
+                                const Object& value,
+                                JSONStream* js) const {
+    PrintInvalidParamError(js, name);
+  }
+
  private:
   const char* name_;
   bool required_;
 };
 
 
+class DartStringParameter : public MethodParameter {
+ public:
+  DartStringParameter(const char* name, bool required)
+      : MethodParameter(name, required) {
+  }
+
+  virtual bool ValidateObject(const Object& value) const {
+    return value.IsString();
+  }
+};
+
+
+class DartListParameter : public MethodParameter {
+ public:
+  DartListParameter(const char* name, bool required)
+      : MethodParameter(name, required) {
+  }
+
+  virtual bool ValidateObject(const Object& value) const {
+    return value.IsArray() || value.IsGrowableObjectArray();
+  }
+};
+
+
 class NoSuchParameter : public MethodParameter {
  public:
   explicit NoSuchParameter(const char* name)
     : MethodParameter(name, false) {
   }
 
   virtual bool Validate(const char* value) const {
     return (value == NULL);
   }
+
+  virtual bool ValidateObject(const Object& value) const {
+    return value.IsNull();
+  }
 };
 
 
 class BoolParameter : public MethodParameter {
  public:
   BoolParameter(const char* name, bool required)
       : MethodParameter(name, required) {
   }
 
   virtual bool Validate(const char* value) const {
@@ skipping 275 matching lines @@
   const MethodParameter* const * parameters;
 };
 
 
 // TODO(johnmccutchan): Do we reject unexpected parameters?
 static bool ValidateParameters(const MethodParameter* const* parameters,
                               JSONStream* js) {
   if (parameters == NULL) {
     return true;
   }
-  for (intptr_t i = 0; parameters[i] != NULL; i++) {
-    const MethodParameter* parameter = parameters[i];
-    const char* name = parameter->name();
-    const bool required = parameter->required();
-    const char* value = js->LookupParam(name);
-    const bool has_parameter = (value != NULL);
-    if (required && !has_parameter) {
-      PrintMissingParamError(js, name);
-      return false;
+  if (js->NumObjectParameters() > 0) {
+    Object& value = Object::Handle();
+    for (intptr_t i = 0; parameters[i] != NULL; i++) {
+      const MethodParameter* parameter = parameters[i];
+      const char* name = parameter->name();
+      const bool required = parameter->required();
+      value = js->LookupObjectParam(name);
+      const bool has_parameter = !value.IsNull();
+      if (required && !has_parameter) {
+        PrintMissingParamError(js, name);
+        return false;
+      }
+      if (has_parameter && !parameter->ValidateObject(value)) {
+        parameter->PrintErrorObject(name, value, js);
+        return false;
+      }
     }
-    if (has_parameter && !parameter->Validate(value)) {
-      parameter->PrintError(name, value, js);
-      return false;
+  } else {
+    for (intptr_t i = 0; parameters[i] != NULL; i++) {
+      const MethodParameter* parameter = parameters[i];
+      const char* name = parameter->name();
+      const bool required = parameter->required();
+      const char* value = js->LookupParam(name);
+      const bool has_parameter = (value != NULL);
+      if (required && !has_parameter) {
+        PrintMissingParamError(js, name);
+        return false;
+      }
+      if (has_parameter && !parameter->Validate(value)) {
+        parameter->PrintError(name, value, js);
+        return false;
+      }
     }
   }
   return true;
 }
 
 
 void Service::PostError(const String& method_name,
                         const Array& parameter_keys,
                         const Array& parameter_values,
                         const Instance& reply_port,
                         const Instance& id,
                         const Error& error) {
   Thread* T = Thread::Current();
   StackZone zone(T);
   HANDLESCOPE(T);
   JSONStream js;
   js.Setup(zone.GetZone(), SendPort::Cast(reply_port).Id(),
            id, method_name, parameter_keys, parameter_values);
   js.PrintError(kExtensionError,
                 "Error in extension `%s`: %s",
                 js.method(), error.ToErrorCString());
   js.PostReply();
 }
 
 
-void Service::InvokeMethod(Isolate* I, const Array& msg) {
+void Service::InvokeMethod(Isolate* I,
+                           const Array& msg,
+                           bool parameters_are_dart_objects) {
   Thread* T = Thread::Current();
   ASSERT(I == T->isolate());
   ASSERT(I != NULL);
   ASSERT(!msg.IsNull());
   ASSERT(msg.Length() == 6);
 
   {
     StackZone zone(T);
     HANDLESCOPE(T);
 
@@ skipping 13 matching lines @@
     ASSERT(!param_keys.IsNull());
     ASSERT(!param_values.IsNull());
     ASSERT(param_keys.Length() == param_values.Length());
 
     if (!reply_port.IsSendPort()) {
       FATAL("SendPort expected.");
     }
 
     JSONStream js;
     js.Setup(zone.GetZone(), SendPort::Cast(reply_port).Id(),
-             seq, method_name, param_keys, param_values);
+             seq,
+             method_name,
+             param_keys,
+             param_values,
+             parameters_are_dart_objects);
 
     // RPC came in with a custom service id zone.
     const char* id_zone_param = js.LookupParam("_idZone");
 
     if (id_zone_param != NULL) {
       // Override id zone.
       if (strcmp("default", id_zone_param) == 0) {
         // Ring with eager id allocation. This is the default ring and default
         // policy.
         // Nothing to do.
@@ skipping 59 matching lines @@
   }
 }
 
 
 void Service::HandleRootMessage(const Array& msg_instance) {
   Isolate* isolate = Isolate::Current();
   InvokeMethod(isolate, msg_instance);
 }
 
 
+void Service::HandleObjectRootMessage(const Array& msg_instance) {
+  Isolate* isolate = Isolate::Current();
+  InvokeMethod(isolate, msg_instance, true);
+}
+
+
 void Service::HandleIsolateMessage(Isolate* isolate, const Array& msg) {
   ASSERT(isolate != NULL);
   InvokeMethod(isolate, msg);
 }
 
 
 void Service::SendEvent(const char* stream_id,
                         const char* event_type,
                         const Object& event_message) {
   Thread* thread = Thread::Current();
@@ skipping 2974 matching lines @@
   if (Service::isolate_stream.enabled()) {
     ServiceEvent event(isolate, ServiceEvent::kIsolateUpdate);
     Service::HandleEvent(&event);
   }
   PrintSuccess(js);
   return true;
 }
 
 
 static const MethodParameter* set_vm_name_params[] = {
+  NO_ISOLATE_PARAMETER,
   new MethodParameter("name", true),
   NULL,
 };
 
 
 static bool SetVMName(Thread* thread, JSONStream* js) {
   const char* name_param = js->LookupParam("name");
   free(vm_name);
   vm_name = strdup(name_param);
   if (Service::vm_stream.enabled()) {
@@ skipping 29 matching lines @@
     return true;
   }
   const Class& cls = Class::Handle(GetClassForId(isolate, cid));
   ASSERT(!cls.IsNull());
   cls.SetTraceAllocation(enable);
   PrintSuccess(js);
   return true;
 }
 
 
+static const MethodParameter* create_dev_fs_params[] = {
+  NO_ISOLATE_PARAMETER,
+  new DartStringParameter("fsName", true),
+  NULL,
+};
+
+
+static bool CreateDevFS(Thread* thread, JSONStream* js) {
+  const String& fs_name =
+      String::Handle(String::RawCast(js->LookupObjectParam("fsName")));
+  DevFS::CreateFileSystem(js, fs_name);
+  return true;
+}
+
+
+static const MethodParameter* delete_dev_fs_params[] = {
+  NO_ISOLATE_PARAMETER,
+  new DartStringParameter("fsName", true),
+  NULL,
+};
+
+
+static bool DeleteDevFS(Thread* thread, JSONStream* js) {
+  const String& fs_name =
+      String::Handle(String::RawCast(js->LookupObjectParam("fsName")));
+  DevFS::DeleteFileSystem(js, fs_name);
+  return true;
+}
+
+
+static const MethodParameter* list_dev_fs_params[] = {
+  NO_ISOLATE_PARAMETER,
+  NULL,
+};
+
+
+static bool ListDevFS(Thread* thread, JSONStream* js) {
+  DevFS::ListFileSystems(js);
+  return true;
+}
+
+
+static const MethodParameter* write_dev_fs_file_params[] = {
+  NO_ISOLATE_PARAMETER,
+  new DartStringParameter("fsName", true),
+  new DartStringParameter("path", true),
+  new DartStringParameter("fileContents", true),
+  NULL,
+};
+
+
+static bool WriteDevFSFile(Thread* thread, JSONStream* js) {
+  const String& fs_name =
+      String::Handle(String::RawCast(js->LookupObjectParam("fsName")));
+  const String& path =
+      String::Handle(String::RawCast(js->LookupObjectParam("path")));
+  const String& file_contents =
+      String::Handle(String::RawCast(js->LookupObjectParam("fileContents")));
+  DevFS::WriteFile(js, fs_name, path, file_contents);
+  return true;
+}
+
+
+static const MethodParameter* write_dev_fs_files_params[] = {
+  NO_ISOLATE_PARAMETER,
+  new DartStringParameter("fsName", true),
+  new DartListParameter("files", true),
+  NULL,
+};
+
+
+static bool WriteDevFSFiles(Thread* thread, JSONStream* js) {
+  const String& fs_name =
+      String::Handle(String::RawCast(js->LookupObjectParam("fsName")));
+  Array& files = Array::Handle();
+  const Object& files_param = Object::Handle(js->LookupObjectParam("files"));
+  if (files_param.IsArray()) {
+    files ^= files_param.raw();
+  } else {
+    ASSERT(files_param.IsGrowableObjectArray());
+    files ^= GrowableObjectArray::Cast(files_param).data();
+  }
+  ASSERT(!files.IsNull());
+  DevFS::WriteFiles(js, fs_name, files);
+  return true;
+}
+
+
+static const MethodParameter* read_dev_fs_file_params[] = {
+  NO_ISOLATE_PARAMETER,
+  new DartStringParameter("fsName", true),
+  new DartStringParameter("path", true),
+  NULL,
+};
+
+
+static bool ReadDevFSFile(Thread* thread, JSONStream* js) {
+  const String& fs_name =
+      String::Handle(String::RawCast(js->LookupObjectParam("fsName")));
+  const String& path =
+      String::Handle(String::RawCast(js->LookupObjectParam("path")));
+  DevFS::ReadFile(js, fs_name, path);
+  return true;
+}
+
+
+static const MethodParameter* list_dev_fs_files_params[] = {
+  NO_ISOLATE_PARAMETER,
+  new DartStringParameter("fsName", true),
+  NULL,
+};
+
+
+static bool ListDevFSFiles(Thread* thread, JSONStream* js) {
+  const String& fs_name =
+      String::Handle(String::RawCast(js->LookupObjectParam("fsName")));
+  DevFS::ListFiles(js, fs_name);
+  return true;
+}
+
+
 static const ServiceMethodDescriptor service_methods_[] = {
   { "_dumpIdZone", DumpIdZone, NULL },
   { "_echo", Echo,
     NULL },
   { "_respondWithMalformedJson", RespondWithMalformedJson,
     NULL },
   { "_respondWithMalformedObject", RespondWithMalformedObject,
     NULL },
   { "_triggerEchoEvent", TriggerEchoEvent,
     NULL },
@@ skipping 92 matching lines @@
   { "setLibraryDebuggable", SetLibraryDebuggable,
     set_library_debuggable_params },
   { "setName", SetName,
     set_name_params },
   { "_setTraceClassAllocation", SetTraceClassAllocation,
     set_trace_class_allocation_params },
   { "setVMName", SetVMName,
     set_vm_name_params },
   { "_setVMTimelineFlags", SetVMTimelineFlags,
     set_vm_timeline_flags_params },
+  { "_createDevFS", CreateDevFS,
+    create_dev_fs_params },
+  { "_deleteDevFS", DeleteDevFS,
+    delete_dev_fs_params },
+  { "_listDevFS", ListDevFS,
+    list_dev_fs_params },
+  { "_writeDevFSFile", WriteDevFSFile,
+    write_dev_fs_file_params },
+  { "_writeDevFSFiles", WriteDevFSFiles,
+    write_dev_fs_files_params },
+  { "_readDevFSFile", ReadDevFSFile,
+    read_dev_fs_file_params },
+  { "_listDevFSFiles", ListDevFSFiles,
+    list_dev_fs_files_params },
 };
 
 
 const ServiceMethodDescriptor* FindMethod(const char* method_name) {
   intptr_t num_methods = sizeof(service_methods_) /
                          sizeof(service_methods_[0]);
   for (intptr_t i = 0; i < num_methods; i++) {
     const ServiceMethodDescriptor& method = service_methods_[i];
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart