Rename InterfaceID to ApiID and move the file.

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"
@@ skipping 17 matching lines @@
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 void SetInstanceAlwaysOnTop(PP_Instance pp_instance, PP_Bool on_top) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(pp_instance);
   if (dispatcher) {
     dispatcher->Send(new PpapiHostMsg_PPBFlash_SetInstanceAlwaysOnTop(
-        INTERFACE_ID_PPB_FLASH, pp_instance, on_top));
+        API_ID_PPB_FLASH, pp_instance, on_top));
   }
 }
 
 PP_Bool DrawGlyphs(PP_Instance instance,
                    PP_Resource pp_image_data,
                    const PP_FontDescription_Dev* font_desc,
                    uint32_t color,
                    PP_Point position,
                    PP_Rect clip,
                    const float transformation[3][3],
@@ skipping 27 matching lines @@
 
   params.glyph_indices.insert(params.glyph_indices.begin(),
                               &glyph_indices[0],
                               &glyph_indices[glyph_count]);
   params.glyph_advances.insert(params.glyph_advances.begin(),
                                &glyph_advances[0],
                                &glyph_advances[glyph_count]);
 
   PP_Bool result = PP_FALSE;
   dispatcher->Send(new PpapiHostMsg_PPBFlash_DrawGlyphs(
-      INTERFACE_ID_PPB_FLASH, params, &result));
+      API_ID_PPB_FLASH, params, &result));
   return result;
 }
 
 PP_Var GetProxyForURL(PP_Instance instance, const char* url) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return PP_MakeUndefined();
 
   ReceiveSerializedVarReturnValue result;
   dispatcher->Send(new PpapiHostMsg_PPBFlash_GetProxyForURL(
-      INTERFACE_ID_PPB_FLASH, instance, url, &result));
+      API_ID_PPB_FLASH, instance, url, &result));
   return result.Return(dispatcher);
 }
 
 int32_t Navigate(PP_Resource request_id,
                  const char* target,
                  bool from_user_action) {
   thunk::EnterResource<thunk::PPB_URLRequestInfo_API> enter(request_id, true);
   if (enter.failed())
     return PP_ERROR_BADRESOURCE;
   PP_Instance instance = enter.resource()->pp_instance();
 
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return PP_ERROR_FAILED;
 
   int32_t result = PP_ERROR_FAILED;
   dispatcher->Send(new PpapiHostMsg_PPBFlash_Navigate(
-      INTERFACE_ID_PPB_FLASH,
+      API_ID_PPB_FLASH,
       instance, enter.object()->GetData(), target, from_user_action,
       &result));
   return result;
 }
 
 void RunMessageLoop(PP_Instance instance) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return;
   IPC::SyncMessage* msg = new PpapiHostMsg_PPBFlash_RunMessageLoop(
-      INTERFACE_ID_PPB_FLASH, instance);
+      API_ID_PPB_FLASH, instance);
   msg->EnableMessagePumping();
   dispatcher->Send(msg);
 }
 
 void QuitMessageLoop(PP_Instance instance) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return;
   dispatcher->Send(new PpapiHostMsg_PPBFlash_QuitMessageLoop(
-      INTERFACE_ID_PPB_FLASH, instance));
+      API_ID_PPB_FLASH, instance));
 }
 
 double GetLocalTimeZoneOffset(PP_Instance instance, PP_Time t) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return 0.0;
 
   // TODO(brettw) on Windows it should be possible to do the time calculation
   // in-process since it doesn't need to read files on disk. This will improve
   // performance.
   //
   // 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));
+      API_ID_PPB_FLASH, instance, t, &result));
   return result;
 }
 
 PP_Var GetCommandLineArgs(PP_Module pp_module) {
   std::string args = ProxyModule::GetInstance()->GetFlashCommandLineArgs();
   return StringVar::StringToPPVar(pp_module, args);
 }
 
 const PPB_Flash flash_interface = {
   &SetInstanceAlwaysOnTop,
@@ skipping 21 matching lines @@
 }
 
 PPB_Flash_Proxy::~PPB_Flash_Proxy() {
 }
 
 // static
 const InterfaceProxy::Info* PPB_Flash_Proxy::GetInfo() {
   static const Info info = {
     &flash_interface,
     PPB_FLASH_INTERFACE,
-    INTERFACE_ID_PPB_FLASH,
+    API_ID_PPB_FLASH,
     true,
     &CreateFlashProxy,
   };
   return &info;
 }
 
 bool PPB_Flash_Proxy::OnMessageReceived(const IPC::Message& msg) {
   // Prevent the dispatcher from going away during a call to Navigate.
   // This must happen OUTSIDE of OnMsgNavigate since the handling code use
   // the dispatcher upon return of the function (sending the reply message).
@@ skipping 101 matching lines @@
 }
 
 void PPB_Flash_Proxy::OnMsgGetLocalTimeZoneOffset(PP_Instance instance,
                                                   PP_Time t,
                                                   double* result) {
   *result = ppb_flash_impl_->GetLocalTimeZoneOffset(instance, t);
 }
 
 }  // namespace proxy
 }  // namespace ppapi