Rename InterfaceID to ApiID and move the file.

ppapi/proxy/ppb_context_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_context_3d_proxy.h"
 
 #include "base/hash_tables.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 122 matching lines @@
 }
 
 bool PepperCommandBuffer::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_PPBContext3D_Initialize(
-          INTERFACE_ID_PPB_CONTEXT_3D, resource_, size, &handle)) &&
+          API_ID_PPB_CONTEXT_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 PepperCommandBuffer::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_PPBContext3D_GetState(
-             INTERFACE_ID_PPB_CONTEXT_3D, resource_, &state)))
+             API_ID_PPB_CONTEXT_3D, resource_, &state)))
       UpdateState(state);
   }
 
   return last_state_;
 }
 
 gpu::CommandBuffer::State PepperCommandBuffer::GetLastState() {
   return last_state_;
 }
 
 void PepperCommandBuffer::Flush(int32 put_offset) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   IPC::Message* message = new PpapiHostMsg_PPBContext3D_AsyncFlush(
-      INTERFACE_ID_PPB_CONTEXT_3D, resource_, put_offset);
+      API_ID_PPB_CONTEXT_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 PepperCommandBuffer::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_PPBContext3D_Flush(
-              INTERFACE_ID_PPB_CONTEXT_3D, resource_, put_offset,
+              API_ID_PPB_CONTEXT_3D, resource_, put_offset,
               last_known_get, &state)))
         UpdateState(state);
     }
   } else {
     Flush(put_offset);
   }
 
   return last_state_;
 }
 
 void PepperCommandBuffer::SetGetOffset(int32 get_offset) {
   // Not implemented in proxy.
   NOTREACHED();
 }
 
 int32 PepperCommandBuffer::CreateTransferBuffer(size_t size, int32 id_request) {
   if (last_state_.error == gpu::error::kNoError) {
     int32 id;
     if (Send(new PpapiHostMsg_PPBContext3D_CreateTransferBuffer(
-            INTERFACE_ID_PPB_CONTEXT_3D, resource_, size, &id))) {
+            API_ID_PPB_CONTEXT_3D, resource_, size, &id))) {
       return id;
     }
   }
 
   return -1;
 }
 
 int32 PepperCommandBuffer::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_PPBContext3D_DestroyTransferBuffer(
-      INTERFACE_ID_PPB_CONTEXT_3D, resource_, id));
+      API_ID_PPB_CONTEXT_3D, resource_, id));
 }
 
 gpu::Buffer PepperCommandBuffer::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_PPBContext3D_GetTransferBuffer(
-          INTERFACE_ID_PPB_CONTEXT_3D, resource_, id, &handle, &size))) {
+          API_ID_PPB_CONTEXT_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 116 matching lines @@
   if (pp_read && !read_surface)
     return PP_ERROR_BADRESOURCE;
   HostResource host_draw =
       draw_surface ? draw_surface->host_resource() : HostResource();
   HostResource host_read =
       read_surface ? read_surface->host_resource() : HostResource();
 
   int32_t result;
   PluginDispatcher::GetForResource(this)->Send(
       new PpapiHostMsg_PPBContext3D_BindSurfaces(
-          INTERFACE_ID_PPB_CONTEXT_3D,
+          API_ID_PPB_CONTEXT_3D,
           host_resource(), host_draw, host_read, &result));
   if (result != PP_OK)
     return result;
 
   if (draw_surface != draw_) {
     if (draw_)
       draw_->set_context(NULL);
     if (draw_surface) {
       draw_surface->set_context(this);
       // Resize the backing texture to the size of the instance when it is
@@ skipping 113 matching lines @@
   std::vector<int32_t> attribs;
   if (attrib_list) {
     for (const int32_t* attr = attrib_list; attr; ++attr)
       attribs.push_back(*attr);
   } else {
     attribs.push_back(0);
   }
 
   HostResource result;
   dispatcher->Send(new PpapiHostMsg_PPBContext3D_Create(
-      INTERFACE_ID_PPB_CONTEXT_3D, instance, config, attribs, &result));
+      API_ID_PPB_CONTEXT_3D, instance, config, attribs, &result));
 
   if (result.is_null())
     return 0;
   scoped_refptr<Context3D> context_3d(new Context3D(result));
   if (!context_3d->CreateImplementation())
     return 0;
   return context_3d->GetReference();
 }
 
 bool PPB_Context3D_Proxy::OnMessageReceived(const IPC::Message& msg) {
@@ skipping 131 matching lines @@
   uint32_t shm_size = 0;
   if (enter.succeeded() &&
       enter.object()->GetTransferBuffer(id, &shm_handle, &shm_size)) {
     *transfer_buffer = TransportSHMHandleFromInt(dispatcher(), shm_handle);
     *size = shm_size;
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi