Rename InterfaceID to ApiID and move the file.

ppapi/proxy/ppb_graphics_3d_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_graphics_3d_proxy.h"
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/enter_proxy.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
@@ skipping 74 matching lines @@
 }
 
 bool CommandBuffer::Initialize(int32 size) {
   DCHECK(!ring_buffer_.get());
 
   // Initialize the service. Assuming we are sandboxed, the GPU
   // process is responsible for duplicating the handle. This might not be true
   // for NaCl.
   base::SharedMemoryHandle handle;
   if (Send(new PpapiHostMsg_PPBGraphics3D_InitCommandBuffer(
-          INTERFACE_ID_PPB_GRAPHICS_3D, resource_, size, &handle)) &&
+          API_ID_PPB_GRAPHICS_3D, resource_, size, &handle)) &&
       base::SharedMemory::IsHandleValid(handle)) {
     ring_buffer_.reset(new base::SharedMemory(handle, false));
     if (ring_buffer_->Map(size)) {
       num_entries_ = size / sizeof(gpu::CommandBufferEntry);
       return true;
     }
 
     ring_buffer_.reset();
   }
 
@@ skipping 13 matching lines @@
   buffer.size = num_entries_ * sizeof(gpu::CommandBufferEntry);
   buffer.shared_memory = ring_buffer_.get();
   return buffer;
 }
 
 gpu::CommandBuffer::State CommandBuffer::GetState() {
   // Send will flag state with lost context if IPC fails.
   if (last_state_.error == gpu::error::kNoError) {
     gpu::CommandBuffer::State state;
     if (Send(new PpapiHostMsg_PPBGraphics3D_GetState(
-             INTERFACE_ID_PPB_GRAPHICS_3D, resource_, &state)))
+             API_ID_PPB_GRAPHICS_3D, resource_, &state)))
       UpdateState(state);
   }
 
   return last_state_;
 }
 
 gpu::CommandBuffer::State CommandBuffer::GetLastState() {
   return last_state_;
 }
 
 void CommandBuffer::Flush(int32 put_offset) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   IPC::Message* message = new PpapiHostMsg_PPBGraphics3D_AsyncFlush(
-      INTERFACE_ID_PPB_GRAPHICS_3D, resource_, put_offset);
+      API_ID_PPB_GRAPHICS_3D, resource_, put_offset);
 
   // Do not let a synchronous flush hold up this message. If this handler is
   // deferred until after the synchronous flush completes, it will overwrite the
   // cached last_state_ with out-of-date data.
   message->set_unblock(true);
   Send(message);
 }
 
 gpu::CommandBuffer::State CommandBuffer::FlushSync(int32 put_offset,
                                                    int32 last_known_get) {
   if (last_known_get == last_state_.get_offset) {
     // Send will flag state with lost context if IPC fails.
     if (last_state_.error == gpu::error::kNoError) {
       gpu::CommandBuffer::State state;
       if (Send(new PpapiHostMsg_PPBGraphics3D_Flush(
-              INTERFACE_ID_PPB_GRAPHICS_3D, resource_, put_offset,
+              API_ID_PPB_GRAPHICS_3D, resource_, put_offset,
               last_known_get, &state)))
         UpdateState(state);
     }
   } else {
     Flush(put_offset);
   }
 
   return last_state_;
 }
 
 void CommandBuffer::SetGetOffset(int32 get_offset) {
   // Not implemented in proxy.
   NOTREACHED();
 }
 
 int32 CommandBuffer::CreateTransferBuffer(size_t size, int32 id_request) {
   if (last_state_.error == gpu::error::kNoError) {
     int32 id;
     if (Send(new PpapiHostMsg_PPBGraphics3D_CreateTransferBuffer(
-            INTERFACE_ID_PPB_GRAPHICS_3D, resource_, size, &id))) {
+            API_ID_PPB_GRAPHICS_3D, resource_, size, &id))) {
       return id;
     }
   }
 
   return -1;
 }
 
 int32 CommandBuffer::RegisterTransferBuffer(
     base::SharedMemory* shared_memory,
     size_t size,
@@ skipping 10 matching lines @@
   // Remove the transfer buffer from the client side4 cache.
   TransferBufferMap::iterator it = transfer_buffers_.find(id);
   DCHECK(it != transfer_buffers_.end());
 
   // Delete the shared memory object, closing the handle in this process.
   delete it->second.shared_memory;
 
   transfer_buffers_.erase(it);
 
   Send(new PpapiHostMsg_PPBGraphics3D_DestroyTransferBuffer(
-      INTERFACE_ID_PPB_GRAPHICS_3D, resource_, id));
+      API_ID_PPB_GRAPHICS_3D, resource_, id));
 }
 
 gpu::Buffer CommandBuffer::GetTransferBuffer(int32 id) {
   if (last_state_.error != gpu::error::kNoError)
     return gpu::Buffer();
 
   // Check local cache to see if there is already a client side shared memory
   // object for this id.
   TransferBufferMap::iterator it = transfer_buffers_.find(id);
   if (it != transfer_buffers_.end()) {
     return it->second;
   }
 
   // Assuming we are in the renderer process, the service is responsible for
   // duplicating the handle. This might not be true for NaCl.
   base::SharedMemoryHandle handle;
   uint32 size;
   if (!Send(new PpapiHostMsg_PPBGraphics3D_GetTransferBuffer(
-          INTERFACE_ID_PPB_GRAPHICS_3D, resource_, id, &handle, &size))) {
+          API_ID_PPB_GRAPHICS_3D, resource_, id, &handle, &size))) {
     return gpu::Buffer();
   }
 
   // Cache the transfer buffer shared memory object client side.
   scoped_ptr<base::SharedMemory> shared_memory(
       new base::SharedMemory(handle, false));
 
   // Map the shared memory on demand.
   if (!shared_memory->memory()) {
     if (!shared_memory->Map(size)) {
@@ skipping 134 matching lines @@
                                                     int32_t last_known_get) {
   return GetErrorState();
 }
 
 gpu::CommandBuffer* Graphics3D::GetCommandBuffer() {
   return command_buffer_.get();
 }
 
 int32 Graphics3D::DoSwapBuffers() {
   IPC::Message* msg = new PpapiHostMsg_PPBGraphics3D_SwapBuffers(
-      INTERFACE_ID_PPB_GRAPHICS_3D, host_resource());
+      API_ID_PPB_GRAPHICS_3D, host_resource());
   msg->set_unblock(true);
   PluginDispatcher::GetForResource(this)->Send(msg);
 
   gles2_impl()->SwapBuffers();
   return PP_OK_COMPLETIONPENDING;
 }
 
 PPB_Graphics3D_Proxy::PPB_Graphics3D_Proxy(Dispatcher* dispatcher)
     : InterfaceProxy(dispatcher),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
