[PPAPI] Implement an IOStreamResource for data transmission between plugin and renderer.

ppapi/shared_impl/io_stream_shared.cc

+// Copyright (c) 2014 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/shared_impl/io_stream_shared.h"
+
+#include "base/logging.h"
+#include "ppapi/c/pp_errors.h"
+
+namespace ppapi {
+
+IOStreamShared::IOStreamShared(bool is_input)
+    : is_input_(is_input) {
+}
+
+IOStreamShared::~IOStreamShared() {
+}
+
+int32_t IOStreamShared::SetBuffer(scoped_ptr<base::SharedMemory> shm,
+                                  uint32_t size) {
+  if (!size)

[yzshen1, 2014/01/03 21:51:41]

nit: For numeric comparison, please use size == 0.

+    return PP_ERROR_BADARGUMENT;
+
+  if (!(shm && shm->Map(size)))
+    return PP_ERROR_NOMEMORY;
+
+  shm_new_ = shm.Pass();
+  circular_buffer_new_.reset(new CircularBuffer(shm_new_->memory(), size));
+  if (!is_input_)
+    circular_buffer_new_->MoveLimit(size);
+
+  // If the |circular_buffer_| is locked, wait until next |Unlock()|.
+  if ((!circular_buffer_) ||
+      (!circular_buffer_->IsLocked())) {
+    shm_ = shm_new_.Pass();
+    circular_buffer_ = circular_buffer_new_.Pass();
+  }
+  return PP_OK;
+}
+
+int32_t IOStreamShared::Write(const void* buffer, uint32_t size) {
+  CHECK(!is_input_);

[yzshen1, 2014/01/03 21:51:41]

Please see my comment about parameter validation in circular_buffer

+  CHECK(buffer);
+  CHECK(size);
+
+  int32_t result = circular_buffer_->Write(buffer, size);
+  if (result > 0)
+    MovePeerLimit(size);
+  return result;
+}
+
+int32_t IOStreamShared::WriteAll(const void* buffer, uint32_t size) {
+  CHECK(!is_input_);
+  CHECK(buffer);
+  CHECK(size);
+
+  int32_t result = circular_buffer_->WriteAll(buffer, size);
+  if (result > 0)
+    MovePeerLimit(result);
+  return result;
+}
+
+int32_t IOStreamShared::Read(void* buffer, uint32_t size) {
+  CHECK(is_input_);
+  CHECK(buffer);
+  CHECK(size);
+
+  int32_t result = circular_buffer_->Read(buffer, size);
+  if (result > 0)
+    MovePeerLimit(size);
+  return result;
+}
+
+int32_t IOStreamShared::ReadAll(void* buffer, uint32_t size) {
+  CHECK(is_input_);
+  CHECK(buffer);
+  CHECK(size);
+
+  int32_t result = circular_buffer_->ReadAll(buffer, size);
+  if (result > 0)
+    MovePeerLimit(result);
+  return result;
+}
+
+int32_t IOStreamShared::Lock(void** buffer, uint32_t size) {
+  CHECK(buffer);
+  CHECK(size);
+  return circular_buffer_->Lock(buffer, size);
+}
+
+int32_t IOStreamShared::Relock(void* buffer, uint32_t size) {
+  CHECK(buffer);
+  CHECK(size);
+  return circular_buffer_->Relock(buffer, size);
+}
+
+int32_t IOStreamShared::Unlock(void* buffer) {
+  int32_t result = circular_buffer_->Unlock(buffer);
+  if (result <= 0)
+    return result;
+
+  if (!shm_new_) {
+    MovePeerLimit(result);
+  } else {
+    // Now that|circular_buffer_| is unlocked, swap in the new buffer.
+    shm_ = shm_new_.Pass();
+    circular_buffer_ = circular_buffer_new_.Pass();
+    if (is_input_ && circular_buffer_->remaining())
+      OnMoreBufferAvailable();
+  }
+  return PP_OK;
+}
+
+uint32_t IOStreamShared::remaining() const {
+  if (!circular_buffer_)
+    return 0;
+  return circular_buffer_->remaining();

[dmichael (off chromium), 2014/01/03 18:05:29]

This isn't right if there's a "new" CircularBuffer and we're still waiting on
the unlock.

(I think the best way to "fix" it is to remove the ability to replace the buffer
at all, if that's possible)

+}
+
+void IOStreamShared::MoveLimit(uint32_t offset) {
+  if (circular_buffer_new_) {
+    circular_buffer_new_->MoveLimit(offset);
+  } else {
+    circular_buffer_->MoveLimit(offset);
+    OnMoreBufferAvailable();
+  }
+}
+
+void IOStreamShared::OnMoreBufferAvailable() {
+}
+
+}  // namespace ppapi