Remove media::VideoFrame from media::VideoCaptureDevice::Client interface

content/browser/renderer_host/media/video_capture_buffer_pool.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 CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_BUFFER_POOL_H_
 #define CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_BUFFER_POOL_H_
 
 #include <map>
 
 #include "base/basictypes.h"
@@ skipping 38 matching lines @@
   static const int kInvalidId;
   explicit VideoCaptureBufferPool(int count);
 
   // One-time (per client/per-buffer) initialization to share a particular
   // buffer to a process. The size of the allocation is returned as
   // |memory_size|.
   base::SharedMemoryHandle ShareToProcess(int buffer_id,
                                           base::ProcessHandle process_handle,
                                           size_t* memory_size);
 
+  // Query the memory parameters of |buffer_id|. Fills in parameters in the
+  // pointer arguments, and returns true iff the buffer exists.
+  bool GetBufferInfo(int buffer_id, void** memory, size_t* size);
+
   // Reserve or allocate a buffer of at least |size| bytes and return its id.
   // This will fail (returning kInvalidId) if the pool already is at its |count|
   // limit of the number of allocations, and all allocated buffers are in use by
   // the producer and/or consumers.
   //
   // If successful, the reserved buffer remains reserved (and writable by the
   // producer) until ownership is transferred either to the consumer via
   // HoldForConsumers(), or back to the pool with
   // RelinquishProducerReservation().
   //
@@ skipping 10 matching lines @@
   // Transfer a buffer from producer to consumer ownership.
   // |buffer_id| must be a buffer index previously returned by
   // ReserveForProducer(), and not already passed to HoldForConsumers().
   void HoldForConsumers(int buffer_id, int num_clients);
 
   // Indicate that one or more consumers are done with a particular buffer. This
   // effectively is the opposite of HoldForConsumers(). Once the consumers are
   // done, a buffer is returned to the pool for reuse.
   void RelinquishConsumerHold(int buffer_id, int num_clients);
 
-  // Detect whether a particular SharedMemoryHandle is exported by a buffer that
+  // Detect whether a particular memory pointer is exported by a buffer that
   // belongs to this pool -- that is, whether it was reserved by an earlier call
   // to ReserveForProducer(). If so, return its buffer_id. If not, return
   // kInvalidId, indicating the buffer is not recognized (it may be a valid
   // frame, but we didn't allocate it).
-  int RecognizeReservedBuffer(base::SharedMemoryHandle maybe_belongs_to_pool);
-
-  // Return a buffer wrapped in a useful type. If a reallocation occurred, the
-  // ID of the destroyed buffer is returned via |buffer_id_to_drop|.
-  scoped_refptr<media::VideoFrame> ReserveI420VideoFrame(
-      const gfx::Size& size,
-      int rotation,
-      int* buffer_id_to_drop);
+  int RecognizeReservedBuffer(const void* maybe_belongs_to_pool);
 
   int count() const { return count_; }
 
  private:
   friend class base::RefCountedThreadSafe<VideoCaptureBufferPool>;
 
   // Per-buffer state.
   struct Buffer {
     Buffer();
 
     // The memory created to be shared with renderer processes.
     base::SharedMemory shared_memory;
 
-    // Rotation in degrees of the buffer.
-    //
-    // TODO(jiayl): Move this out of this class. Clients can track rotation
-    // state themselves by means of a map keyed by buffer_id.
-    int rotation;
-
     // Tracks whether this buffer is currently referenced by the producer.
     bool held_by_producer;
 
     // Number of consumer processes which hold this shared memory.
     int consumer_hold_count;
   };
 
   typedef std::map<int, Buffer*> BufferMap;
 
   virtual ~VideoCaptureBufferPool();
@@ skipping 13 matching lines @@
 
   // The buffers, indexed by |buffer_id|.
   BufferMap buffers_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(VideoCaptureBufferPool);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_BUFFER_POOL_H_