Convert NaClIPCAdapter::RewrittenMessage ownership management from shared to unique

components/nacl/loader/nacl_ipc_adapter.cc

 // Copyright 2013 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 "components/nacl/loader/nacl_ipc_adapter.h"
 
 #include <limits.h>
 #include <string.h>
 
 #include <memory>
@@ skipping 232 matching lines @@
           handle.GetHandle(),
 #else
           base::SharedMemory::GetFdFromSharedMemoryHandle(handle),
 #endif
           size)));
 #endif
 }
 
 }  // namespace
 
-class NaClIPCAdapter::RewrittenMessage
-    : public base::RefCounted<RewrittenMessage> {
+class NaClIPCAdapter::RewrittenMessage {
  public:
   RewrittenMessage();
+  ~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(NaClDescWrapper* desc) { descs_.push_back(desc); }
 
   size_t desc_count() const { return descs_.size(); }
 
  private:
-  friend class base::RefCounted<RewrittenMessage>;
-  ~RewrittenMessage() {}
-
   std::unique_ptr<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<NaClDescWrapper> descs_;
 };
@@ skipping 249 matching lines @@
       // browser process.
       return true;
     }
   }
   return RewriteMessage(msg, type);
 }
 
 bool NaClIPCAdapter::RewriteMessage(const IPC::Message& msg, uint32_t type) {
   {
     base::AutoLock lock(lock_);
-    scoped_refptr<RewrittenMessage> rewritten_msg(new RewrittenMessage);
+    std::unique_ptr<RewrittenMessage> rewritten_msg(new RewrittenMessage);
 
     typedef std::vector<ppapi::proxy::SerializedHandle> Handles;
     Handles handles;
     std::unique_ptr<IPC::Message> new_msg;
 
     if (!locked_data_.nacl_msg_scanner_.ScanMessage(
             msg, type, &handles, &new_msg))
       return false;
 
     // Now add any descriptors we found to rewritten_msg. |handles| is usually
@@ skipping 41 matching lines @@
         case ppapi::proxy::SerializedHandle::INVALID: {
           // Nothing to do.
           break;
         }
         // No default, so the compiler will warn us if new types get added.
       }
       if (nacl_desc.get())
         rewritten_msg->AddDescriptor(nacl_desc.release());
     }
     if (new_msg)
-      SaveMessage(*new_msg, rewritten_msg.get());
+      SaveMessage(*new_msg, std::move(rewritten_msg));
     else
-      SaveMessage(msg, rewritten_msg.get());
+      SaveMessage(msg, std::move(rewritten_msg));
     cond_var_.Signal();
   }
   return true;
 }
 
 std::unique_ptr<IPC::Message> CreateOpenResourceReply(
     const IPC::Message& orig_msg,
     ppapi::proxy::SerializedHandle sh) {
   // The creation of new_msg must be kept in sync with
   // SyncMessage::WriteSyncHeader.
@@ skipping 44 matching lines @@
 
     std::unique_ptr<NaClDescWrapper> desc_wrapper(
         new NaClDescWrapper(NaClDescIoMakeFromHandle(
 #if defined(OS_WIN)
             orig_sh.descriptor().GetHandle(),
 #else
             orig_sh.descriptor().fd,
 #endif
             NACL_ABI_O_RDONLY)));
 
-    scoped_refptr<RewrittenMessage> rewritten_msg(new RewrittenMessage);
+    std::unique_ptr<RewrittenMessage> rewritten_msg(new RewrittenMessage);
     rewritten_msg->AddDescriptor(desc_wrapper.release());
     {
       base::AutoLock lock(lock_);
-      SaveMessage(*new_msg, rewritten_msg.get());
+      SaveMessage(*new_msg, std::move(rewritten_msg));
       cond_var_.Signal();
     }
     return;
   }
 
   // The file token was successfully resolved.
   std::string file_path_str = file_path.AsUTF8Unsafe();
   base::PlatformFile handle =
       IPC::PlatformFileForTransitToPlatformFile(ipc_fd);
 
   ppapi::proxy::SerializedHandle sh;
   sh.set_file_handle(ipc_fd, PP_FILEOPENFLAG_READ, 0);
   std::unique_ptr<IPC::Message> new_msg = CreateOpenResourceReply(orig_msg, sh);
