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

ppapi/shared_impl/io_stream_shared.h

Index: ppapi/shared_impl/io_stream_shared.h
diff --git a/ppapi/shared_impl/io_stream_shared.h b/ppapi/shared_impl/io_stream_shared.h
new file mode 100644
index 0000000000000000000000000000000000000000..9362270cd0f1f84713b16891b03f3eb6514fac04
--- /dev/null
+++ b/ppapi/shared_impl/io_stream_shared.h
@@ -0,0 +1,85 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.

[bbudge, 2013/12/31 00:51:53]

s/2012/2013

[Peng, 2013/12/31 23:33:54]

Done.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef PPAPI_SHARED_IMPL_IO_STREAM_SHAERD_H_

[bbudge, 2013/12/31 00:51:53]

s/SHAERD_H/SHARED_H

[Peng, 2013/12/31 23:33:54]

Done.

+#define PPAPI_SHARED_IMPL_IO_STREAM_SHAERD_H_
+
+#include "base/basictypes.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/shared_memory.h"
+#include "base/memory/weak_ptr.h"

[bbudge, 2013/12/31 00:51:53]

I don't think this is needed.

[Peng, 2013/12/31 23:33:54]

Done.

+#include "ppapi/shared_impl/circular_buffer.h"
+#include "ppapi/shared_impl/ppapi_shared_export.h"
+
+namespace ppapi {
+
+class CircularBuffer;
+
+class PPAPI_SHARED_EXPORT IOStreamShared {
+ public:
+  int32_t Write(const void* buffer, uint32_t size);
+
+  int32_t WriteAll(const void* buffer, uint32_t size);
+
+  int32_t Read(void* buffer, uint32_t size);
+
+  int32_t ReadAll(void* buffer, uint32_t size);
+
+  int32_t Lock(void** buffer, uint32_t size);
+
+  int32_t Relock(void* buffer, uint32_t size);
+
+  int32_t Unlock(void* buffer);
+
+  uint32_t remaining() const;
+
+  bool input() { return input_; }

[bbudge, 2013/12/31 00:51:53]

I think it would be clearer to call this is_input().
That probably implies changing 'input'  to 'is_input' everywhere in this file.

[Peng, 2013/12/31 23:33:54]

Done.

+
+  const scoped_ptr<base::SharedMemory>& shared_memory() const {

[bbudge, 2013/12/31 00:51:53]

It seems dangerous to return a ref to our scoped_ptr.

[Peng, 2013/12/31 23:33:54]

Done.

+    return shm_;
+  }
+
+ protected:
+  IOStreamShared(bool input);
+
+  virtual ~IOStreamShared();
+
+  // Set the underlying shared memory.
+  int32_t SetBuffer(scoped_ptr<base::SharedMemory> shm, uint32_t size);
+
+  // Subclass uses this function to move the limit position of the
+  // |circular_buffer_|.
+  void MoveLimit(uint32_t offset);
+
+  // Subclass may overridden this function to receive notification when
+  // more buffer is available.
+  virtual void OnMoreBufferAvailable();
+
+ private:
+  // Move limit position at the another peer of an IOStream pair.
+  // Subclass should send IPC message to the another peer to move the limit
+  // position.
+  virtual void MovePeerLimit(uint32_t offset) = 0;
+
+  // True if it is an input peer of an IO stream, otherwise it is an output peer
+  // of an IO stream.
+  bool input_;
+
+  // Shared memory.
+  scoped_ptr<base::SharedMemory> shm_;
+
+  // A new shared memory will be used to replace the existing |shm_|.
+  scoped_ptr<base::SharedMemory> shm_new_;
+
+  // Circular buffer
+  scoped_ptr<CircularBuffer> circular_buffer_;
+
+  scoped_ptr<CircularBuffer> circular_buffer_new_;

[bbudge, 2013/12/31 00:51:53]

I think you could get away with just having one CircularBuffer, and just contain
it directly rather than use scoped_ptr.

You would have to add a size_new_ field to hold the new size until you can do
the swap. You would also need to change CircularBuffer to have a default
constructor and an Init or SetBuffer method.

[Peng, 2013/12/31 23:33:54]

I use two circular_buffers because when a new shared memory is set, the
|MoveLimit()|, |Relock()| can still be used before |Unlock()|. In this case,
|MoveLimit()| will move the limit_ in |circular_buffer_new_| instead of
|circular_buffer_|. If we want to use one buffer, probably we have to duplicate
some fields in CircularBuffer. So I think using two circular buffers is slight
simpler.

BTW, currently, we will drop all frames if underlying buffer is changed.
probably it is OK. But if we want, we could swap circular_buffer_ when all
content in the old buffer is consumed instead of in |Unlock()|. Not sure if it
is necessary.


thought?
  

 

[bbudge, 2014/01/02 18:51:43]

I'm suggesting that when SetBuffer is called, but the CircularBuffer is locked,
you simply store the shm in shm_new_ and wait until the buffer is unlocked
before creating the new CircularBuffer. Any calls to MoveLimit before Unlock
should work on the old CircularBuffer.

I don't know much about how this would be used so I'm not sure about your last
question. I would expect that SetBuffer would only be called once in the vast
majority of usage scenarios so I would go with the approach that is easiest to
implement for now.

+
+  DISALLOW_COPY_AND_ASSIGN(IOStreamShared);
+};
+
+}  // namespace ppapi
+
+#endif  // PPAPI_SHARED_IMPL_IO_STREAM_SHAERD_H_