Rename InterfaceID to ApiID and move the file.

ppapi/proxy/ppb_url_loader_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_url_loader_proxy.h"
 
 #include <algorithm>
 #include <deque>
 #include <vector>
 
@@ skipping 50 matching lines @@
     return;
 
   PPBURLLoader_UpdateProgress_Params params;
   params.instance = pp_instance;
   params.resource.SetHostResource(pp_instance, pp_resource);
   params.bytes_sent = bytes_sent;
   params.total_bytes_to_be_sent = total_bytes_to_be_sent;
   params.bytes_received = bytes_received;
   params.total_bytes_to_be_received = total_bytes_to_be_received;
   dispatcher->Send(new PpapiMsg_PPBURLLoader_UpdateProgress(
-      INTERFACE_ID_PPB_URL_LOADER, params));
+      API_ID_PPB_URL_LOADER, params));
 }
 
 InterfaceProxy* CreateURLLoaderProxy(Dispatcher* dispatcher) {
   return new PPB_URLLoader_Proxy(dispatcher);
 }
 
 }  // namespace
 
 // URLLoader -------------------------------------------------------------------
 
@@ skipping 99 matching lines @@
 
 int32_t URLLoader::Open(PP_Resource request_id,
                         PP_CompletionCallback callback) {
   EnterResourceNoLock<thunk::PPB_URLRequestInfo_API> enter(request_id, true);
   if (enter.failed())
     return PP_ERROR_BADRESOURCE;
 
   // TODO(brettw) http://crbug.com/86279: SendCallback doesn't ensure that
   // the proper callback semantics happen if the object is deleted.
   GetDispatcher()->Send(new PpapiHostMsg_PPBURLLoader_Open(
-      INTERFACE_ID_PPB_URL_LOADER, host_resource(), enter.object()->GetData(),
+      API_ID_PPB_URL_LOADER, host_resource(), enter.object()->GetData(),
       GetDispatcher()->callback_tracker().SendCallback(callback)));
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t URLLoader::FollowRedirect(PP_CompletionCallback callback) {
   // TODO(brettw) http://crbug.com/86279: SendCallback doesn't ensure that
   // the proper callback semantics happen if the object is deleted.
   GetDispatcher()->Send(new PpapiHostMsg_PPBURLLoader_FollowRedirect(
-      INTERFACE_ID_PPB_URL_LOADER, host_resource(),
+      API_ID_PPB_URL_LOADER, host_resource(),
       GetDispatcher()->callback_tracker().SendCallback(callback)));
   return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Bool URLLoader::GetUploadProgress(int64_t* bytes_sent,
                                      int64_t* total_bytes_to_be_sent) {
   if (bytes_sent_ == -1) {
     *bytes_sent = 0;
     *total_bytes_to_be_sent = 0;
     return PP_FALSE;
@@ skipping 13 matching lines @@
   }
   *bytes_received = bytes_received_;
   *total_bytes_to_be_received = total_bytes_to_be_received_;
   return PP_TRUE;
 }
 
 PP_Resource URLLoader::GetResponseInfo() {
   if (!response_info_) {
     HostResource response_id;
     GetDispatcher()->Send(new PpapiHostMsg_PPBURLLoader_GetResponseInfo(
-        INTERFACE_ID_PPB_URL_LOADER, host_resource(), &response_id));
+        API_ID_PPB_URL_LOADER, host_resource(), &response_id));
     if (response_id.is_null())
       return 0;
 
     response_info_ = PPB_URLResponseInfo_Proxy::CreateResponseForResource(
         response_id);
   }
 
   // The caller expects to get a ref, and we want to keep holding ours.
   PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(response_info_);
   return response_info_;
@@ skipping 17 matching lines @@
     // return data to the caller. Do so without making IPCs.
     PopBuffer(buffer, bytes_to_read);
     return bytes_to_read;
   }
 
   current_read_callback_ = callback;
   current_read_buffer_ = buffer;
   current_read_buffer_size_ = bytes_to_read;
 
   GetDispatcher()->Send(new PpapiHostMsg_PPBURLLoader_ReadResponseBody(
-      INTERFACE_ID_PPB_URL_LOADER, host_resource(), bytes_to_read));
+      API_ID_PPB_URL_LOADER, host_resource(), bytes_to_read));
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t URLLoader::FinishStreamingToFile(PP_CompletionCallback callback) {
   GetDispatcher()->Send(new PpapiHostMsg_PPBURLLoader_FinishStreamingToFile(
-      INTERFACE_ID_PPB_URL_LOADER, host_resource(),
+      API_ID_PPB_URL_LOADER, host_resource(),
       GetDispatcher()->callback_tracker().SendCallback(callback)));
   return PP_OK_COMPLETIONPENDING;
 }
 
 void URLLoader::Close() {
   GetDispatcher()->Send(new PpapiHostMsg_PPBURLLoader_Close(
-      INTERFACE_ID_PPB_URL_LOADER, host_resource()));
+      API_ID_PPB_URL_LOADER, host_resource()));
 }
 
 void URLLoader::GrantUniversalAccess() {
   GetDispatcher()->Send(
       new PpapiHostMsg_PPBURLLoader_GrantUniversalAccess(
-          INTERFACE_ID_PPB_URL_LOADER, host_resource()));
+          API_ID_PPB_URL_LOADER, host_resource()));
 }
 
 void URLLoader::SetStatusCallback(
     PP_URLLoaderTrusted_StatusCallback cb) {
   // Not implemented in the proxied version, this is for implementing the
   // proxy itself in the host.
 }
 
 void URLLoader::UpdateProgress(
     const PPBURLLoader_UpdateProgress_Params& params) {
@@ skipping 57 matching lines @@
 PP_Resource PPB_URLLoader_Proxy::TrackPluginResource(
     const HostResource& url_loader_resource) {
   return (new URLLoader(url_loader_resource))->GetReference();
 }
 
 // static
 const InterfaceProxy::Info* PPB_URLLoader_Proxy::GetTrustedInfo() {
   static const Info info = {
     thunk::GetPPB_URLLoaderTrusted_Thunk(),
     PPB_URLLOADERTRUSTED_INTERFACE,
-    INTERFACE_ID_NONE,  // URL_LOADER is the canonical one.
+    API_ID_NONE,  // URL_LOADER is the canonical one.
     false,
     &CreateURLLoaderProxy
   };
   return &info;
 }
 
 // static
 PP_Resource PPB_URLLoader_Proxy::CreateProxyResource(PP_Instance pp_instance) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(pp_instance);
   if (!dispatcher)
     return 0;
 
   HostResource result;
   dispatcher->Send(new PpapiHostMsg_PPBURLLoader_Create(
-      INTERFACE_ID_PPB_URL_LOADER, pp_instance, &result));
+      API_ID_PPB_URL_LOADER, pp_instance, &result));
   if (result.is_null())
     return 0;
   return PPB_URLLoader_Proxy::TrackPluginResource(result);
 }
 
 bool PPB_URLLoader_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_URLLoader_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBURLLoader_Create,
                         OnMsgCreate)
@@ skipping 172 matching lines @@
 }
 
 void PPB_URLLoader_Proxy::OnReadCallback(int32_t result,
                                          ReadCallbackInfo* info) {
   int32_t bytes_read = 0;
   if (result > 0)
     bytes_read = result;  // Positive results indicate bytes read.
   info->read_buffer.resize(bytes_read);
 
   dispatcher()->Send(new PpapiMsg_PPBURLLoader_ReadResponseBody_Ack(
-      INTERFACE_ID_PPB_URL_LOADER, info->resource, result, info->read_buffer));
+      API_ID_PPB_URL_LOADER, info->resource, result, info->read_buffer));
 
   delete info;
 }
 
 }  // namespace proxy
 }  // namespace ppapi