1/* Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 * Use of this source code is governed by a BSD-style license that can be
3 * found in the LICENSE file.
4 */
5
6#include "queue.h"
7
8#include <pthread.h>
9#include <stdlib.h>
10
11#include "ppapi/c/pp_var.h"
12
13#define MAX_QUEUE_SIZE 16
14
15/** A mutex that guards |g_queue|. */
16static pthread_mutex_t g_queue_mutex;
17
18/** A condition variable that is signalled when |g_queue| is not empty. */
19static pthread_cond_t g_queue_not_empty_cond;
20
21/** A circular queue of messages from JavaScript to be handled.
22 *
23 * If g_queue_start < g_queue_end:
24 *   all elements in the range [g_queue_start, g_queue_end) are valid.
25 * If g_queue_start > g_queue_end:
26 *   all elements in the ranges [0, g_queue_end) and
27 *   [g_queue_start, MAX_QUEUE_SIZE) are valid.
28 * If g_queue_start == g_queue_end, and g_queue_size > 0:
29 *   all elements in the g_queue are valid.
30 * If g_queue_start == g_queue_end, and g_queue_size == 0:
31 *   No elements are valid. */
32static struct PP_Var g_queue[MAX_QUEUE_SIZE];
33
34/** The index of the head of the queue. */
35static int g_queue_start = 0;
36
37/** The index of the tail of the queue, non-inclusive. */
38static int g_queue_end = 0;
39
40/** The size of the queue. */
41static int g_queue_size = 0;
42
43/** Return whether the queue is empty.
44 *
45 * NOTE: this function assumes g_queue_mutex lock is held.
46 * @return non-zero if the queue is empty. */
47static int IsQueueEmpty() { return g_queue_size == 0; }
48
49/** Return whether the queue is full.
50 *
51 * NOTE: this function assumes g_queue_mutex lock is held.
52 * @return non-zero if the queue is full. */
53static int IsQueueFull() { return g_queue_size == MAX_QUEUE_SIZE; }
54
55/** Initialize the message queue. */
56void InitializeMessageQueue() {
57  pthread_mutex_init(&g_queue_mutex, NULL);
58  pthread_cond_init(&g_queue_not_empty_cond, NULL);
59}
60
61/** Enqueue a message (i.e. add to the end)
62 *
63 * If the queue is full, the message will be dropped.
64 *
65 * NOTE: this function assumes g_queue_mutex is _NOT_ held.
66 * @param[in] message The message to enqueue.
67 * @return non-zero if the message was added to the queue. */
68int EnqueueMessage(struct PP_Var message) {
69  pthread_mutex_lock(&g_queue_mutex);
70
71  /* We shouldn't block the main thread waiting for the queue to not be full,
72   * so just drop the message. */
73  if (IsQueueFull()) {
74    pthread_mutex_unlock(&g_queue_mutex);
75    return 0;
76  }
77
78  g_queue[g_queue_end] = message;
79  g_queue_end = (g_queue_end + 1) % MAX_QUEUE_SIZE;
80  g_queue_size++;
81
82  pthread_cond_signal(&g_queue_not_empty_cond);
83
84  pthread_mutex_unlock(&g_queue_mutex);
85
86  return 1;
87}
88
89/** Dequeue a message and return it.
90 *
91 * This function blocks until a message is available. It should not be called
92 * on the main thread.
93 *
94 * NOTE: this function assumes g_queue_mutex is _NOT_ held.
95 * @return The message at the head of the queue. */
96struct PP_Var DequeueMessage() {
97  struct PP_Var message;
98
99  pthread_mutex_lock(&g_queue_mutex);
100
101  while (IsQueueEmpty()) {
102    pthread_cond_wait(&g_queue_not_empty_cond, &g_queue_mutex);
103  }
104
105  message = g_queue[g_queue_start];
106  g_queue_start = (g_queue_start + 1) % MAX_QUEUE_SIZE;
107  g_queue_size--;
108
109  pthread_mutex_unlock(&g_queue_mutex);
110
111  return message;
112}
113