Add NaCl proxies for Pepper Video Source and Destination resources.

content/renderer/pepper/pepper_video_source_host.cc

 // 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.
 
 #include "content/renderer/pepper/pepper_video_source_host.h"
 
 #include "base/bind.h"
 #include "base/safe_numerics.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "content/renderer/render_thread_impl.h"
@@ skipping 88 matching lines @@
     return PP_ERROR_BADARGUMENT;
 
   stream_url_ = gurl.spec();
 
   ReplyMessageContext reply_context = context->MakeReplyMessageContext();
   reply_context.params.set_result(PP_OK);
   host()->SendReply(reply_context, PpapiPluginMsg_VideoSource_OpenReply());
   return PP_OK_COMPLETIONPENDING;
 }
 
-int32_t PepperVideoSourceHost::OnHostMsgGetFrame(
-    HostMessageContext* context) {
+int32_t PepperVideoSourceHost::OnHostMsgGetFrame(HostMessageContext* context) {
   if (!source_handler_.get())
     return PP_ERROR_FAILED;
   if (get_frame_pending_)
     return PP_ERROR_INPROGRESS;
 
   reply_context_ = context->MakeReplyMessageContext();
   get_frame_pending_ = true;
 
   // If a frame is ready, try to convert it and send the reply.
   if (last_frame_.get())
     SendGetFrameReply();
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PepperVideoSourceHost::OnHostMsgClose(HostMessageContext* context) {
   Close();
   return PP_OK;
 }
 
 void PepperVideoSourceHost::SendGetFrameReply() {
   DCHECK(get_frame_pending_);
   get_frame_pending_ = false;
 
   DCHECK(last_frame_.get());
   scoped_ptr<cricket::VideoFrame> frame(last_frame_.release());
 
   int32_t width = base::checked_numeric_cast<int32_t>(frame->GetWidth());
   int32_t height = base::checked_numeric_cast<int32_t>(frame->GetHeight());
-  // Create an image data resource to hold the frame pixels.
   PP_ImageDataDesc image_desc;
   IPC::PlatformFileForTransit image_handle;
   uint32_t byte_count;
   ppapi::ScopedPPResource resource(
       ppapi::ScopedPPResource::PassRef(),
       ppapi::proxy::PPB_ImageData_Proxy::CreateImageData(
           pp_instance(),
-          ppapi::PPB_ImageData_Shared::PLATFORM,
+          ppapi::PPB_ImageData_Shared::SIMPLE,
           PP_IMAGEDATAFORMAT_BGRA_PREMUL,
           PP_MakeSize(width, height),
           false /* init_to_zero */,
           &image_desc, &image_handle, &byte_count));
   if (!resource.get()) {
     SendGetFrameErrorReply(PP_ERROR_FAILED);
     return;
   }
 
   ppapi::thunk::EnterResourceNoLock<ppapi::thunk::PPB_ImageData_API>
@@ skipping 31 matching lines @@
   ppapi::HostResource host_resource;
   host_resource.SetHostResource(pp_instance(), resource.get());
 
   // Convert a video timestamp (int64, in nanoseconds) to a time delta (int64,
   // microseconds) and then to a PP_TimeTicks (a double, in seconds). All times
   // are relative to the Unix Epoch.
   base::TimeDelta time_delta = base::TimeDelta::FromMicroseconds(
       frame->GetTimeStamp() / base::Time::kNanosecondsPerMicrosecond);
   PP_TimeTicks timestamp = time_delta.InSecondsF();
 
-  reply_context_.params.set_result(PP_OK);
-
-#if defined(TOOLKIT_GTK)
-  // For GTK, we pass the SysV shared memory key in the message.
-  PpapiPluginMsg_VideoSource_GetFrameReply reply_msg(host_resource,
-                                                     image_desc,
-                                                     image_handle.fd,
-                                                     timestamp);
-#elif defined(OS_POSIX) || defined(OS_WIN)
   ppapi::proxy::SerializedHandle serialized_handle;
-  PpapiPluginMsg_VideoSource_GetFrameReply reply_msg(host_resource,
-                                                     image_desc,
-                                                     0,
-                                                     timestamp);
   serialized_handle.set_shmem(image_handle, byte_count);
   reply_context_.params.AppendHandle(serialized_handle);
-#else
-  // Not supported on other platforms.
-  // This is a stub reply_msg to not break the build.
-  PpapiPluginMsg_VideoSource_GetFrameReply reply_msg(host_resource,
-                                                     image_desc,
-                                                     0,
-                                                     timestamp);
-  NOTIMPLEMENTED();
-  SendGetFrameErrorReply(PP_ERROR_NOTSUPPORTED);
-  return;
-#endif
 
-  host()->SendReply(reply_context_, reply_msg);
+  host()->SendReply(reply_context_,
+                    PpapiPluginMsg_VideoSource_GetFrameReply(host_resource,
+                                                             image_desc,
+                                                             timestamp));
 
   reply_context_ = ppapi::host::ReplyMessageContext();
 
   // Keep a reference once we know this method succeeds.
   resource.Release();
 }
 
 void PepperVideoSourceHost::SendGetFrameErrorReply(int32_t error) {
   reply_context_.params.set_result(error);
   host()->SendReply(
       reply_context_,
-      PpapiPluginMsg_VideoSource_GetFrameReply(
-          ppapi::HostResource(), PP_ImageDataDesc(), -1, 0.0));
+      PpapiPluginMsg_VideoSource_GetFrameReply(ppapi::HostResource(),
+                                               PP_ImageDataDesc(),
+                                               0.0 /* timestamp */));
   reply_context_ = ppapi::host::ReplyMessageContext();
 }
 
 void PepperVideoSourceHost::Close() {
   if (source_handler_.get() && !stream_url_.empty())
     source_handler_->Close(stream_url_, frame_receiver_.get());
 
   source_handler_.reset(NULL);
   stream_url_.clear();
 }
 
 }  // namespace content