Rename InterfaceID to ApiID and move the file.

ppapi/proxy/ppb_video_capture_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_video_capture_proxy.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "build/build_config.h"
@@ skipping 69 matching lines @@
 #elif defined(OS_POSIX)
           handle;
 #else
 #error Not implemented.
 #endif
       buffers[i].handle =
           dispatcher->ShareHandleWithRemote(platform_file, false);
     }
   }
   dispatcher->Send(new PpapiMsg_PPPVideoCapture_OnDeviceInfo(
-      INTERFACE_ID_PPP_VIDEO_CAPTURE_DEV, host_resource, *info, buffers));
+      API_ID_PPP_VIDEO_CAPTURE_DEV, host_resource, *info, buffers));
 }
 
 void OnStatus(PP_Instance instance, PP_Resource resource, uint32_t status) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     return;
   }
   HostResource host_resource;
   host_resource.SetHostResource(instance, resource);
   dispatcher->Send(new PpapiMsg_PPPVideoCapture_OnStatus(
-      INTERFACE_ID_PPP_VIDEO_CAPTURE_DEV, host_resource, status));
+      API_ID_PPP_VIDEO_CAPTURE_DEV, host_resource, status));
 }
 
 void OnError(PP_Instance instance, PP_Resource resource, uint32_t error_code) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     return;
   }
   HostResource host_resource;
   host_resource.SetHostResource(instance, resource);
   dispatcher->Send(new PpapiMsg_PPPVideoCapture_OnError(
-      INTERFACE_ID_PPP_VIDEO_CAPTURE_DEV, host_resource, error_code));
+      API_ID_PPP_VIDEO_CAPTURE_DEV, host_resource, error_code));
 }
 
 void OnBufferReady(PP_Instance instance,
                    PP_Resource resource,
                    uint32_t buffer) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher) {
     NOTREACHED();
     return;
   }
   HostResource host_resource;
   host_resource.SetHostResource(instance, resource);
   dispatcher->Send(new PpapiMsg_PPPVideoCapture_OnBufferReady(
-      INTERFACE_ID_PPP_VIDEO_CAPTURE_DEV, host_resource, buffer));
+      API_ID_PPP_VIDEO_CAPTURE_DEV, host_resource, buffer));
 }
 
 PPP_VideoCapture_Dev ppp_video_capture = {
   OnDeviceInfo,
   OnStatus,
   OnError,
   OnBufferReady
 };
 
 }  // namespace
@@ skipping 16 matching lines @@
       case PP_VIDEO_CAPTURE_STATUS_STARTED:
       case PP_VIDEO_CAPTURE_STATUS_PAUSED:
       default:
         return PP_ERROR_FAILED;
       case PP_VIDEO_CAPTURE_STATUS_STOPPED:
       case PP_VIDEO_CAPTURE_STATUS_STOPPING:
         break;
     }
     status_ = PP_VIDEO_CAPTURE_STATUS_STARTING;
     GetDispatcher()->Send(new PpapiHostMsg_PPBVideoCapture_StartCapture(
-        INTERFACE_ID_PPB_VIDEO_CAPTURE_DEV, host_resource(),
+        API_ID_PPB_VIDEO_CAPTURE_DEV, host_resource(),
         requested_info, buffer_count));
     return PP_OK;
   }
 
   virtual int32_t ReuseBuffer(uint32_t buffer) {
     if (buffer >= buffer_in_use_.size() || !buffer_in_use_[buffer])
       return PP_ERROR_BADARGUMENT;
     GetDispatcher()->Send(new PpapiHostMsg_PPBVideoCapture_ReuseBuffer(
-        INTERFACE_ID_PPB_VIDEO_CAPTURE_DEV, host_resource(), buffer));
+        API_ID_PPB_VIDEO_CAPTURE_DEV, host_resource(), buffer));
     return PP_OK;
   }
 
   virtual int32_t StopCapture() {
     switch (status_) {
       case PP_VIDEO_CAPTURE_STATUS_STOPPED:
       case PP_VIDEO_CAPTURE_STATUS_STOPPING:
       default:
         return PP_ERROR_FAILED;
       case PP_VIDEO_CAPTURE_STATUS_STARTING:
       case PP_VIDEO_CAPTURE_STATUS_STARTED:
       case PP_VIDEO_CAPTURE_STATUS_PAUSED:
         break;
     }
     buffer_in_use_.clear();
     status_ = PP_VIDEO_CAPTURE_STATUS_STOPPING;
     GetDispatcher()->Send(new PpapiHostMsg_PPBVideoCapture_StopCapture(
-        INTERFACE_ID_PPB_VIDEO_CAPTURE_DEV, host_resource()));
+        API_ID_PPB_VIDEO_CAPTURE_DEV, host_resource()));
     return PP_OK;
   }
 
   bool OnStatus(uint32_t status) {
     switch (status) {
       case PP_VIDEO_CAPTURE_STATUS_STARTING:
       case PP_VIDEO_CAPTURE_STATUS_STOPPING:
       default:
         // Those states are not sent by the browser.
         NOTREACHED();
@@ skipping 65 matching lines @@
 }
 
 // static
 PP_Resource PPB_VideoCapture_Proxy::CreateProxyResource(PP_Instance instance) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return 0;
 
   HostResource result;
   dispatcher->Send(new PpapiHostMsg_PPBVideoCapture_Create(
-      INTERFACE_ID_PPB_VIDEO_CAPTURE_DEV, instance, &result));
+      API_ID_PPB_VIDEO_CAPTURE_DEV, instance, &result));
   if (result.is_null())
     return 0;
   return (new VideoCapture(result))->GetReference();
 }
 
 bool PPB_VideoCapture_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_VideoCapture_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVideoCapture_Create, OnMsgCreate)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVideoCapture_StartCapture,
@@ skipping 50 matching lines @@
 }
 
 PPP_VideoCapture_Proxy::~PPP_VideoCapture_Proxy() {
 }
 
 // static
 const InterfaceProxy::Info* PPP_VideoCapture_Proxy::GetInfo() {
   static const Info info = {
     &ppp_video_capture,
     PPP_VIDEO_CAPTURE_DEV_INTERFACE,
-    INTERFACE_ID_PPP_VIDEO_CAPTURE_DEV,
+    API_ID_PPP_VIDEO_CAPTURE_DEV,
     false,
     &CreatePPPVideoCaptureProxy,
   };
   return &info;
 }
 
 bool PPP_VideoCapture_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPP_VideoCapture_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPVideoCapture_OnDeviceInfo,
@@ skipping 71 matching lines @@
     return;
 
   VideoCapture* capture = static_cast<VideoCapture*>(enter.object());
   capture->SetBufferInUse(buffer);
   ppp_video_capture_impl_->OnBufferReady(
       host_resource.instance(), capture->pp_resource(), buffer);
 }
 
 }  // namespace proxy
 }  // namespace ppapi