Introduce a client minimum picture pool size

ppapi/proxy/video_decoder_resource.cc

 // Copyright (c) 2012 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/proxy/video_decoder_resource.h"
 
 #include "base/bind.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/common/mailbox.h"
@@ skipping 11 matching lines @@
 #include "ppapi/shared_impl/resource_tracker.h"
 #include "ppapi/thunk/enter.h"
 
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Graphics3D_API;
 using ppapi::thunk::PPB_VideoDecoder_API;
 
 namespace ppapi {
 namespace proxy {
 
+namespace {
+
+// The maximum number of pictures that the client can pass in for
+// min_picture_count, just as a sanity check on the argument.
+// This should match the constant of the same name in test_video_decoder.cc.
+const uint32_t kMaximumPictureCount = 100;

[jln (very slow on Chromium), 2015/08/17 21:44:39]

What happens if they don't match?

Could you expose a GetMaximumPictureCount() so that you can test that they match
at least?

[lpique, 2015/08/17 23:57:07]

The test in test_video_decoder.cc will fail, since it tries to use a count of
100, expecting it to pass, and a count of 101 expecting it to fail.
This question gave me the most pause.

Yes I could use this function to elimiante the constant from the test (it would
just use the returned value, and try calling Initialize() with the returned
count and one more than the returned count).

But it is not really useful otherwise. The limit of 100 I chose is purely
arbitrary. For the purposes of my work on ARC (a client of this API) I only
actually need a minimum picture count of 8. I chose a larger  value in case that
changes, but 100 is pretty extreme.

For video decoding, a normal client will want to minimize this value. Large
values represent more memory being allocated, as well as more latency (ARC, or
really the Android code it uses has additional logic to sync things up despite
having a larger decode queue)

A normal client would have some simple known fixed constant need, and I think it
is perfectly fine if it tries to call Initialize() with this value, and just
asserts that it returns PP_OK. Being able to call GetMaximumPictureCount() might
be useful for displaying an error message, but its not really useful otherwise.
If the limit is too small, the only way to increase it is to rebuild Chrome with
a larger value.

+
+}  // namespace
+
 VideoDecoderResource::ShmBuffer::ShmBuffer(
     scoped_ptr<base::SharedMemory> shm_ptr,
     uint32_t size,
     uint32_t shm_id)
     : shm(shm_ptr.Pass()), addr(NULL), shm_id(shm_id) {
   if (shm->Map(size))
     addr = shm->memory();
 }
 
 VideoDecoderResource::ShmBuffer::~ShmBuffer() {
@@ skipping 13 matching lines @@
     : decode_id(decode_id), texture_id(texture_id), visible_rect(visible_rect) {
 }
 
 VideoDecoderResource::Picture::~Picture() {
 }
 
 VideoDecoderResource::VideoDecoderResource(Connection connection,
                                            PP_Instance instance)
     : PluginResource(connection, instance),
       num_decodes_(0),
+      min_picture_count_(0),
       get_picture_(NULL),
       get_picture_0_1_(NULL),
       gles2_impl_(NULL),
       initialized_(false),
       testing_(false),
       // Set |decoder_last_error_| to PP_OK after successful initialization.
       // This makes error checking a little more concise, since we can check
       // that the decoder has been initialized and hasn't returned an error by
       // just testing |decoder_last_error_|.
       decoder_last_error_(PP_ERROR_FAILED) {
@@ skipping 16 matching lines @@
 int32_t VideoDecoderResource::Initialize0_1(
     PP_Resource graphics_context,
     PP_VideoProfile profile,
     PP_Bool allow_software_fallback,
     scoped_refptr<TrackedCallback> callback) {
   return Initialize(graphics_context,
                     profile,
                     allow_software_fallback
                         ? PP_HARDWAREACCELERATION_WITHFALLBACK
                         : PP_HARDWAREACCELERATION_ONLY,
+                    0,
                     callback);
 }
 
+int32_t VideoDecoderResource::Initialize0_2(
+    PP_Resource graphics_context,
+    PP_VideoProfile profile,
+    PP_HardwareAcceleration acceleration,
+    scoped_refptr<TrackedCallback> callback) {
+  return Initialize(graphics_context,
+                    profile,
+                    acceleration,
+                    0,
+                    callback);
+}
+
 int32_t VideoDecoderResource::Initialize(
     PP_Resource graphics_context,
     PP_VideoProfile profile,
     PP_HardwareAcceleration acceleration,
+    uint32_t min_picture_count,
     scoped_refptr<TrackedCallback> callback) {
   if (initialized_)
     return PP_ERROR_FAILED;
   if (profile < 0 || profile > PP_VIDEOPROFILE_MAX)
     return PP_ERROR_BADARGUMENT;
+  if (min_picture_count > kMaximumPictureCount)

[bbudge, 2015/08/19 18:47:05]

You could keep this if you move the constant definition. See my comment on the
host.

+    return PP_ERROR_BADARGUMENT;
   if (initialize_callback_.get())
     return PP_ERROR_INPROGRESS;
   if (!graphics_context)
     return PP_ERROR_BADRESOURCE;
 
+  min_picture_count_ = min_picture_count;
+
   HostResource host_resource;
   if (!testing_) {
     // Create a new Graphics3D resource that can create texture resources to
     // share with the plugin. We can't use the plugin's Graphics3D, since we
     // create textures on a proxy thread, and would interfere with the plugin.
     thunk::EnterResourceCreationNoLock enter_create(pp_instance());
     if (enter_create.failed())
       return PP_ERROR_FAILED;
     int32_t attrib_list[] = {PP_GRAPHICS3DATTRIB_NONE};
     graphics3d_ =
         ScopedPPResource(ScopedPPResource::PassRef(),
                          enter_create.functions()->CreateGraphics3D(
                              pp_instance(), graphics_context, attrib_list));
     EnterResourceNoLock<PPB_Graphics3D_API> enter_graphics(graphics3d_.get(),
                                                            false);
     if (enter_graphics.failed())
       return PP_ERROR_BADRESOURCE;
 
     PPB_Graphics3D_Shared* ppb_graphics3d_shared =
         static_cast<PPB_Graphics3D_Shared*>(enter_graphics.object());
     gles2_impl_ = ppb_graphics3d_shared->gles2_impl();
     host_resource = ppb_graphics3d_shared->host_resource();
   }
 
   initialize_callback_ = callback;
 
   Call<PpapiPluginMsg_VideoDecoder_InitializeReply>(
       RENDERER,
       PpapiHostMsg_VideoDecoder_Initialize(
-          host_resource, profile, acceleration),
+          host_resource, profile, acceleration, min_picture_count),
       base::Bind(&VideoDecoderResource::OnPluginMsgInitializeComplete, this));
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t VideoDecoderResource::Decode(uint32_t decode_id,
                                      uint32_t size,
                                      const void* buffer,
                                      scoped_refptr<TrackedCallback> callback) {
   if (decoder_last_error_)
@@ skipping 194 matching lines @@
   testing_ = true;
 }
 
 void VideoDecoderResource::OnPluginMsgRequestTextures(
     const ResourceMessageReplyParams& params,
     uint32_t num_textures,
     const PP_Size& size,
     uint32_t texture_target,
     const std::vector<gpu::Mailbox>& mailboxes) {
   DCHECK(num_textures);
+  DCHECK(num_textures >= min_picture_count_);

[jln (very slow on Chromium), 2015/08/17 21:44:39]

Is this correct as a DCHECK? What happens if an attacker sends a malicious
min_picture_count?

[lpique, 2015/08/17 23:57:07]

I think so. With the rest of my changes, this should never be trigger, as later
code ensures that num_textures >= min_picture_count_.

I left this here in case some introduces a new code path that does not respect
the minimum requested, in which case the test for allocating the maximum allowed
minimum picture count should trigger the DCHECK (unless I am mistaken about the
DCHECK's being enabled for the test, which is possible)

If this DCHECK is compiled out, and new code is written in the host that does
not honor the requested minimum picture count (num_textures <
min_picture_count), the worst that happens is that the client may try to
allocate a larger number of textures than the interface can provide, and the
client ends up waiting on the callback from GetPicture() to complete.
The check I added at line 137 is supposed to restrict the set of values to a
reasonable range.

Without that check, the client can request say MAXINT, causing the host to try
to allocate memory for MAXINT picture frames. That should fail due to running
out of memory, but I certainly didn't expect the host code to handle it
correctly.

However looking back on it now, I'm fairly certain that I need to move the
validation to pepper_video_decoder_host.cc, as I think the client could bypass
the check here. (I saw the other validation here, and so I added it here.)

[bbudge, 2015/08/18 00:48:13]

You definitely have to validate anything you receive from the plugin in the
renderer process. Any validation done in the resource (plugin process) is purely
for convenience and can easily be bypassed by an attacker. Good catch jln.

[bbudge, 2015/08/19 18:47:06]

The DCHECKs here are OK for validating proxy correctness. They aren't a security
check, since this is a message from a more trusted (renderer) process.
'min_picture_count_' is completely under the control of the untrusted process.

   DCHECK(mailboxes.empty() || mailboxes.size() == num_textures);
   std::vector<uint32_t> texture_ids(num_textures);
   if (gles2_impl_) {
     gles2_impl_->GenTextures(num_textures, &texture_ids.front());
     for (uint32_t i = 0; i < num_textures; ++i) {
       gles2_impl_->ActiveTexture(GL_TEXTURE0);
       gles2_impl_->BindTexture(texture_target, texture_ids[i]);
       gles2_impl_->TexParameteri(
           texture_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
       gles2_impl_->TexParameteri(
@@ skipping 182 matching lines @@
     get_picture_0_1_->texture_target = texture_target;
     get_picture_0_1_->texture_size = texture_size;
     get_picture_0_1_ = NULL;
   }
 
   received_pictures_.pop();
 }
 
 }  // namespace proxy
 }  // namespace ppapi