Use macros to define pepper interfaces

ppapi/proxy/ppb_instance_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_instance_proxy.h"
 
 #include "ppapi/c/dev/ppb_fullscreen_dev.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_instance.h"
 #include "ppapi/c/ppb_messaging.h"
@@ skipping 12 matching lines @@
 
 using ppapi::thunk::EnterFunctionNoLock;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Instance_FunctionAPI;
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
-InterfaceProxy* CreateInstanceProxy(Dispatcher* dispatcher,
-                                    const void* target_interface) {
-  return new PPB_Instance_Proxy(dispatcher, target_interface);
+typedef EnterFunctionNoLock<PPB_Instance_FunctionAPI> EnterInstanceNoLock;
+
+InterfaceProxy* CreateInstanceProxy(Dispatcher* dispatcher) {
+  return new PPB_Instance_Proxy(dispatcher);
 }
 
 }  // namespace
 
-PPB_Instance_Proxy::PPB_Instance_Proxy(Dispatcher* dispatcher,
-                                       const void* target_interface)
-    : InterfaceProxy(dispatcher, target_interface) {
+PPB_Instance_Proxy::PPB_Instance_Proxy(Dispatcher* dispatcher)
+    : InterfaceProxy(dispatcher) {
 }
 
 PPB_Instance_Proxy::~PPB_Instance_Proxy() {
 }
 
 // static
-const InterfaceProxy::Info* PPB_Instance_Proxy::GetInfo0_5() {
-  static const Info info = {
-    ppapi::thunk::GetPPB_Instance_1_0_Thunk(),
-    PPB_INSTANCE_INTERFACE_0_5,
-    INTERFACE_ID_NONE,  // 1_0 is the canonical one.
-    false,
-    &CreateInstanceProxy,
-  };
-  return &info;
-}
-
-// static
-const InterfaceProxy::Info* PPB_Instance_Proxy::GetInfo1_0() {
-  static const Info info = {
-    ppapi::thunk::GetPPB_Instance_1_0_Thunk(),
-    PPB_INSTANCE_INTERFACE_1_0,
-    INTERFACE_ID_PPB_INSTANCE,
-    false,
-    &CreateInstanceProxy,
-  };
-  return &info;
-}
-
-// static
-const InterfaceProxy::Info* PPB_Instance_Proxy::GetInfoMessaging() {
-  static const Info info = {
-    ppapi::thunk::GetPPB_Messaging_Thunk(),
-    PPB_MESSAGING_INTERFACE,
-    INTERFACE_ID_NONE,  // 1_0 is the canonical one.
-    false,
-    &CreateInstanceProxy,
-  };
-  return &info;
-}
-
-// static
 const InterfaceProxy::Info* PPB_Instance_Proxy::GetInfoPrivate() {
   static const Info info = {
     ppapi::thunk::GetPPB_Instance_Private_Thunk(),
     PPB_INSTANCE_PRIVATE_INTERFACE,
     INTERFACE_ID_NONE,  // 1_0 is the canonical one.
     false,
     &CreateInstanceProxy,
   };
   return &info;
 }
@@ skipping 22 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetWindowObject,
                         OnMsgGetWindowObject)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetOwnerElementObject,
                         OnMsgGetOwnerElementObject)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_BindGraphics,
                         OnMsgBindGraphics)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_IsFullFrame,
                         OnMsgIsFullFrame)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ExecuteScript,
                         OnMsgExecuteScript)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_Log,
+                        OnMsgLog)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_LogWithSource,
+                        OnMsgLogWithSource)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PostMessage,
                         OnMsgPostMessage)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetFullscreen,
                         OnMsgSetFullscreen)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetScreenSize,
                         OnMsgGetScreenSize)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_RequestInputEvents,
                         OnMsgRequestInputEvents)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ClearInputEvents,
                         OnMsgClearInputEvents)
@@ skipping 47 matching lines @@
   if (se.IsThrown())
     return PP_MakeUndefined();
 
   ReceiveSerializedVarReturnValue result;
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_ExecuteScript(
       INTERFACE_ID_PPB_INSTANCE, instance,
       SerializedVarSendInput(dispatcher(), script), &se, &result));
   return result.Return(dispatcher());
 }
 
