Use macros to define pepper interfaces

ppapi/proxy/ppb_video_capture_proxy.cc

 // Copyright (c) 2011 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_video_capture_proxy.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/dev/ppb_video_capture_dev.h"
 #include "ppapi/c/dev/ppp_video_capture_dev.h"
 #include "ppapi/proxy/enter_proxy.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_buffer_proxy.h"
 #include "ppapi/thunk/ppb_buffer_api.h"
 #include "ppapi/thunk/ppb_buffer_trusted_api.h"
 #include "ppapi/thunk/ppb_video_capture_api.h"
+#include "ppapi/thunk/resource_creation_api.h"
 #include "ppapi/thunk/thunk.h"
 
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Buffer_API;
 using ppapi::thunk::PPB_BufferTrusted_API;
 using ppapi::thunk::PPB_VideoCapture_API;
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
-InterfaceProxy* CreatePPBVideoCaptureProxy(Dispatcher* dispatcher,
-                                           const void* target_interface) {
-  return new PPB_VideoCapture_Proxy(dispatcher, target_interface);
-}
-
-InterfaceProxy* CreatePPPVideoCaptureProxy(Dispatcher* dispatcher,
-                                           const void* target_interface) {
-  return new PPP_VideoCapture_Proxy(dispatcher, target_interface);
+InterfaceProxy* CreatePPPVideoCaptureProxy(Dispatcher* dispatcher) {
+  return new PPP_VideoCapture_Proxy(dispatcher);
 }
 
 void OnDeviceInfo(PP_Instance instance,
                   PP_Resource resource,
                   const PP_VideoCaptureDeviceInfo_Dev* info,
                   uint32_t buffer_count,
                   const PP_Resource* resources) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     return;
   }
   HostResource host_resource;
   host_resource.SetHostResource(instance, resource);
   std::vector<PPPVideoCapture_Buffer> buffers(buffer_count);
   const PPB_Core* core = static_cast<const PPB_Core*>(
-      dispatcher->GetLocalInterface(PPB_CORE_INTERFACE));
+      dispatcher->local_get_interface()(PPB_CORE_INTERFACE));
   DCHECK(core);
   for (uint32_t i = 0; i < buffer_count; ++i) {
     // We need to take a ref on the resource now. The browser may drop
     // references once we return from here, but we're sending an asynchronous
     // message. The plugin side takes ownership of that reference.
     core->AddRefResource(resources[i]);
     buffers[i].resource.SetHostResource(instance, resources[i]);
     {
       EnterResourceNoLock<PPB_Buffer_API> enter(resources[i], true);
       DCHECK(enter.succeeded());
@@ skipping 187 matching lines @@
       status_(PP_VIDEO_CAPTURE_STATUS_STOPPED) {
 }
 
 VideoCapture::~VideoCapture() {
 }
 
 ppapi::thunk::PPB_VideoCapture_API* VideoCapture::AsPPB_VideoCapture_API() {
   return this;
 }
 
-PPB_VideoCapture_Proxy::PPB_VideoCapture_Proxy(Dispatcher* dispatcher,
-                                               const void* target_interface)
-    : InterfaceProxy(dispatcher, target_interface) {
+PPB_VideoCapture_Proxy::PPB_VideoCapture_Proxy(Dispatcher* dispatcher)
+    : InterfaceProxy(dispatcher) {
 }
 
 PPB_VideoCapture_Proxy::~PPB_VideoCapture_Proxy() {
 }
 
 // static
-const InterfaceProxy::Info* PPB_VideoCapture_Proxy::GetInfo() {
-  static const Info info = {
-    ppapi::thunk::GetPPB_VideoCapture_Thunk(),
-    PPB_VIDEO_CAPTURE_DEV_INTERFACE,
-    INTERFACE_ID_PPB_VIDEO_CAPTURE_DEV,
-    false,
-    &CreatePPBVideoCaptureProxy,
-  };
-  return &info;
-}
-
-// static
 PP_Resource PPB_VideoCapture_Proxy::CreateProxyResource(PP_Instance instance) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return 0;
 
   HostResource result;
   dispatcher->Send(new PpapiHostMsg_PPBVideoCapture_Create(
       INTERFACE_ID_PPB_VIDEO_CAPTURE_DEV, instance, &result));
   if (result.is_null())
     return 0;
@@ skipping 11 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVideoCapture_StopCapture,
                         OnMsgStopCapture)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   // TODO(brettw) handle bad messages!
   return handled;
 }
 
 void PPB_VideoCapture_Proxy::OnMsgCreate(PP_Instance instance,
                                          HostResource* result_resource) {
-  HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
-  if (!dispatcher)
-    return;
-  PP_Resource resource = ppb_video_capture_target()->Create(instance);
-  result_resource->SetHostResource(instance, resource);
+  thunk::EnterResourceCreation enter(instance);
+  if (enter.succeeded()) {
+    result_resource->SetHostResource(
+        instance,
+        enter.functions()->CreateVideoCapture(instance));
+  }
 }
 
 void PPB_VideoCapture_Proxy::OnMsgStartCapture(
     const HostResource& resource,
     const PP_VideoCaptureDeviceInfo_Dev& info,
     uint32_t buffers) {
   EnterHostFromHostResource<PPB_VideoCapture_API> enter(resource);
   if (enter.succeeded())
     enter.object()->StartCapture(info, buffers);
 }
 
 void PPB_VideoCapture_Proxy::OnMsgReuseBuffer(const HostResource& resource,
                                               uint32_t buffer) {
   EnterHostFromHostResource<PPB_VideoCapture_API> enter(resource);
   if (enter.succeeded())
     enter.object()->ReuseBuffer(buffer);
 }
 
 void PPB_VideoCapture_Proxy::OnMsgStopCapture(const HostResource& resource) {
   EnterHostFromHostResource<PPB_VideoCapture_API> enter(resource);
   if (enter.succeeded())
     enter.object()->StopCapture();
 }
 
-PPP_VideoCapture_Proxy::PPP_VideoCapture_Proxy(Dispatcher* dispatcher,
-                                               const void* target_interface)
-    : InterfaceProxy(dispatcher, target_interface) {
+PPP_VideoCapture_Proxy::PPP_VideoCapture_Proxy(Dispatcher* dispatcher)
+    : InterfaceProxy(dispatcher),
+      ppp_video_capture_impl_(NULL) {
+  if (dispatcher->IsPlugin()) {
+    ppp_video_capture_impl_ = static_cast<const PPP_VideoCapture_Dev*>(
+        dispatcher->local_get_interface()(PPP_VIDEO_CAPTURE_DEV_INTERFACE));
+  }
 }
 
 PPP_VideoCapture_Proxy::~PPP_VideoCapture_Proxy() {
 }
 
 // static
 const InterfaceProxy::Info* PPP_VideoCapture_Proxy::GetInfo() {
   static const Info info = {
     &ppp_video_capture,
     PPP_VIDEO_CAPTURE_DEV_INTERFACE,
@@ skipping 19 matching lines @@
   return handled;
 }
 
 void PPP_VideoCapture_Proxy::OnMsgOnDeviceInfo(
     const HostResource& host_resource,
     const PP_VideoCaptureDeviceInfo_Dev& info,
     const std::vector<PPPVideoCapture_Buffer>& buffers) {
   EnterPluginFromHostResource<PPB_VideoCapture_API> enter(host_resource);
   PluginResourceTracker* tracker = PluginResourceTracker::GetInstance();
   PP_Resource resource = tracker->PluginResourceForHostResource(host_resource);
-  if (!resource || !ppp_video_capture_target() || enter.failed())
+  if (!resource || !ppp_video_capture_impl_ || enter.failed())
     return;
 
   scoped_array<PP_Resource> resources(new PP_Resource[buffers.size()]);
   for (size_t i = 0; i < buffers.size(); ++i) {
     // We assume that the browser created a new set of resources.
     DCHECK(!tracker->PluginResourceForHostResource(buffers[i].resource));
     resources[i] = PPB_Buffer_Proxy::AddProxyResource(buffers[i].resource,
                                                       buffers[i].handle,
                                                       buffers[i].size);
   }
   static_cast<VideoCapture*>(enter.object())->SetBufferCount(buffers.size());
-  ppp_video_capture_target()->OnDeviceInfo(
+  ppp_video_capture_impl_->OnDeviceInfo(
       host_resource.instance(),
       resource,
       &info,
       buffers.size(),
       resources.get());
   for (size_t i = 0; i < buffers.size(); ++i)
     tracker->ReleaseResource(resources[i]);
 }
 
 void PPP_VideoCapture_Proxy::OnMsgOnStatus(const HostResource& host_resource,
                                            uint32_t status) {
   EnterPluginFromHostResource<PPB_VideoCapture_API> enter(host_resource);
   PluginResourceTracker* tracker = PluginResourceTracker::GetInstance();
   PP_Resource resource = tracker->PluginResourceForHostResource(host_resource);
-  if (!resource || !ppp_video_capture_target() || enter.failed())
+  if (!resource || !ppp_video_capture_impl_ || enter.failed())
     return;
 
   if (!static_cast<VideoCapture*>(enter.object())->OnStatus(status))
     return;
-  ppp_video_capture_target()->OnStatus(
+  ppp_video_capture_impl_->OnStatus(
       host_resource.instance(), resource, status);
 }
 
 void PPP_VideoCapture_Proxy::OnMsgOnError(const HostResource& host_resource,
                                           uint32_t error_code) {
   EnterPluginFromHostResource<PPB_VideoCapture_API> enter(host_resource);
   PluginResourceTracker* tracker = PluginResourceTracker::GetInstance();
   PP_Resource resource = tracker->PluginResourceForHostResource(host_resource);
-  if (!resource || !ppp_video_capture_target() || enter.failed())
+  if (!resource || !ppp_video_capture_impl_ || enter.failed())
     return;
   static_cast<VideoCapture*>(enter.object())->set_status(
       PP_VIDEO_CAPTURE_STATUS_STOPPED);
-  ppp_video_capture_target()->OnError(
+  ppp_video_capture_impl_->OnError(
       host_resource.instance(), resource, error_code);
 }
 
 void PPP_VideoCapture_Proxy::OnMsgOnBufferReady(
     const HostResource& host_resource, uint32_t buffer) {
   EnterPluginFromHostResource<PPB_VideoCapture_API> enter(host_resource);
   PluginResourceTracker* tracker = PluginResourceTracker::GetInstance();
   PP_Resource resource = tracker->PluginResourceForHostResource(host_resource);
-  if (!resource || !ppp_video_capture_target() || enter.failed())
+  if (!resource || !ppp_video_capture_impl_ || enter.failed())
     return;
   static_cast<VideoCapture*>(enter.object())->SetBufferInUse(buffer);
-  ppp_video_capture_target()->OnBufferReady(
+  ppp_video_capture_impl_->OnBufferReady(
       host_resource.instance(), resource, buffer);
 }
 
 }  // namespace proxy
 }  // namespace ppapi