CmaRenderer is dead. Long live MojoRenderer.

chromecast/media/cma/ipc/media_message_fifo.h

-// Copyright 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.
-
-#ifndef CHROMECAST_MEDIA_CMA_IPC_MEDIA_MESSAGE_FIFO_H_
-#define CHROMECAST_MEDIA_CMA_IPC_MEDIA_MESSAGE_FIFO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <list>
-#include <memory>
-
-#include "base/atomicops.h"
-#include "base/callback.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/weak_ptr.h"
-#include "base/threading/thread_checker.h"
-
-namespace chromecast {
-namespace media {
-class MediaMemoryChunk;
-class MediaMessage;
-class MediaMessageFlag;
-
-// MediaMessageFifo is a lock free fifo implementation
-// to pass audio/video data from one thread to another or from one process
-// to another one (in that case using shared memory).
-//
-// Assuming the feeder and the consumer have a common block of shared memory
-// (representing the serialized structure of the fifo),
-// the feeder (which must be running on a single thread) instantiates its own
-// instance of MediaMessageFifo, same applies to the consumer.
-//
-// Example: assuming the block of shared memory is given by |mem|, a typical
-// feeder (using MediaMessageFifo instance fifo_feeder) will push messages
-// in the following way:
-//   // Create a dummy message to calculate the size of the serialized message.
-//   std::unique_ptr<MediaMessage> dummy_msg(
-//     MediaMessage::CreateDummyMessage(msg_type));
-//   // ...
-//   // Write all the fields to the dummy message.
-//   // ...
-//
-//   // Create the real message, once the size of the serialized message
-//   // is known.
-//   std::unique_ptr<MediaMessage> msg(
-//     MediaMessage::CreateMessage(
-//       msg_type,
-//       base::Bind(&MediaMessageFifo::ReserveMemory,
-//                  base::Unretained(fifo_feeder.get())),
-//       dummy_msg->content_size()));
-//   if (!msg) {
-//     // Not enough space for the message:
-//     // retry later (e.g. when receiving a read activity event, meaning
-//     // some enough space might have been release).
-//     return;
-//   }
-//   // ...
-//   // Write all the fields to the real message
-//   // in exactly the same way it was done for the dummy message.
-//   // ...
-//   // Once message |msg| is going out of scope, then MediaMessageFifo
-//   // fifo_feeder is informed that the message is not needed anymore
-//   // (i.e. it was fully written), and fifo_feeder can then update
-//   // the external write pointer of the fifo so that the consumer
-//   // can start consuming this message.
-//
-// A typical consumer (using MediaMessageFifo instance fifo_consumer)
-// will retrive messages in the following way:
-//   std::unique_ptr<MediaMessage> msg(fifo_consumer->Pop());
-//   if (!msg) {
-//     // The fifo is empty, i.e. no message left.
-//     // Try reading again later (e.g. after receiving a write activity event.
-//     return;
-//   }
-//   // Parse the message using Read functions of MediaMessage:
-//   // ...
-//   // Once the message is going out of scope, MediaMessageFifo will receive
-//   // a notification that the underlying memory can be released
-//   // (i.e. the external read pointer can be updated).
-//
-//
-class MediaMessageFifo {
- private:
-  struct Descriptor {
-    size_t size;
-    size_t rd_offset;
-    size_t wr_offset;
-
-    // Ensure the first item has the same alignment as an int64_t.
-    int64_t first_item;
-  };
-
- public:
-  static const int kDescriptorSize = sizeof(Descriptor);
-
-  // Creates a media message fifo using |mem| as the underlying serialized
-  // structure.
-  // If |init| is true, the underlying fifo structure is initialized.
-  MediaMessageFifo(std::unique_ptr<MediaMemoryChunk> mem, bool init);
-  ~MediaMessageFifo();
-
-  // When the consumer and the feeder are living in two different processes,
-  // we might want to convey some messages between these two processes to notify
-  // about some fifo activity.
-  void ObserveReadActivity(const base::Closure& read_event_cb);
-  void ObserveWriteActivity(const base::Closure& write_event_cb);
-
-  // Reserves a writeable block of memory at the back of the fifo,
-  // corresponding to the serialized structure of the message.
-  // Returns NULL if the required size cannot be allocated.
-  std::unique_ptr<MediaMemoryChunk> ReserveMemory(size_t size);
-
-  // Pop a message from the queue.
-  // Returns a null pointer if there is no message left.
-  std::unique_ptr<MediaMessage> Pop();
-
-  // Flush the fifo.
-  void Flush();
-
- private:
-  // Add some accessors to ensure security on the browser process side.
-  size_t current_rd_offset() const;
-  size_t current_wr_offset() const;
-  size_t internal_rd_offset() const {
-    DCHECK_LT(internal_rd_offset_, size_);
-    return internal_rd_offset_;
-  }
-  size_t internal_wr_offset() const {
-    DCHECK_LT(internal_wr_offset_, size_);
-    return internal_wr_offset_;
-  }
-
-  // Reserve a block of free memory without doing any check on the available
-  // space. Invoke this function only when all the checks have been done.
-  std::unique_ptr<MediaMemoryChunk> ReserveMemoryNoCheck(size_t size);
-
-  // Invoked each time there is a memory region in the free space of the fifo
-  // that has possibly been written.
-  void OnWrMemoryReleased();
-
-  // Invoked each time there is a memory region in the allocated space
-  // of the fifo that has possibly been released.
-  void OnRdMemoryReleased();
-
-  // Functions to modify the internal/external read/write pointers.
-  void CommitRead(size_t new_rd_offset);
-  void CommitWrite(size_t new_wr_offset);
-  void CommitInternalRead(size_t new_rd_offset);
-  void CommitInternalWrite(size_t new_wr_offset);
-
-  // An instance of MediaMessageFifo must be running on a single thread.
-  // If the fifo feeder and consumer are living on 2 different threads
-  // or 2 different processes, they must create their own instance
-  // of MediaMessageFifo using the same underlying block of (shared) memory
-  // in the constructor.
-  base::ThreadChecker thread_checker_;
-
-  // Callbacks invoked to notify either of some read or write activity on the
-  // fifo. This is especially useful when the feeder and consumer are living in
-  // two different processes.
-  base::Closure read_event_cb_;
-  base::Closure write_event_cb_;
-
-  // The serialized structure of the fifo.
-  std::unique_ptr<MediaMemoryChunk> mem_;
-
-  // The size in bytes of the fifo is cached locally for security purpose.
-  // (the renderer process cannot modify the size and make the browser process
-  // access out of range addresses).
-  size_t size_;
-
-  // TODO(damienv): This is a work-around since atomicops.h does not define
-  // an atomic size_t type.
-#if SIZE_MAX == UINT32_MAX
-  typedef base::subtle::Atomic32 AtomicSize;
-#elif SIZE_MAX == UINT64_MAX
-  typedef base::subtle::Atomic64 AtomicSize;
-#else
-#error "Unsupported size_t"
-#endif
-  AtomicSize* rd_offset_;
-  AtomicSize* wr_offset_;
-
-  // Internal read offset: this is where data is actually read from.
-  // The external offset |rd_offset_| is only used to protect data from being
-  // overwritten by the feeder.
-  // At any time, the internal read pointer must be between the external read
-  // offset and the write offset (circular fifo definition of "between").
-  size_t internal_rd_offset_;
-  size_t internal_wr_offset_;
-
-  // Note: all the memory read/write are followed by a memory fence before
-  // updating the rd/wr pointer.
-  void* base_;
-
-  // Protects the messages that are either being read or written.
-  std::list<scoped_refptr<MediaMessageFlag> > rd_flags_;
-  std::list<scoped_refptr<MediaMessageFlag> > wr_flags_;
-
-  base::WeakPtr<MediaMessageFifo> weak_this_;
-  base::WeakPtrFactory<MediaMessageFifo> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(MediaMessageFifo);
-};
-
-}  // namespace media
-}  // namespace chromecast
-
-#endif  // CHROMECAST_MEDIA_CMA_IPC_MEDIA_MESSAGE_FIFO_H_