Rename InterfaceID to ApiID and move the file.

ppapi/proxy/ppp_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/ppp_instance_proxy.h"
 
 #include <algorithm>
 
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_core.h"
@@ skipping 17 matching lines @@
                   const char* argv[]) {
   std::vector<std::string> argn_vect;
   std::vector<std::string> argv_vect;
   for (uint32_t i = 0; i < argc; i++) {
     argn_vect.push_back(std::string(argn[i]));
     argv_vect.push_back(std::string(argv[i]));
   }
 
   PP_Bool result = PP_FALSE;
   HostDispatcher::GetForInstance(instance)->Send(
-      new PpapiMsg_PPPInstance_DidCreate(INTERFACE_ID_PPP_INSTANCE, instance,
+      new PpapiMsg_PPPInstance_DidCreate(API_ID_PPP_INSTANCE, instance,
                                          argn_vect, argv_vect, &result));
   return result;
 }
 
 void DidDestroy(PP_Instance instance) {
   HostDispatcher::GetForInstance(instance)->Send(
-      new PpapiMsg_PPPInstance_DidDestroy(INTERFACE_ID_PPP_INSTANCE, instance));
+      new PpapiMsg_PPPInstance_DidDestroy(API_ID_PPP_INSTANCE, instance));
 }
 
 void DidChangeView(PP_Instance instance,
                    const PP_Rect* position,
                    const PP_Rect* clip) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   const PPB_FlashFullscreen* fullscreen_interface =
       static_cast<const PPB_FlashFullscreen*>(
           dispatcher->local_get_interface()(PPB_FLASHFULLSCREEN_INTERFACE));
   DCHECK(fullscreen_interface);
   const PPB_FlashFullscreen* flash_fullscreen_interface =
       static_cast<const PPB_FlashFullscreen*>(
           dispatcher->local_get_interface()(PPB_FLASHFULLSCREEN_INTERFACE));
   DCHECK(flash_fullscreen_interface);
   PP_Bool fullscreen = fullscreen_interface->IsFullscreen(instance);
   PP_Bool flash_fullscreen  =
       flash_fullscreen_interface->IsFullscreen(instance);
   dispatcher->Send(
-      new PpapiMsg_PPPInstance_DidChangeView(INTERFACE_ID_PPP_INSTANCE,
+      new PpapiMsg_PPPInstance_DidChangeView(API_ID_PPP_INSTANCE,
                                              instance, *position, *clip,
                                              fullscreen,
                                              flash_fullscreen));
 }
 
 void DidChangeFocus(PP_Instance instance, PP_Bool has_focus) {
   HostDispatcher::GetForInstance(instance)->Send(
-      new PpapiMsg_PPPInstance_DidChangeFocus(INTERFACE_ID_PPP_INSTANCE,
+      new PpapiMsg_PPPInstance_DidChangeFocus(API_ID_PPP_INSTANCE,
                                               instance, has_focus));
 }
 
 PP_Bool HandleDocumentLoad(PP_Instance instance,
                            PP_Resource url_loader) {
   PP_Bool result = PP_FALSE;
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
 
   // Set up the URLLoader for proxying.
 
   PPB_URLLoader_Proxy* url_loader_proxy = static_cast<PPB_URLLoader_Proxy*>(
-      dispatcher->GetInterfaceProxy(INTERFACE_ID_PPB_URL_LOADER));
+      dispatcher->GetInterfaceProxy(API_ID_PPB_URL_LOADER));
   url_loader_proxy->PrepareURLLoaderForSendingToPlugin(url_loader);
 
   // PluginResourceTracker in the plugin process assumes that resources that it
   // tracks have been addrefed on behalf of the plugin at the renderer side. So
   // we explicitly do it for |url_loader| here.
   //
   // Please also see comments in PPP_Instance_Proxy::OnMsgHandleDocumentLoad()
   // about releasing of this extra reference.
   const PPB_Core* core = reinterpret_cast<const PPB_Core*>(
       dispatcher->local_get_interface()(PPB_CORE_INTERFACE));
   if (!core) {
     NOTREACHED();
     return PP_FALSE;
   }
   core->AddRefResource(url_loader);
 
   HostResource serialized_loader;
   serialized_loader.SetHostResource(instance, url_loader);
   dispatcher->Send(new PpapiMsg_PPPInstance_HandleDocumentLoad(
-      INTERFACE_ID_PPP_INSTANCE, instance, serialized_loader, &result));
+      API_ID_PPP_INSTANCE, instance, serialized_loader, &result));
   return result;
 }
 
 static const PPP_Instance_1_0 instance_interface_1_0 = {
   &DidCreate,
   &DidDestroy,
   &DidChangeView,
   &DidChangeFocus,
   &HandleDocumentLoad
 };
@@ skipping 14 matching lines @@
 }
 
 PPP_Instance_Proxy::~PPP_Instance_Proxy() {
 }
 
 // static
 const InterfaceProxy::Info* PPP_Instance_Proxy::GetInfo1_0() {
   static const Info info = {
     &instance_interface_1_0,
     PPP_INSTANCE_INTERFACE_1_0,
-    INTERFACE_ID_PPP_INSTANCE,
+    API_ID_PPP_INSTANCE,
     false,
     &CreateInstanceProxy
   };
   return &info;
 }
 
 bool PPP_Instance_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPP_Instance_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPInstance_DidCreate,
@@ skipping 84 matching lines @@
   // with. The plugin will normally take an additional reference which will keep
   // the resource alive in the plugin (and the one reference in the renderer
   // representing all plugin references).
   // Once all references at the plugin side are released, the renderer side will
   // be notified and release the reference added in HandleDocumentLoad() above.
   PpapiGlobals::Get()->GetResourceTracker()->ReleaseResource(plugin_loader);
 }
 
 }  // namespace proxy
 }  // namespace ppapi