[NaCl SDK] Support non blocking TCP/UDP

native_client_sdk/src/libraries/nacl_io/event_emitter_packet.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 LIBRARIES_NACL_IO_EVENT_EMITTER_PACKET_H_
+#define LIBRARIES_NACL_IO_EVENT_EMITTER_PACKET_H_
+
+#include <poll.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "nacl_io/event_emitter.h"
+#include "nacl_io/fifo_packet.h"
+
+#include "sdk_util/auto_lock.h"
+
+namespace nacl_io {
+
+class EventEmitterPacket;
+typedef sdk_util::ScopedRef<EventEmitterPacket> ScopedEmitterPacket;
+
+class EventEmitterPacket : public EventEmitter {
+ public:
+  EventEmitterPacket(size_t rsize, size_t wsize)

[binji, 2013/09/12 01:47:56]

I'd prefer having a .cc file instead of defining this all in the header

[noelallen1, 2013/09/12 23:19:03]

That's in the follow on.  

+      : rfifo_(NULL),
+        wfifo_(NULL),
+        event_status_(0) {
+
+    rsize = std::max<size_t>(1, rsize);
+    fifo_ = new FIFOPacket(rsize);

[binji, 2013/09/12 01:47:56]

Why allocate?

If you define these as non-pointer members you can construct them like so:

rfifo_(std::max<size_t>(1, rsize)),
wfifo_(std::max<size_t>(1, wsize)),

And then you can use the default destructor

[noelallen1, 2013/09/12 23:19:03]

I was allowing for more sharing in the parent class by letting the child
allocate specializations, but I don't think I need it here.

+
+    wsize = std::max<size_t>(1, wsize);
+    fifo_ = new FIFOPacket(wsize);
+
+    UpdateStatusLocked();
+  }
+
+  ~EventEmitterPipe() {
+    delete rfifo_;
+    delete wfifo_;
+  }
+
+  virtual uint32_t GetEventStatus() {
+    return event_status_;
+  }
+
+  Packet* ReadPacket() {

[binji, 2013/09/12 01:47:56]

what's the ownership of the returned packet?

[noelallen1, 2013/09/12 23:19:03]

I'll comment.

+    AUTO_LOCK(emitter_lock_);
+    Packet* packet = rfifo_->Read();
+
+    UpdateStatusLocked();
+    return packet;
+  }
+
+  uint32_t WritePacket(Packet* packet) {

[binji, 2013/09/12 01:47:56]

ownership of passed packet?

[noelallen1, 2013/09/12 23:19:03]

Done.

+    AUTO_LOCK(emitter_lock_);
+    uint32_t result = rfifo_->Write(packet);
+
+    UpdateStatusLocked();
+    return result;
+  }
+
+ protected:
+  void UpdateStatusLocked() {
+    uint32_t old_status = event_status_;
+
+    if (!rfifo_->IsEmpty()) {
+      event_status_ |= POLLIN;
+    } else {
+      event_status_ &= ~POLLIN;
+    }
+
+    if (!wfifo_->IsFull()) {
+      event_status_ |= POLLOUT;
+    } else {
+      event_status_ &= ~POLLOUT;
+    }
+
+    uint32_t raise_status = event_status_ & ~old_status;
+    if (raise_status)
+      RaiseEvents_Locked(raise_status);
+  }
+
+  FIFOPacket* rfifo_;
+  FIFOPacket* wfifo_;
+  uint32_t event_status_;
+};
+
+}  // namespace nacl_io
+
+#endif  // LIBRARIES_NACL_IO_EVENT_EMITTER_PIPE_H_

[binji, 2013/09/12 01:47:56]

PACKET_H_

[noelallen1, 2013/09/12 23:19:03]

Done.

+