CmaRenderer is dead. Long live MojoRenderer.

chromecast/media/cma/ipc/media_message.h

Index: chromecast/media/cma/ipc/media_message.h
diff --git a/chromecast/media/cma/ipc/media_message.h b/chromecast/media/cma/ipc/media_message.h
deleted file mode 100644
index 38187c2f32b5ffba47f9019dcabf3f49c6ac0927..0000000000000000000000000000000000000000
--- a/chromecast/media/cma/ipc/media_message.h
+++ /dev/null
@@ -1,166 +0,0 @@
-// 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_H_
-#define CHROMECAST_MEDIA_CMA_IPC_MEDIA_MESSAGE_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <memory>
-
-#include "base/callback.h"
-#include "base/macros.h"
-
-namespace chromecast {
-namespace media {
-class MediaMemoryChunk;
-
-// MediaMessage -
-// Represents a media message, including:
-// - a message header that gives for example the message size or its type,
-// - the content of the message,
-// - and some possible padding if the content does not occupy the whole
-//   reserved space.
-//
-class MediaMessage {
- public:
-  // Memory allocator: given a number of bytes to allocate,
-  // return the pointer to the allocated block if successful
-  // or NULL if allocation failed.
-  typedef base::Callback<std::unique_ptr<MediaMemoryChunk>(size_t)>
-      MemoryAllocatorCB;
-
-  // Creates a message with no associated memory for its content, i.e.
-  // each write on this message is a dummy operation.
-  // This type of message can be useful to calculate first the size of the
-  // message, before allocating the real message.
-  static std::unique_ptr<MediaMessage> CreateDummyMessage(uint32_t type);
-
-  // Creates a message with a capacity of at least |msg_content_capacity|
-  // bytes. The actual content size can be smaller than its capacity.
-  // The message can be populated with some Write functions.
-  static std::unique_ptr<MediaMessage> CreateMessage(
-      uint32_t type,
-      const MemoryAllocatorCB& memory_allocator,
-      size_t msg_content_capacity);
-
-  // Creates a message of type |type| whose serialized structure is stored
-  // in |mem|.
-  static std::unique_ptr<MediaMessage> CreateMessage(
-      uint32_t type,
-      std::unique_ptr<MediaMemoryChunk> mem);
-
-  // Creates a message from a memory area which already contains
-  // the serialized structure of the message.
-  // Only Read functions can be invoked on this type of message.
-  static std::unique_ptr<MediaMessage> MapMessage(
-      std::unique_ptr<MediaMemoryChunk> mem);
-
-  // Return the minimum size of a message.
-  static size_t minimum_msg_size() {
-    return offsetof(SerializedMsg, content);
-  }
-
-  ~MediaMessage();
-
-  // Indicate whether the underlying serialized structure of the message is
-  // available.
-  // Note: the serialized structure might be unavailable in case of a dummy
-  // message or if the underlying memory has been invalidated.
-  bool IsSerializedMsgAvailable() const;
-
-  // Return the message and the total size of the message
-  // incuding the header, the content and the possible padding.
-  const void* msg() const { return msg_read_only_; }
-  size_t size() const { return cached_msg_.header.size; }
-
-  // Return the size of the message without padding.
-  size_t actual_size() const {
-    return minimum_msg_size() + cached_msg_.header.content_size;
-  }
-
-  // Return the size of the content of the message.
-  size_t content_size() const { return cached_msg_.header.content_size; }
-
-  // Return the type of the message.
-  uint32_t type() const { return cached_msg_.header.type; }
-
-  // Append a POD to the message.
-  // Return true if the POD has been succesfully written.
-  template<typename T> bool WritePod(T* const& pod);
-  template<typename T> bool WritePod(const T& pod) {
-    return WriteBuffer(&pod, sizeof(T));
-  }
-
-  // Append a raw buffer to the message.
-  bool WriteBuffer(const void* src, size_t size);
-
-  // Read a POD from the message.
-  template<typename T> bool ReadPod(T* pod) {
-    return ReadBuffer(pod, sizeof(T));
-  }
-
-  // Read |size| bytes from the message from the last read position
-  // and write it to |dst|.
-  bool ReadBuffer(void* dst, size_t size);
-
-  // Return a pointer to a buffer of size |size|.
-  // Return NULL if not successful.
-  const void* GetBuffer(size_t size);
-  void* GetWritableBuffer(size_t size);
-
- private:
-  MediaMessage(uint32_t type, size_t msg_size);
-  MediaMessage(uint32_t type, std::unique_ptr<MediaMemoryChunk> memory);
-  MediaMessage(std::unique_ptr<MediaMemoryChunk> memory);
-
-  struct Header {
-    // Total size of the message (including both header & content).
-    uint32_t size;
-    // Indicate the message type.
-    uint32_t type;
-    // Actual size of the content in the message.
-    uint32_t content_size;
-  };
-
-  struct SerializedMsg {
-    // Message header.
-    Header header;
-
-    // Start of the content of the message.
-    // Use uint8_t since no special alignment is needed.
-    uint8_t content;
-  };
-
-  // Indicate whether the message is a dummy message, i.e. a message without
-  // a complete underlying serialized structure: only the message header is
-  // available.
-  bool is_dummy_msg_;
-
-  // |cached_msg_| is used for 2 purposes:
-  // - to create a dummy message
-  // - for security purpose: cache the msg header to avoid browser security
-  // issues.
-  SerializedMsg cached_msg_;
-  Header* const cached_header_;
-
-  SerializedMsg* msg_;
-  SerializedMsg* msg_read_only_;
-
-  // Memory allocated to store the underlying serialized structure into memory.
-  // Note: a dummy message has no underlying serialized structure:
-  // |mem_| is a null pointer in that case.
-  std::unique_ptr<MediaMemoryChunk> mem_;
-
-  // Read iterator into the message.
-  size_t rd_offset_;
-
-  DISALLOW_COPY_AND_ASSIGN(MediaMessage);
-};
-
-}  // namespace media
-}  // namespace chromecast
-
-#endif