Use macros to define pepper interfaces

ppapi/proxy/ppb_var_deprecated_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_var_deprecated_proxy.h"
 
 #include <stdlib.h>  // For malloc
 
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 270 matching lines @@
   &GetProperty,
   &EnumerateProperties,
   &SetProperty,
   &RemoveProperty,
   &Call,
   &Construct,
   &IsInstanceOf,
   &CreateObject
 };
 
-InterfaceProxy* CreateVarDeprecatedProxy(Dispatcher* dispatcher,
-                                         const void* target_interface) {
-  return new PPB_Var_Deprecated_Proxy(dispatcher, target_interface);
+InterfaceProxy* CreateVarDeprecatedProxy(Dispatcher* dispatcher) {
+  return new PPB_Var_Deprecated_Proxy(dispatcher );
 }
 
 }  // namespace
 
 PPB_Var_Deprecated_Proxy::PPB_Var_Deprecated_Proxy(
-    Dispatcher* dispatcher,
-    const void* target_interface)
-    : InterfaceProxy(dispatcher, target_interface),
-      task_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+    Dispatcher* dispatcher)
+    : InterfaceProxy(dispatcher),
+      task_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      ppb_var_impl_(NULL) {
+  if (!dispatcher->IsPlugin()) {
+    ppb_var_impl_ = static_cast<const PPB_Var_Deprecated*>(
+        dispatcher->local_get_interface()(PPB_VAR_DEPRECATED_INTERFACE));
+  }
 }
 
 PPB_Var_Deprecated_Proxy::~PPB_Var_Deprecated_Proxy() {
 }
 
 // static
 const InterfaceProxy::Info* PPB_Var_Deprecated_Proxy::GetInfo() {
   static const Info info = {
     &var_deprecated_interface,
     PPB_VAR_DEPRECATED_INTERFACE,
@@ skipping 40 matching lines @@
   IPC_END_MESSAGE_MAP()
   // TODO(brettw) handle bad messages!
   return handled;
 }
 
 void PPB_Var_Deprecated_Proxy::OnMsgAddRefObject(int64 object_id,
                                                  int* /* unused */) {
   PP_Var var;
   var.type = PP_VARTYPE_OBJECT;
   var.value.as_id = object_id;
-  ppb_var_target()->AddRef(var);
+  ppb_var_impl_->AddRef(var);
 }
 
 void PPB_Var_Deprecated_Proxy::OnMsgReleaseObject(int64 object_id) {
   // Ok, so this is super subtle.
   // When the browser side sends a sync IPC message that returns a var, and the
   // plugin wants to give ownership of that var to the browser, dropping all
   // references, it may call ReleaseObject right after returning the result.
   // However, the IPC system doesn't enforce strict ordering of messages in that
   // case, where a message that is set to unblock (e.g. a sync message, or in
   // our case all messages coming from the plugin) that is sent *after* the
@@ skipping 12 matching lines @@
       task_factory_.NewRunnableMethod(
           &PPB_Var_Deprecated_Proxy::DoReleaseObject, object_id));
 }
 
 void PPB_Var_Deprecated_Proxy::OnMsgHasProperty(
     SerializedVarReceiveInput var,
     SerializedVarReceiveInput name,
     SerializedVarOutParam exception,
     PP_Bool* result) {
   SetAllowPluginReentrancy();
-  *result = PP_FromBool(ppb_var_target()->HasProperty(
+  *result = PP_FromBool(ppb_var_impl_->HasProperty(
       var.Get(dispatcher()),
       name.Get(dispatcher()),
       exception.OutParam(dispatcher())));
 }
 
 void PPB_Var_Deprecated_Proxy::OnMsgHasMethodDeprecated(
     SerializedVarReceiveInput var,
     SerializedVarReceiveInput name,
     SerializedVarOutParam exception,
     PP_Bool* result) {
   SetAllowPluginReentrancy();
-  *result = PP_FromBool(ppb_var_target()->HasMethod(
+  *result = PP_FromBool(ppb_var_impl_->HasMethod(
       var.Get(dispatcher()),
       name.Get(dispatcher()),
       exception.OutParam(dispatcher())));
 }
 
 void PPB_Var_Deprecated_Proxy::OnMsgGetProperty(
     SerializedVarReceiveInput var,
     SerializedVarReceiveInput name,
     SerializedVarOutParam exception,
     SerializedVarReturnValue result) {
   SetAllowPluginReentrancy();
-  result.Return(dispatcher(), ppb_var_target()->GetProperty(
+  result.Return(dispatcher(), ppb_var_impl_->GetProperty(
       var.Get(dispatcher()), name.Get(dispatcher()),
       exception.OutParam(dispatcher())));
 }
 
 void PPB_Var_Deprecated_Proxy::OnMsgEnumerateProperties(
     SerializedVarReceiveInput var,
     SerializedVarVectorOutParam props,
     SerializedVarOutParam exception) {
   SetAllowPluginReentrancy();
-  ppb_var_target()->GetAllPropertyNames(var.Get(dispatcher()),
+  ppb_var_impl_->GetAllPropertyNames(var.Get(dispatcher()),
       props.CountOutParam(), props.ArrayOutParam(dispatcher()),
       exception.OutParam(dispatcher()));
 }
 
 void PPB_Var_Deprecated_Proxy::OnMsgSetPropertyDeprecated(
     SerializedVarReceiveInput var,
     SerializedVarReceiveInput name,
     SerializedVarReceiveInput value,
     SerializedVarOutParam exception) {
   SetAllowPluginReentrancy();
-  ppb_var_target()->SetProperty(var.Get(dispatcher()),
+  ppb_var_impl_->SetProperty(var.Get(dispatcher()),
                                 name.Get(dispatcher()),
                                 value.Get(dispatcher()),
                                 exception.OutParam(dispatcher()));
 }
 
 void PPB_Var_Deprecated_Proxy::OnMsgDeleteProperty(
     SerializedVarReceiveInput var,
     SerializedVarReceiveInput name,
     SerializedVarOutParam exception,
     PP_Bool* result) {
   SetAllowPluginReentrancy();
-  ppb_var_target()->RemoveProperty(var.Get(dispatcher()),
+  ppb_var_impl_->RemoveProperty(var.Get(dispatcher()),
                                    name.Get(dispatcher()),
                                    exception.OutParam(dispatcher()));
   // This deprecated function doesn't actually return a value, but we re-use
   // the message from the non-deprecated interface with the return value.
   *result = PP_TRUE;
 }
 
 void PPB_Var_Deprecated_Proxy::OnMsgCallDeprecated(
     SerializedVarReceiveInput object,
     SerializedVarReceiveInput method_name,
     SerializedVarVectorReceiveInput arg_vector,
     SerializedVarOutParam exception,
     SerializedVarReturnValue result) {
   SetAllowPluginReentrancy();
   uint32_t arg_count = 0;
   PP_Var* args = arg_vector.Get(dispatcher(), &arg_count);
-  result.Return(dispatcher(), ppb_var_target()->Call(
+  result.Return(dispatcher(), ppb_var_impl_->Call(
       object.Get(dispatcher()),
       method_name.Get(dispatcher()),
       arg_count, args,
       exception.OutParam(dispatcher())));
 }
 
 void PPB_Var_Deprecated_Proxy::OnMsgConstruct(
     SerializedVarReceiveInput var,
     SerializedVarVectorReceiveInput arg_vector,
     SerializedVarOutParam exception,
     SerializedVarReturnValue result) {
   SetAllowPluginReentrancy();
   uint32_t arg_count = 0;
   PP_Var* args = arg_vector.Get(dispatcher(), &arg_count);
-  result.Return(dispatcher(), ppb_var_target()->Construct(
+  result.Return(dispatcher(), ppb_var_impl_->Construct(
       var.Get(dispatcher()), arg_count, args,
       exception.OutParam(dispatcher())));
 }
 
 void PPB_Var_Deprecated_Proxy::OnMsgIsInstanceOfDeprecated(
     SerializedVarReceiveInput var,
     int64 ppp_class,
     int64* ppp_class_data,
     PP_Bool* result) {
   // TODO(brettw) write this.
 }
 
 void PPB_Var_Deprecated_Proxy::OnMsgCreateObjectDeprecated(
     PP_Instance instance,
     int64 ppp_class,
     int64 class_data,
     SerializedVarReturnValue result) {
   SetAllowPluginReentrancy();
   result.Return(dispatcher(), PPP_Class_Proxy::CreateProxiedObject(
-      ppb_var_target(), dispatcher(), instance, ppp_class, class_data));
+      ppb_var_impl_, dispatcher(), instance, ppp_class, class_data));
 }
 
 void PPB_Var_Deprecated_Proxy::SetAllowPluginReentrancy() {
   if (dispatcher()->IsPlugin())
     NOTREACHED();
   else
     static_cast<HostDispatcher*>(dispatcher())->set_allow_plugin_reentrancy();
 }
 
 void PPB_Var_Deprecated_Proxy::DoReleaseObject(int64 object_id) {
   PP_Var var;
   var.type = PP_VARTYPE_OBJECT;
   var.value.as_id = object_id;
-  ppb_var_target()->Release(var);
+  ppb_var_impl_->Release(var);
 }
 
 }  // namespace proxy
 }  // namespace ppapi