[NaCl SDK] Switch ppapi_simple to C library

native_client_sdk/src/libraries/ppapi_simple/ps_event.c

+// Copyright 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.
+
+#include "ppapi_simple/ps_event.h"
+
+#include <assert.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "ppapi_simple/ps_instance.h"
+#include "ppapi_simple/ps_interface.h"
+
+#define NO_BLOCK 0
+#define BLOCK 1
+
+struct PSMessageHandlerInfo {
+  char* message_name;
+  PSMessageHandler_t func;
+  void* user_data;
+  struct PSMessageHandlerInfo* prev;
+  struct PSMessageHandlerInfo* next;
+};
+
+static uint32_t s_events_enabled = PSE_NONE;
+static struct PSEvent* s_event_head;
+static struct PSEvent* s_event_tail;
+static pthread_mutex_t s_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_cond = PTHREAD_COND_INITIALIZER;
+static struct PSMessageHandlerInfo* s_handler_head;
+static struct PSMessageHandlerInfo* s_handler_tail;
+
+static struct PSMessageHandlerInfo* FindMessageHandler(
+    const char* message_name) {
+  struct PSMessageHandlerInfo* info = s_handler_head;
+  while (info) {
+    if (strcmp(info->message_name, message_name) == 0) {
+      return info;
+    }
+
+    info = info->next;
+  }
+
+  return NULL;
+}
+
+static void EnqueueEvent(struct PSEvent* event) {
+  pthread_mutex_lock(&s_lock);
+
+  if (!s_event_tail) {
+    s_event_head = s_event_tail = event;
+    event->next = NULL;
+  } else {
+    s_event_tail->next = event;
+    s_event_tail = event;
+  }
+
+  pthread_cond_signal(&s_cond);
+  pthread_mutex_unlock(&s_lock);
+}
+
+static struct PSEvent* DequeueEvent(int block) {
+  pthread_mutex_lock(&s_lock);
+
+  if (block) {
+    while (s_event_head == NULL) {
+      pthread_cond_wait(&s_cond, &s_lock);
+    }
+  }
+
+  if (s_event_head == NULL) {
+    pthread_mutex_unlock(&s_lock);
+    return NULL;
+  }
+
+  struct PSEvent* item = s_event_head;
+
+  if (s_event_head == s_event_tail) {
+    s_event_head = s_event_tail = NULL;
+  } else {
+    s_event_head = s_event_head->next;
+  }
+
+  pthread_mutex_unlock(&s_lock);
+
+  return item;
+}
+
+struct PSEvent* PSEventTryAcquire() {
+  struct PSEvent* event;
+  while (1) {
+    event = DequeueEvent(NO_BLOCK);
+    if (NULL == event)
+      break;
+    if (s_events_enabled & event->type)
+      break;
+    /* Release filtered events & continue to acquire. */
+    PSEventRelease(event);
+  }
+  return event;
+}
+
+struct PSEvent* PSEventWaitAcquire() {
+  struct PSEvent* event;
+  while (1) {
+    event = DequeueEvent(BLOCK);
+    if (s_events_enabled & event->type)
+      break;
+    /* Release filtered events & continue to acquire. */
+    PSEventRelease(event);
+  }
+  return event;
+}
+
+void PSEventRelease(struct PSEvent* event) {
+  if (event) {
+    switch (event->type) {
+      case PSE_INSTANCE_HANDLEMESSAGE:
+        PSInterfaceVar()->Release(event->as_var);
+        break;
+      case PSE_INSTANCE_HANDLEINPUT:
+      case PSE_INSTANCE_DIDCHANGEVIEW:
+        if (event->as_resource) {
+          PSInterfaceCore()->ReleaseResource(event->as_resource);
+        }
+        break;
+      default:
+        break;
+    }
+    free(event);
+  }
+}
+
+void PSEventSetFilter(PSEventTypeMask filter) {
+  s_events_enabled = filter;
+  if (filter == 0) {
+    static int s_warn_once = 1;
+    if (s_warn_once) {
+      PSInstanceWarn(
+          "PSInstance::SetEnabledEvents(mask) where mask == 0 will block\n");
+      PSInstanceWarn(
+          "all events. This can come from PSEventSetFilter(PSE_NONE);\n");
+      s_warn_once = 0;
+    }
+  }
+}
+
+void PSEventPost(PSEventType type) {
+  assert(PSE_GRAPHICS3D_GRAPHICS3DCONTEXTLOST == type ||
+         PSE_MOUSELOCK_MOUSELOCKLOST == type);
+
+  struct PSEvent* event = malloc(sizeof(struct PSEvent));
+  memset(event, 0, sizeof(*event));
+  event->type = type;
+  EnqueueEvent(event);
+}
+
+void PSEventPostBool(PSEventType type, PP_Bool bool_value) {
+  assert(PSE_INSTANCE_DIDCHANGEFOCUS == type);
+
+  struct PSEvent* event = malloc(sizeof(struct PSEvent));
+  memset(event, 0, sizeof(*event));
+  event->type = type;
+  event->as_bool = bool_value;
+  EnqueueEvent(event);
+}
+
+void PSEventPostVar(PSEventType type, struct PP_Var var) {
+  assert(PSE_INSTANCE_HANDLEMESSAGE == type);
+
+  /* If the message is a dictionary then see if it matches one of the specific
+   * handlers, then call that handler rather than queuing an event. */
+  if (var.type == PP_VARTYPE_DICTIONARY) {
+    struct PP_Var keys_var = PSInterfaceVarDictionary()->GetKeys(var);
+    if (PSInterfaceVarArray()->GetLength(keys_var) == 1) {
+      struct PP_Var key_var = PSInterfaceVarArray()->Get(keys_var, 0);
+      uint32_t key_len;
+      const char* key_str = PSInterfaceVar()->VarToUtf8(key_var, &key_len);
+      char* key_cstr = alloca(key_len + 1);
+      memcpy(key_cstr, key_str, key_len);
+      key_cstr[key_len] = 0;
+      PSInstanceTrace("calling handler for: %s\n", key_cstr);
+
+      struct PSMessageHandlerInfo* handler_info = FindMessageHandler(key_cstr);
+      if (handler_info) {
+        struct PP_Var value_var = PSInterfaceVarDictionary()->Get(var, key_var);
+        handler_info->func(key_var, value_var, handler_info->user_data);
+        PSInterfaceVar()->Release(value_var);
+        PSInterfaceVar()->Release(key_var);
+        PSInterfaceVar()->Release(keys_var);
+        return;
+      }
+
+      PSInterfaceVar()->Release(key_var);
+    }
+
+    PSInterfaceVar()->Release(keys_var);
+  }
+
+  PSInterfaceVar()->AddRef(var);
+  struct PSEvent *env =  malloc(sizeof(struct PSEvent));
+  memset(env, 0, sizeof(*env));
+  env->type = type;
+  env->as_var = var;
+  EnqueueEvent(env);
+}
+
+void PSEventPostResource(PSEventType type, PP_Resource resource) {
+  assert(PSE_INSTANCE_HANDLEINPUT == type ||
+         PSE_INSTANCE_DIDCHANGEVIEW == type);
+
+  if (resource) {
+    PSInterfaceCore()->AddRefResource(resource);
+  }
+  struct PSEvent* event = malloc(sizeof(struct PSEvent));
+  memset(event, 0, sizeof(*event));
+  event->type = type;
+  event->as_resource = resource;
+  EnqueueEvent(event);
+}
+
+void PSEventRegisterMessageHandler(const char* message_name,
+                                   PSMessageHandler_t func,
+                                   void* user_data) {
+  PSInstanceTrace("registering msg handler: %s\n", message_name);
+  struct PSMessageHandlerInfo* handler = FindMessageHandler(message_name);
+
+  if (func == NULL) {
+    /* Unregister handler, if it exists */
+    if (handler) {
+      if (handler->prev) {
+        handler->prev->next = handler->next;
+      } else {
+        s_handler_head = handler->next;
+      }
+
+      if (handler->next) {
+        handler->next->prev = handler->prev;
+      } else {
+        s_handler_tail = handler->prev;
+      }
+
+      free(handler->message_name);
+      free(handler);
+    }
+    return;
+  }
+
+  if (handler) {
+    /* Already registered, change its function */
+    handler->func = func;
+    handler->user_data = user_data;
+  } else {
+    /* Not registered, append a new handler info */
+    struct PSMessageHandlerInfo* handler_info =
+        malloc(sizeof(struct PSMessageHandlerInfo));
+    handler_info->message_name = strdup(message_name);
+    handler_info->func = func;
+    handler_info->user_data = user_data;
+    handler_info->next = NULL;
+    handler_info->prev = s_handler_tail;
+
+    if (s_handler_tail) {
+      s_handler_tail->next = handler_info;
+      s_handler_tail = handler_info;
+    } else {
+      s_handler_head = s_handler_tail = handler_info;
+    }
+  }
+}