Add Pepper VideoReader and VideoWriter plumbing

ppapi/proxy/ppb_image_data_proxy.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/ppb_image_data_proxy.h"
 
 #include <string.h>  // For memcpy
 
 #include <map>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/memory/weak_ptr.h"
 #include "build/build_config.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/proxy/enter_proxy.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_globals.h"
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/host_resource.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/resource.h"
+#include "ppapi/shared_impl/scoped_pp_resource.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/thunk.h"
 
 #if !defined(OS_NACL)
 #include "skia/ext/platform_canvas.h"
 #include "ui/surface/transport_dib.h"
 #endif
 
 using ppapi::thunk::PPB_ImageData_API;
 
@@ skipping 492 matching lines @@
     IPC::PlatformFileForTransit* image_handle,
     uint32_t* byte_count) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return 0;
 
   thunk::EnterResourceCreation enter(instance);
   if (enter.failed())
     return 0;
 
-  PP_Resource result = 0;
-  PP_Bool clear = init_to_zero ? PP_TRUE : PP_FALSE;
-  if (is_nacl_plugin) {
-    result = enter.functions()->CreateImageDataNaCl(
-        instance, static_cast<PP_ImageDataFormat>(format), &size, clear);
-  } else {
-    result = enter.functions()->CreateImageData(
-        instance, static_cast<PP_ImageDataFormat>(format), &size, clear);
-  }
-  if (!result)
+  PP_Bool pp_init_to_zero = init_to_zero ? PP_TRUE : PP_FALSE;
+  ppapi::ScopedPPResource resource(
+      ppapi::ScopedPPResource::PassRef(),
+      is_nacl_plugin ?
+          enter.functions()->CreateImageDataNaCl(instance, format, &size,
+                                                 pp_init_to_zero) :
+          enter.functions()->CreateImageData(instance, format, &size,
+                                             pp_init_to_zero));
+  if (!resource.get())
     return 0;
 
-  thunk::EnterResourceNoLock<PPB_ImageData_API> enter_resource(result, false);
-  if (enter_resource.object()->Describe(desc) != PP_TRUE)
+  thunk::EnterResourceNoLock<PPB_ImageData_API> enter_resource(resource.get(),
+                                                               false);
+  if (enter_resource.object()->Describe(desc) != PP_TRUE) {
     DVLOG(1) << "CreateImageData failed: could not Describe";
+    return 0;
+  }
 
   int local_fd = 0;
-  if (enter_resource.object()->GetSharedMemory(&local_fd, byte_count) != PP_OK)
+  if (enter_resource.object()->GetSharedMemory(&local_fd,
+                                               byte_count) != PP_OK) {
     DVLOG(1) << "CreateImageData failed: could not GetSharedMemory";
+    return 0;
+  }
 
 #if defined(OS_WIN)
   *image_handle = dispatcher->ShareHandleWithRemote(
       reinterpret_cast<HANDLE>(static_cast<intptr_t>(local_fd)), false);
 #elif defined(OS_MACOSX) || defined(OS_ANDROID)
   *image_handle = dispatcher->ShareHandleWithRemote(local_fd, false);
 #elif defined(OS_POSIX)
   // On X Windows, a non-nacl handle is a SysV shared memory key.
   if (is_nacl_plugin)
     *image_handle = dispatcher->ShareHandleWithRemote(local_fd, false);
   else
     *image_handle = IPC::PlatformFileForTransit(local_fd, false);
 #else
   #error Not implemented.
 #endif
 
-  return result;
+  return resource.Release();
 }
 
 void PPB_ImageData_Proxy::OnHostMsgCreate(PP_Instance instance,
                                           int32_t format,
                                           const PP_Size& size,
                                           PP_Bool init_to_zero,
                                           HostResource* result,
                                           std::string* image_data_desc,
                                           ImageHandle* result_image_handle) {
   PP_ImageDataDesc desc;
   IPC::PlatformFileForTransit image_handle;
   uint32_t byte_count;
-  PP_Resource resource = CreateImageData(
-                             instance,
-                             static_cast<PP_ImageDataFormat>(format),
-                             size,
-                             true /* init_to_zero */,
-                             false /* is_nacl_plugin */,
-                             &desc, &image_handle, &byte_count);
+  PP_Resource resource =
+      CreateImageData(instance,
+                      static_cast<PP_ImageDataFormat>(format),
+                      size,
+                      true /* init_to_zero */,
+                      false /* is_nacl_plugin */,
+                      &desc, &image_handle, &byte_count);
   result->SetHostResource(instance, resource);
   if (resource) {
     image_data_desc->resize(sizeof(PP_ImageDataDesc));
     memcpy(&(*image_data_desc)[0], &desc, sizeof(PP_ImageDataDesc));
 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_ANDROID)
     *result_image_handle = image_handle;
 #else
     // On X Windows ImageHandle is a SysV shared memory key.
     *result_image_handle = image_handle.fd;
 #endif
   } else {
     image_data_desc->clear();
     *result_image_handle = ImageData::NullHandle();
   }
 }
 
 void PPB_ImageData_Proxy::OnHostMsgCreateNaCl(
     PP_Instance instance,
     int32_t format,
     const PP_Size& size,
     PP_Bool init_to_zero,
     HostResource* result,
     std::string* image_data_desc,
     ppapi::proxy::SerializedHandle* result_image_handle) {
   PP_ImageDataDesc desc;
   IPC::PlatformFileForTransit image_handle;
   uint32_t byte_count;
-  PP_Resource resource = CreateImageData(
-                             instance,
-                             static_cast<PP_ImageDataFormat>(format),
-                             size,
-                             true /* init_to_zero */,
-                             true /* is_nacl_plugin */,
-                             &desc, &image_handle, &byte_count);
+  PP_Resource resource =
+      CreateImageData(instance,
+                      static_cast<PP_ImageDataFormat>(format),
+                      size,
+                      true /* init_to_zero */,
+                      true /* is_nacl_plugin */,
+                      &desc, &image_handle, &byte_count);
 
   result->SetHostResource(instance, resource);
   if (resource) {
     image_data_desc->resize(sizeof(PP_ImageDataDesc));
     memcpy(&(*image_data_desc)[0], &desc, sizeof(PP_ImageDataDesc));
     result_image_handle->set_shmem(image_handle, byte_count);
   } else {
     image_data_desc->clear();
     result_image_handle->set_null_shmem();
   }
@@ skipping 17 matching lines @@
   // still cached in our process, the proxy still holds a reference so we can
   // remove the one the renderer just sent is. If the proxy no longer holds a
   // reference, we released everything and we should also release the one the
   // renderer just sent us.
   dispatcher()->Send(new PpapiHostMsg_PPBCore_ReleaseResource(
       API_ID_PPB_CORE, old_image_data));
 }
 
 }  // namespace proxy
 }  // namespace ppapi