[NaCl SDK] nacl_io: Add initial implementations of kill and signal

native_client_sdk/src/libraries/ppapi_simple/ps_instance.h

 // Copyright (c) 2013 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.
 
 #ifndef PPAPI_SIMPLE_PS_INSTANCE_H_
 #define PPAPI_SIMPLE_PS_INSTANCE_H_
 
 #include <stdarg.h>
 
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_stdint.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/c/ppb_view.h"
 
 #include "ppapi/cpp/fullscreen.h"
 #include "ppapi/cpp/graphics_3d_client.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/message_loop.h"
 #include "ppapi/cpp/mouse_lock.h"
 
 #include "ppapi/utility/completion_callback_factory.h"
 
 #include "ppapi_simple/ps_event.h"
 #include "ppapi_simple/ps_main.h"
 
 #include "sdk_util/thread_safe_queue.h"
 
+typedef void (*MessageHandler_t)(const pp::Var& key,

[binji, 2013/08/22 18:09:36]

ps_main.h defines PsMainFunc_t for a function typedef, maybe call this
MessageHandlerFunc_t for consistency?

[Sam Clegg, 2013/08/22 19:52:25]

I think the handler part implied its a function... but will
change it if you like.

+                                 const pp::Var& value,
+                                 void* user_data);
+
+struct MessageHandler {
+  MessageHandler_t handler;
+  void* user_data;
+};
 
 // The basic instance class which also inherits the MouseLock and
 // Graphics3DClient interfaces.
 class PSInstance : public pp::Instance, pp::MouseLock, pp::Graphics3DClient {
  public:
   // Verbosity levels, ecplicitly numbered since we pass these
   // in from html attributes as numberic values.
   enum Verbosity {
     PSV_SILENT = 0,
     PSV_ERROR = 1,
@@ skipping 27 matching lines @@
   void SetEnabledEvents(uint32_t mask);
   void PostEvent(PSEventType type);
   void PostEvent(PSEventType type, PP_Bool bool_value);
   void PostEvent(PSEventType type, PP_Resource resource);
   void PostEvent(PSEventType type, const PP_Var& var);
 
   PSEvent* TryAcquireEvent();
   PSEvent* WaitAcquireEvent();
   void ReleaseEvent(PSEvent* event);
 
+  // Register a message handler for messages that are arrive

[binji, 2013/08/22 18:09:36]

Register a message handler for messages that arrive from JavaScript with a given
name.

[Sam Clegg, 2013/08/22 19:52:25]

Done.

+  // with a give names.  Messages of the form:
+  //  'name' { <var> }

[binji, 2013/08/22 18:09:36]

{message_name: value}

[Sam Clegg, 2013/08/22 19:52:25]

Done.

+  // will then not generate events but instead cause the
+  // handler to be called upon message arrival.
+  // If handler is NULL then the current handler will be
+  // removed.

[binji, 2013/08/22 18:09:36]

Probably worthwhile to have an example:

JavaScript:
  nacl_module.postMessage({'foo': 123});

C++:
  instance_->RegisterMessageHandler("foo", &MyMessageHandler, NULL);
  ...

  void MyMessageHandler(const pp::Var& key, const pp::Var& value, void*
user_data) {
    assert(key.is_string());
    assert(key.AsString() == "foo");
    assert(value.is_int());
    assert(value.AsInt() == 123);
  }

[binji, 2013/08/22 20:10:55]

WDYT? This would make the connection a lot clearer for me, personally.

[Sam Clegg, 2013/08/22 20:19:03]

Done.

+  void RegisterMessageHandler(std::string message_name,
+                              MessageHandler_t handler,
+                              void* user_data);
+
  protected:
   // Callback functions triggered by Pepper
   //
   // These functions are called on the main pepper thread, so they must
   // not block.
   //
   // Called by the browser when the NaCl module is loaded and all ready to go.
   // This function will create a new thread which will run the pseudo main.
   virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]);
 
@@ skipping 20 matching lines @@
 
   // Called by the browser when the mouselock is lost.
   virtual void MouseLockLost();
 
   // Called by Init to processes default and embed tag arguments prior to
   // launching the 'ppapi_main' thread.
   virtual bool ProcessProperties();
 
  private:
   static void* MainThreadThunk(void *start_info);
+  int TtyOutputHandler(const char* buf, int count);
+  void MessageHandlerInput(const pp::Var& message);
+  void MessageHandlerResize(const pp::Var& message);
+
+  static int TtyOutputHandlerStatic(const char* buf, int count);
+  static void MessageHandlerResizeStatic(const pp::Var& key,
+                                         const pp::Var& value,
+                                         void* user_data);
+  static void MessageHandlerInputStatic(const pp::Var& key,
+                                        const pp::Var& value,
+                                        void* user_data);
 
  protected:
   pp::MessageLoop* main_loop_;
 
   sdk_util::ThreadSafeQueue<PSEvent> event_queue_;
   uint32_t events_enabled_;
   Verbosity verbosity_;
-  int fd_tty_;
+
+  // TTY handling
+  int tty_fd_;
+  const char* tty_prefix_;
+  const char* tty_resize_;
+  std::map<std::string, MessageHandler> message_handlers_;
 
   PSMainFunc_t main_cb_;
 
   const PPB_Core* ppb_core_;
   const PPB_Var* ppb_var_;
   const PPB_View* ppb_view_;
 };
 
 #endif  // PPAPI_MAIN_PS_INSTANCE_H_