+void PPB_Instance_Proxy::Log(PP_Instance instance,
+                             int log_level,
+                             PP_Var value) {
+  dispatcher()->Send(new PpapiHostMsg_PPBInstance_Log(
+      INTERFACE_ID_PPB_INSTANCE, instance, static_cast<int>(log_level),
+      SerializedVarSendInput(dispatcher(), value)));
+}
+
+void PPB_Instance_Proxy::LogWithSource(PP_Instance instance,
+                                       int log_level,
+                                       PP_Var source,
+                                       PP_Var value) {
+  dispatcher()->Send(new PpapiHostMsg_PPBInstance_LogWithSource(
+      INTERFACE_ID_PPB_INSTANCE, instance, static_cast<int>(log_level),
+      SerializedVarSendInput(dispatcher(), source),
+      SerializedVarSendInput(dispatcher(), value)));
+}
+
 PP_Bool PPB_Instance_Proxy::IsFullscreen(PP_Instance instance) {
   InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
       GetInstanceData(instance);
   if (!data)
     return PP_FALSE;
   return data->fullscreen;
 }
 
 PP_Bool PPB_Instance_Proxy::SetFullscreen(PP_Instance instance,
                                           PP_Bool fullscreen) {
@@ skipping 61 matching lines @@
 void PPB_Instance_Proxy::PostMessage(PP_Instance instance,
                                      PP_Var message) {
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_PostMessage(
       INTERFACE_ID_PPB_INSTANCE,
       instance, SerializedVarSendInput(dispatcher(), message)));
 }
 
 void PPB_Instance_Proxy::OnMsgGetWindowObject(
     PP_Instance instance,
     SerializedVarReturnValue result) {
-  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
+  EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded())
     result.Return(dispatcher(), enter.functions()->GetWindowObject(instance));
 }
 
 void PPB_Instance_Proxy::OnMsgGetOwnerElementObject(
     PP_Instance instance,
     SerializedVarReturnValue result) {
-  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
+  EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded()) {
     result.Return(dispatcher(),
                   enter.functions()->GetOwnerElementObject(instance));
   }
 }
 
 void PPB_Instance_Proxy::OnMsgBindGraphics(PP_Instance instance,
                                            const HostResource& device,
                                            PP_Bool* result) {
-  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
+  EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded()) {
     *result = enter.functions()->BindGraphics(instance,
                                               device.host_resource());
   }
 }
 
 void PPB_Instance_Proxy::OnMsgIsFullFrame(PP_Instance instance,
                                           PP_Bool* result) {
-  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
+  EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded())
     *result = enter.functions()->IsFullFrame(instance);
 }
 
 void PPB_Instance_Proxy::OnMsgExecuteScript(
     PP_Instance instance,
     SerializedVarReceiveInput script,
     SerializedVarOutParam out_exception,
     SerializedVarReturnValue result) {
-  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
+  EnterInstanceNoLock enter(instance, false);
   if (enter.failed())
     return;
 
   if (dispatcher()->IsPlugin())
     NOTREACHED();
   else
     static_cast<HostDispatcher*>(dispatcher())->set_allow_plugin_reentrancy();
 
   result.Return(dispatcher(), enter.functions()->ExecuteScript(
       instance,
       script.Get(dispatcher()),
       out_exception.OutParam(dispatcher())));
 }
 
+void PPB_Instance_Proxy::OnMsgLog(PP_Instance instance,
+                                  int log_level,
+                                  SerializedVarReceiveInput value) {
+  EnterInstanceNoLock enter(instance, false);
+  if (enter.succeeded())
+    enter.functions()->Log(instance, log_level, value.Get(dispatcher()));
+}
+
+void PPB_Instance_Proxy::OnMsgLogWithSource(PP_Instance instance,
+                                            int log_level,
+                                            SerializedVarReceiveInput source,
+                                            SerializedVarReceiveInput value) {
+  EnterInstanceNoLock enter(instance, false);
+  if (enter.succeeded()) {
+    enter.functions()->LogWithSource(instance, log_level,
+                                     source.Get(dispatcher()),
+                                     value.Get(dispatcher()));
+  }
+}
+
 void PPB_Instance_Proxy::OnMsgSetFullscreen(PP_Instance instance,
                                             PP_Bool fullscreen,
                                             PP_Bool* result) {
-  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
+  EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded())
     *result = enter.functions()->SetFullscreen(instance, fullscreen);
 }
 
 void PPB_Instance_Proxy::OnMsgGetScreenSize(PP_Instance instance,
                                             PP_Bool* result,
                                             PP_Size* size) {
-  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
+  EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded())
     *result = enter.functions()->GetScreenSize(instance, size);
 }
 
 void PPB_Instance_Proxy::OnMsgRequestInputEvents(PP_Instance instance,
                                                  bool is_filtering,
                                                  uint32_t event_classes) {
-  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
+  EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded()) {
     if (is_filtering)
       enter.functions()->RequestFilteringInputEvents(instance, event_classes);
     else
       enter.functions()->RequestInputEvents(instance, event_classes);
   }
 }
 
 void PPB_Instance_Proxy::OnMsgClearInputEvents(PP_Instance instance,
                                                uint32_t event_classes) {
-  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
+  EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded())
     enter.functions()->ClearInputEventRequest(instance, event_classes);
 }
 
 void PPB_Instance_Proxy::OnMsgPostMessage(PP_Instance instance,
                                           SerializedVarReceiveInput message) {
-  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
+  EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded())
     enter.functions()->PostMessage(instance, message.Get(dispatcher()));
 }
 
 }  // namespace proxy
 }  // namespace ppapi