NaCl: Remove use of nacl::DescWrapper from nacl_ipc_adapter.cc

chrome/nacl/nacl_ipc_adapter.cc

 // Copyright (c) 2012 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 "chrome/nacl/nacl_ipc_adapter.h"
 
 #include <limits.h>
 #include <string.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/shared_memory.h"
 #include "build/build_config.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_platform_file.h"
 #include "native_client/src/trusted/desc/nacl_desc_custom.h"
-#include "native_client/src/trusted/desc/nacl_desc_wrapper.h"
+#include "native_client/src/trusted/desc/nacl_desc_imc_shm.h"
+#include "native_client/src/trusted/desc/nacl_desc_sync_socket.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/serialized_handle.h"
 
 namespace {
 
 enum BufferSizeStatus {
   // The buffer contains a full message with no extra bytes.
   MESSAGE_IS_COMPLETE,
 
   // The message doesn't fit and the buffer contains only some of it.
@@ skipping 53 matching lines @@
   funcs.SendMsg = NaClDescCustomSendMsg;
   funcs.RecvMsg = NaClDescCustomRecvMsg;
   // NaClDescMakeCustomDesc gives us a reference on the returned NaClDesc.
   return NaClDescMakeCustomDesc(new DescThunker(adapter), &funcs);
 }
 
 void DeleteChannel(IPC::Channel* channel) {
   delete channel;
 }
 
+class NaClDescWrapper {
+ public:
+  explicit NaClDescWrapper(NaClDesc* desc): desc_(desc) {}
+  ~NaClDescWrapper() {
+    NaClDescUnref(desc_);
+  }
+
+  NaClDesc* desc() { return desc_; }
+
+ private:
+  NaClDesc* desc_;
+  DISALLOW_COPY_AND_ASSIGN(NaClDescWrapper);
+};
+
 }  // namespace
 
 class NaClIPCAdapter::RewrittenMessage
     : public base::RefCounted<RewrittenMessage> {
  public:
   RewrittenMessage();
 
   bool is_consumed() const { return data_read_cursor_ == data_len_; }
 
   void SetData(const NaClIPCAdapter::NaClMessageHeader& header,
                const void* payload, size_t payload_length);
 
   int Read(NaClImcTypedMsgHdr* msg);
 
-  void AddDescriptor(nacl::DescWrapper* desc) { descs_.push_back(desc); }
+  void AddDescriptor(NaClDescWrapper* desc) { descs_.push_back(desc); }
 
   size_t desc_count() const { return descs_.size(); }
 
  private:
   friend class base::RefCounted<RewrittenMessage>;
   ~RewrittenMessage() {}
 
   scoped_array<char> data_;
   size_t data_len_;
 
   // Offset into data where the next read will happen. This will be equal to
   // data_len_ when all data has been consumed.
   size_t data_read_cursor_;
 
   // Wrapped descriptors for transfer to untrusted code.
-  ScopedVector<nacl::DescWrapper> descs_;
+  ScopedVector<NaClDescWrapper> descs_;
 };
 
 NaClIPCAdapter::RewrittenMessage::RewrittenMessage()
     : data_len_(0),
       data_read_cursor_(0) {
 }
 
 void NaClIPCAdapter::RewrittenMessage::SetData(
     const NaClIPCAdapter::NaClMessageHeader& header,
     const void* payload,
@@ skipping 200 matching lines @@
     typedef std::vector<ppapi::proxy::SerializedHandle> Handles;
     Handles handles;
     scoped_ptr<IPC::Message> new_msg_ptr;
     bool success = locked_data_.handle_converter_.ConvertNativeHandlesToPosix(
         msg, &handles, &new_msg_ptr);
     if (!success)
       return false;
 
     // Now add any descriptors we found to rewritten_msg. |handles| is usually
     // empty, unless we read a message containing a FD or handle.
-    nacl::DescWrapperFactory factory;
     for (Handles::const_iterator iter = handles.begin();
          iter != handles.end();
          ++iter) {
-      scoped_ptr<nacl::DescWrapper> nacl_desc;
+      scoped_ptr<NaClDescWrapper> nacl_desc;
       switch (iter->type()) {
         case ppapi::proxy::SerializedHandle::SHARED_MEMORY: {
           const base::SharedMemoryHandle& shm_handle = iter->shmem();
           uint32_t size = iter->size();
-          nacl_desc.reset(factory.ImportShmHandle(
+          nacl_desc.reset(new NaClDescWrapper(NaClDescImcShmMake(
 #if defined(OS_WIN)
               reinterpret_cast<const NaClHandle>(shm_handle),
 #else
               shm_handle.fd,
 #endif
-              static_cast<size_t>(size)));
+              static_cast<size_t>(size))));
           break;
         }
         case ppapi::proxy::SerializedHandle::SOCKET: {
-          nacl_desc.reset(factory.ImportSyncSocketHandle(
+          nacl_desc.reset(new NaClDescWrapper(NaClDescSyncSocketMake(
 #if defined(OS_WIN)
               reinterpret_cast<const NaClHandle>(iter->descriptor())
 #else
               iter->descriptor().fd
 #endif
-          ));
+          )));
           break;
         }
         case ppapi::proxy::SerializedHandle::CHANNEL_HANDLE: {
           // Check that this came from a PpapiMsg_CreateNaClChannel message.
           // This code here is only appropriate for that message.
           DCHECK(msg.type() == PpapiMsg_CreateNaClChannel::ID);
           IPC::ChannelHandle channel_handle =
               IPC::Channel::GenerateVerifiedChannelID("nacl");
           scoped_refptr<NaClIPCAdapter> ipc_adapter(
               new NaClIPCAdapter(channel_handle, task_runner_));
           ipc_adapter->ConnectChannel();
 #if defined(OS_POSIX)
           channel_handle.socket = base::FileDescriptor(
               ipc_adapter->TakeClientFileDescriptor(), true);
 #endif
-          nacl_desc.reset(factory.MakeGeneric(ipc_adapter->MakeNaClDesc()));
+          nacl_desc.reset(new NaClDescWrapper(ipc_adapter->MakeNaClDesc()));
           // Send back a message that the channel was created.
           scoped_ptr<IPC::Message> response(
               new PpapiHostMsg_ChannelCreated(channel_handle));
           task_runner_->PostTask(FROM_HERE,
               base::Bind(&NaClIPCAdapter::SendMessageOnIOThread, this,
                          base::Passed(&response)));
           break;
         }
         case ppapi::proxy::SerializedHandle::FILE:
           // TODO(raymes): Handle file handles for NaCl.
@@ skipping 129 matching lines @@
   header.payload_size = static_cast<uint32>(msg.payload_size());
   header.routing = msg.routing_id();
   header.type = msg.type();
   header.flags = msg.flags();
   header.num_fds = static_cast<int>(rewritten_msg->desc_count());
 
   rewritten_msg->SetData(header, msg.payload(), msg.payload_size());
   locked_data_.to_be_received_.push(rewritten_msg);
 }