OLD | NEW |
| (Empty) |
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|. */ | |
16 static pthread_mutex_t g_queue_mutex; | |
17 | |
18 /** A condition variable that is signalled when |g_queue| is not empty. */ | |
19 static 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. */ | |
32 static struct PP_Var g_queue[MAX_QUEUE_SIZE]; | |
33 | |
34 /** The index of the head of the queue. */ | |
35 static int g_queue_start = 0; | |
36 | |
37 /** The index of the tail of the queue, non-inclusive. */ | |
38 static int g_queue_end = 0; | |
39 | |
40 /** The size of the queue. */ | |
41 static 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. */ | |
47 static 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. */ | |
53 static int IsQueueFull() { return g_queue_size == MAX_QUEUE_SIZE; } | |
54 | |
55 /** Initialize the message queue. */ | |
56 void 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. */ | |
68 int 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. */ | |
96 struct 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 } | |
OLD | NEW |