[PPAPI][MediaStream] Support configure for video input.

ppapi/shared_impl/media_stream_buffer_manager.cc

 // 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.
 
 #include "ppapi/shared_impl/media_stream_buffer_manager.h"
 
 #include "base/logging.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/shared_impl/media_stream_buffer.h"
 
@@ skipping 13 matching lines @@
 
 MediaStreamBufferManager::~MediaStreamBufferManager() {
 }
 
 bool MediaStreamBufferManager::SetBuffers(
     int32_t number_of_buffers,
     int32_t buffer_size,
     scoped_ptr<base::SharedMemory> shm,
     bool enqueue_all_buffers) {
   DCHECK(shm);
-  DCHECK(!shm_);
   DCHECK_GT(number_of_buffers, 0);
   DCHECK_GT(buffer_size,
             static_cast<int32_t>(sizeof(MediaStreamBuffer::Header)));

[jschuh, 2014/02/14 22:21:25]

I realize this is existing code, but shouldn't this be verified in release
builds, or are we checking it elsewhere?

[Peng, 2014/02/16 15:48:13]

Those input arguments are not from third party code (plugin). The caller will
make sure those arguments are valid. So we just use DCHECK() to check them in
debug build. Is it necessary to use CHECK() for release build as well?

   DCHECK_EQ(buffer_size & 0x3, 0);
 
   number_of_buffers_ = number_of_buffers;
   buffer_size_ = buffer_size;
 
   int32_t size = number_of_buffers_ * buffer_size;

[jschuh, 2014/02/14 22:21:25]

Also existing code, but where are these sizes validated and how do we know this
won't overflow?

[Peng, 2014/02/16 15:48:13]

Same reason. arguments are not from third party code. So we know the maximum
value of them.
number_of_buffers_ is in [1, 8]
buffer_size is in (0, 4096 * 4096 * 4]

So it should not overflow. Anyway, I will change int32_t to size_t.
Done
 

   shm_ = shm.Pass();
   if (!shm_->Map(size))
     return false;
 
+  buffer_queue_.clear();
+  buffers_.clear();
   uint8_t* p = reinterpret_cast<uint8_t*>(shm_->memory());
   for (int32_t i = 0; i < number_of_buffers; ++i) {
     if (enqueue_all_buffers)
       buffer_queue_.push_back(i);
     buffers_.push_back(reinterpret_cast<MediaStreamBuffer*>(p));
     p += buffer_size_;
   }
   return true;
 }
 
 int32_t MediaStreamBufferManager::DequeueBuffer() {
   if (buffer_queue_.empty())
     return PP_ERROR_FAILED;
   int32_t buffer = buffer_queue_.front();
   buffer_queue_.pop_front();
   return buffer;
 }
 
 void MediaStreamBufferManager::EnqueueBuffer(int32_t index) {
-  DCHECK_GE(index, 0);
-  DCHECK_LT(index, number_of_buffers_);
+  CHECK_GE(index, 0) << "Invalid buffer index";
+  CHECK_LT(index, number_of_buffers_) << "Invalid buffer index";
   buffer_queue_.push_back(index);
   delegate_->OnNewBufferEnqueued();
 }
 
 MediaStreamBuffer* MediaStreamBufferManager::GetBufferPointer(
     int32_t index) {
-  DCHECK_GE(index, 0);
-  DCHECK_LT(index, number_of_buffers_);
+  CHECK_GE(index, 0) << "Invalid buffer index";
+  CHECK_LT(index, number_of_buffers_) << "Invalid buffer index";
   return buffers_[index];
 }
 
 }  // namespace ppapi