Use macros to define pepper interfaces

ppapi/proxy/ppb_flash_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_flash_proxy.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "ppapi/c/dev/ppb_font_dev.h"
 #include "ppapi/c/dev/ppb_var_deprecated.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/private/ppb_flash.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/proxy_module.h"
 #include "ppapi/proxy/serialized_var.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/shared_impl/scoped_pp_resource.h"
+#include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_url_request_info_api.h"
 #include "ppapi/thunk/resource_creation_api.h"
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 void SetInstanceAlwaysOnTop(PP_Instance pp_instance, PP_Bool on_top) {
@@ skipping 112 matching lines @@
   //
   // On Linux, it would be better to go directly to the browser process for
   // this message rather than proxy it through some instance in a renderer.
   double result = 0;
   dispatcher->Send(new PpapiHostMsg_PPBFlash_GetLocalTimeZoneOffset(
       INTERFACE_ID_PPB_FLASH, instance, t, &result));
   return result;
 }
 
 PP_Var GetCommandLineArgs(PP_Module pp_module) {
-  const PPB_Var_Deprecated* var_deprecated =
-      static_cast<const PPB_Var_Deprecated*>(
-          PluginDispatcher::GetInterfaceFromDispatcher(
-              PPB_VAR_DEPRECATED_INTERFACE));
   std::string args = ProxyModule::GetInstance()->GetFlashCommandLineArgs();
-  return var_deprecated->VarFromUtf8(pp_module, args.data(), args.length());
+  return StringVar::StringToPPVar(pp_module, args);
 }
 
 const PPB_Flash flash_interface = {
   &SetInstanceAlwaysOnTop,
   &DrawGlyphs,
   &GetProxyForURL,
   &Navigate,
   &RunMessageLoop,
   &QuitMessageLoop,
   &GetLocalTimeZoneOffset,
   &GetCommandLineArgs
 };
 
-InterfaceProxy* CreateFlashProxy(Dispatcher* dispatcher,
-                                 const void* target_interface) {
-  return new PPB_Flash_Proxy(dispatcher, target_interface);
+InterfaceProxy* CreateFlashProxy(Dispatcher* dispatcher) {
+  return new PPB_Flash_Proxy(dispatcher);
 }
 
 }  // namespace
 
-PPB_Flash_Proxy::PPB_Flash_Proxy(Dispatcher* dispatcher,
-                                 const void* target_interface)
-    : InterfaceProxy(dispatcher, target_interface) {
+PPB_Flash_Proxy::PPB_Flash_Proxy(Dispatcher* dispatcher)
+    : InterfaceProxy(dispatcher),
+      ppb_flash_impl_(NULL) {
+  if (!dispatcher->IsPlugin())
+    ppb_flash_impl_ = static_cast<const PPB_Flash*>(
+        dispatcher->local_get_interface()(PPB_FLASH_INTERFACE));
 }
 
 PPB_Flash_Proxy::~PPB_Flash_Proxy() {
 }
 
 // static
 const InterfaceProxy::Info* PPB_Flash_Proxy::GetInfo() {
   static const Info info = {
     &flash_interface,
     PPB_FLASH_INTERFACE,
@@ skipping 27 matching lines @@
                         OnMsgGetLocalTimeZoneOffset)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   // TODO(brettw) handle bad messages!
   return handled;
 }
 
 void PPB_Flash_Proxy::OnMsgSetInstanceAlwaysOnTop(
     PP_Instance instance,
     PP_Bool on_top) {
-  ppb_flash_target()->SetInstanceAlwaysOnTop(instance, on_top);
+  ppb_flash_impl_->SetInstanceAlwaysOnTop(instance, on_top);
 }
 
 void PPB_Flash_Proxy::OnMsgDrawGlyphs(const PPBFlash_DrawGlyphs_Params& params,
                                       PP_Bool* result) {
   *result = PP_FALSE;
 
   PP_FontDescription_Dev font_desc;
   params.font_desc.SetToPPFontDescription(dispatcher(), &font_desc, false);
 
   if (params.glyph_indices.size() != params.glyph_advances.size() ||
       params.glyph_indices.empty())
     return;
 
-  *result = ppb_flash_target()->DrawGlyphs(
+  *result = ppb_flash_impl_->DrawGlyphs(
       0,  // Unused instance param.
       params.image_data.host_resource(), &font_desc,
       params.color, params.position, params.clip,
       const_cast<float(*)[3]>(params.transformation),
       static_cast<uint32_t>(params.glyph_indices.size()),
       const_cast<uint16_t*>(&params.glyph_indices[0]),
       const_cast<PP_Point*>(&params.glyph_advances[0]));
 }
 
 void PPB_Flash_Proxy::OnMsgGetProxyForURL(PP_Instance instance,
                                           const std::string& url,
                                           SerializedVarReturnValue result) {
-  result.Return(dispatcher(), ppb_flash_target()->GetProxyForURL(
+  result.Return(dispatcher(), ppb_flash_impl_->GetProxyForURL(
       instance, url.c_str()));
 }
 
 void PPB_Flash_Proxy::OnMsgNavigate(PP_Instance instance,
                                     const PPB_URLRequestInfo_Data& data,
                                     const std::string& target,
                                     bool from_user_action,
                                     int32_t* result) {
   DCHECK(!dispatcher()->IsPlugin());
 
@@ skipping 16 matching lines @@
   // Make a temporary request resource.
   thunk::EnterFunctionNoLock<thunk::ResourceCreationAPI> enter(instance, true);
   if (enter.failed()) {
     *result = PP_ERROR_FAILED;
     return;
   }
   ScopedPPResource request_resource(
       ScopedPPResource::PassRef(),
       enter.functions()->CreateURLRequestInfo(instance, data));
 
-  *result = ppb_flash_target()->Navigate(request_resource,
-                                         target.c_str(),
-                                         from_user_action);
+  *result = ppb_flash_impl_->Navigate(request_resource,
+                                      target.c_str(),
+                                      from_user_action);
 }
 
 void PPB_Flash_Proxy::OnMsgRunMessageLoop(PP_Instance instance) {
-  ppb_flash_target()->RunMessageLoop(instance);
+  ppb_flash_impl_->RunMessageLoop(instance);
 }
 
 void PPB_Flash_Proxy::OnMsgQuitMessageLoop(PP_Instance instance) {
-  ppb_flash_target()->QuitMessageLoop(instance);
+  ppb_flash_impl_->QuitMessageLoop(instance);
 }
 
 void PPB_Flash_Proxy::OnMsgGetLocalTimeZoneOffset(PP_Instance instance,
                                                   PP_Time t,
                                                   double* result) {
-  *result = ppb_flash_target()->GetLocalTimeZoneOffset(instance, t);
+  *result = ppb_flash_impl_->GetLocalTimeZoneOffset(instance, t);
 }
 
 }  // namespace proxy
 }  // namespace ppapi