Implement software fallback for PPB_VideoDecoder.

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"
 #include "ipc/ipc_message.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_opengles2.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_graphics_3d_proxy.h"
 #include "ppapi/proxy/serialized_handle.h"
 #include "ppapi/proxy/video_decoder_constants.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/ppb_graphics_3d_shared.h"
@@ skipping 85 matching lines @@
     // 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(),
-                                                           true);
+                                                           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;
@@ skipping 199 matching lines @@
 }
 
 void VideoDecoderResource::SetForTest() {
   testing_ = true;
 }
 
 void VideoDecoderResource::OnPluginMsgRequestTextures(
     const ResourceMessageReplyParams& params,
     uint32_t num_textures,
     const PP_Size& size,
-    uint32_t texture_target) {
+    uint32_t texture_target,
+    const std::vector<gpu::Mailbox>& mailboxes) {
   DCHECK(num_textures);
+  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_NEAREST);
       gles2_impl_->TexParameteri(
           texture_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
       gles2_impl_->TexParameterf(
           texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
       gles2_impl_->TexParameterf(
           texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
       if (texture_target == GL_TEXTURE_2D) {
         gles2_impl_->TexImage2D(texture_target,
                                 0,
                                 GL_RGBA,
                                 size.width,
                                 size.height,
                                 0,
                                 GL_RGBA,
                                 GL_UNSIGNED_BYTE,
                                 NULL);
       }
+      if (!mailboxes.empty()) {
+        gles2_impl_->ProduceTextureCHROMIUM(
+            GL_TEXTURE_2D, reinterpret_cast<const GLbyte*>(mailboxes[i].name));
+      }
 
       textures_.insert(
           std::make_pair(texture_ids[i], Texture(texture_target, size)));
     }
     gles2_impl_->Flush();
   } else {
     DCHECK(testing_);
     // Create some fake texture ids so we can test picture handling.
     for (uint32_t i = 0; i < num_textures; ++i) {
       texture_ids[i] = i + 1;
@@ skipping 124 matching lines @@
     pp_picture->texture_target = it->second.texture_target;
     pp_picture->texture_size = it->second.size;
   } else {
     NOTREACHED();
   }
   received_pictures_.pop();
 }
 
 }  // namespace proxy
 }  // namespace ppapi