-  scoped_refptr<RewrittenMessage> rewritten_msg(new RewrittenMessage);
+  std::unique_ptr<RewrittenMessage> rewritten_msg(new RewrittenMessage);
 
   struct NaClDesc* desc =
       NaClDescCreateWithFilePathMetadata(handle, file_path_str.c_str());
   rewritten_msg->AddDescriptor(new NaClDescWrapper(desc));
   {
     base::AutoLock lock(lock_);
-    SaveMessage(*new_msg, rewritten_msg.get());
+    SaveMessage(*new_msg, std::move(rewritten_msg));
     cond_var_.Signal();
   }
 }
 
 void NaClIPCAdapter::OnChannelConnected(int32_t peer_pid) {}
 
 void NaClIPCAdapter::OnChannelError() {
   CloseChannel();
 }
 
 NaClIPCAdapter::~NaClIPCAdapter() {
   // Make sure the channel is deleted on the IO thread.
   task_runner_->PostTask(FROM_HERE,
       base::Bind(&DeleteChannel, io_thread_data_.channel_.release()));
 }
 
 int NaClIPCAdapter::LockedReceive(NaClImcTypedMsgHdr* msg) {
   lock_.AssertAcquired();
 
   if (locked_data_.to_be_received_.empty())
     return 0;
-  scoped_refptr<RewrittenMessage> current =
-      locked_data_.to_be_received_.front();
+  RewrittenMessage& current = *locked_data_.to_be_received_.front();
 
-  int retval = current->Read(msg);
+  int retval = current.Read(msg);
 
-  // When a message is entirely consumed, remove if from the waiting queue.
-  if (current->is_consumed())
+  // When a message is entirely consumed, remove it from the waiting queue.
+  if (current.is_consumed())
     locked_data_.to_be_received_.pop();
 
   return retval;
 }
 
 bool NaClIPCAdapter::SendCompleteMessage(const char* buffer,
                                          size_t buffer_len) {
   lock_.AssertAcquired();
   // The message will have already been validated, so we know it's large enough
   // for our header.
@@ skipping 84 matching lines @@
       // The callback sent a reply to the untrusted side.
       return;
     }
   }
 
   if (message->is_sync())
     io_thread_data_.pending_sync_msgs_[id] = message->type();
   io_thread_data_.channel_->Send(message.release());
 }
 
-void NaClIPCAdapter::SaveMessage(const IPC::Message& msg,
-                                 RewrittenMessage* rewritten_msg) {
+void NaClIPCAdapter::SaveMessage(
+    const IPC::Message& msg,
+    std::unique_ptr<RewrittenMessage> rewritten_msg) {
   lock_.AssertAcquired();
   // There is some padding in this structure (the "padding" member is 16
   // bits but this then gets padded to 32 bits). We want to be sure not to
   // leak data to the untrusted plugin, so zero everything out first.
   NaClMessageHeader header;
   memset(&header, 0, sizeof(NaClMessageHeader));
 
   header.payload_size = static_cast<uint32_t>(msg.payload_size());
   header.routing = msg.routing_id();
   header.type = msg.type();
   header.flags = msg.flags();
   header.num_fds = static_cast<uint16_t>(rewritten_msg->desc_count());
 
   rewritten_msg->SetData(header, msg.payload(), msg.payload_size());
-  locked_data_.to_be_received_.push(rewritten_msg);
+  locked_data_.to_be_received_.push(std::move(rewritten_msg));
 }
 
 int TranslatePepperFileReadWriteOpenFlagsForTesting(int32_t pp_open_flags) {
   return TranslatePepperFileReadWriteOpenFlags(pp_open_flags);
 }