[NaCl SDK] Remove invalid assert from nacl_io.

native_client_sdk/src/examples/api/input_event/shared_queue.h

 // Copyright (c) 2012 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 SHARED_QUEUE_H
 #define SHARED_QUEUE_H
 
 #include <pthread.h>
 #include <cassert>
 #include <deque>
 
+#ifdef __GNUC__

[binji, 2013/09/04 20:21:48]

not sure I like adding UNUSED to this header. Does it fix the warning if you do
this instead?

...
assert(result == 0);
(void)result;

or maybe disable the warning (via #pragma) below?
or move the #ifdef below?

[Sam Clegg, 2013/09/04 20:54:43]

I prefer the attribute to the #pragma.

(void) doesn't fix the issue in my experience. The compilers are
getting too clever.  Even if it did work is less explicit and 
more fragile.

Moved the macro down.

+#define UNUSED __attribute__ ((unused))
+#else
+#define UNUSED
+#endif
+
 // This file provides a queue that uses a mutex and condition variable so that
 // one thread can put pointers into the queue and another thread can pull items
 // out of the queue.
 
 // Specifies whether we want to wait for the queue.
 enum QueueWaitingFlag {
   kWait = 0,
   kDontWait
 };
 
@@ skipping 23 matching lines @@
   }
 
  private:
   pthread_mutex_t* mutex_;  // Weak reference, passed in to constructor.
 
   // Disable copy and assign.
   ScopedLock& operator=(const ScopedLock&);
   ScopedLock(const ScopedLock&);
 };
 
+
 // LockingQueue contains a collection of <T>, such as a collection of
 // objects or pointers.  The Push() method is used to add items to the
 // queue in a thread-safe manner.  The GetItem() is used to retrieve
 // items from the queue in a thread-safe manner.
 template <class T> class LockingQueue {
  public:
   LockingQueue() : quit_(false) {
-    int result = pthread_mutex_init(&queue_mutex_, NULL);
+    int result UNUSED;
+    result = pthread_mutex_init(&queue_mutex_, NULL);
     assert(result == 0);
     result = pthread_cond_init(&queue_condition_var_, NULL);
     assert(result == 0);
   }
   ~LockingQueue() { pthread_mutex_destroy(&queue_mutex_); }
 
   // The producer (who instantiates the queue) calls this to tell the
   // consumer that the queue is no longer being used.
   void CancelQueue() {
     ScopedLock scoped_mutex(&queue_mutex_);
@@ skipping 65 matching lines @@
   std::deque<T> the_queue_;
   bool quit_;
   pthread_mutex_t queue_mutex_;
   pthread_cond_t queue_condition_var_;
 
   // This is used by methods that already have the lock.
   bool is_empty_no_locking() const { return the_queue_.empty(); }
 };
 
 #endif  // SHARED_QUEUE_H