@@ skipping 22 matching lines @@
          attr[0] != PP_GRAPHICS3DATTRIB_NONE;
          attr += 2) {
       attribs.push_back(attr[0]);
       attribs.push_back(attr[1]);
     }
   }
   attribs.push_back(PP_GRAPHICS3DATTRIB_NONE);
 
   HostResource result;
   dispatcher->Send(new PpapiHostMsg_PPBGraphics3D_Create(
-      INTERFACE_ID_PPB_GRAPHICS_3D, instance, attribs, &result));
+      API_ID_PPB_GRAPHICS_3D, instance, attribs, &result));
   if (result.is_null())
     return 0;
 
   scoped_refptr<Graphics3D> graphics_3d(new Graphics3D(result));
   if (!graphics_3d->Init())
     return 0;
   return graphics_3d->GetReference();
 }
 
 bool PPB_Graphics3D_Proxy::OnMessageReceived(const IPC::Message& msg) {
@@ skipping 137 matching lines @@
                                               int32_t pp_error) {
   EnterPluginFromHostResource<PPB_Graphics3D_API> enter(resource);
   if (enter.succeeded())
     static_cast<Graphics3D*>(enter.object())->SwapBuffersACK(pp_error);
 }
 
 void PPB_Graphics3D_Proxy::SendSwapBuffersACKToPlugin(
     int32_t result,
     const HostResource& context) {
   dispatcher()->Send(new PpapiMsg_PPBGraphics3D_SwapBuffersACK(
-      INTERFACE_ID_PPB_GRAPHICS_3D, context, result));
+      API_ID_PPB_GRAPHICS_3D, context, result));
 }
 
 }  // namespace proxy
 }  // namespace ppapi