Convert mojo::system::ChannelEndpointClient to use our new refcounting stuff (instead of base's).

mojo/edk/system/data_pipe.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 "mojo/edk/system/data_pipe.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 76 matching lines @@
     return MOJO_RESULT_INVALID_ARGUMENT;
   if (reader.options().capacity_num_bytes >
       GetConfiguration().max_data_pipe_capacity_bytes)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
   out_options->capacity_num_bytes = reader.options().capacity_num_bytes;
 
   return MOJO_RESULT_OK;
 }
 
 // static
-DataPipe* DataPipe::CreateLocal(
+RefPtr<DataPipe> DataPipe::CreateLocal(
     const MojoCreateDataPipeOptions& validated_options) {
-  return new DataPipe(true, true, validated_options,
-                      util::MakeUnique<LocalDataPipeImpl>());
+  return AdoptRef(new DataPipe(true, true, validated_options,
+                               util::MakeUnique<LocalDataPipeImpl>()));
 }
 
 // static
-DataPipe* DataPipe::CreateRemoteProducerFromExisting(
+RefPtr<DataPipe> DataPipe::CreateRemoteProducerFromExisting(
     const MojoCreateDataPipeOptions& validated_options,
     MessageInTransitQueue* message_queue,
     RefPtr<ChannelEndpoint>&& channel_endpoint) {
   std::unique_ptr<char, base::AlignedFreeDeleter> buffer;
   size_t buffer_num_bytes = 0;
   if (!RemoteProducerDataPipeImpl::ProcessMessagesFromIncomingEndpoint(
           validated_options, message_queue, &buffer, &buffer_num_bytes))
     return nullptr;
 
   // Important: This is called under |IncomingEndpoint|'s (which is a
   // |ChannelEndpointClient|) lock, in particular from
   // |IncomingEndpoint::ConvertToDataPipeConsumer()|. Before releasing that
   // lock, it will reset its |endpoint_| member, which makes any later or
   // ongoing call to |IncomingEndpoint::OnReadMessage()| return false. This will
   // make |ChannelEndpoint::OnReadMessage()| retry, until its |ReplaceClient()|
   // is called.
-  DataPipe* data_pipe = new DataPipe(
+  RefPtr<DataPipe> data_pipe = AdoptRef(new DataPipe(
       false, true, validated_options,
       util::MakeUnique<RemoteProducerDataPipeImpl>(
-          channel_endpoint.Clone(), std::move(buffer), 0, buffer_num_bytes));
+          channel_endpoint.Clone(), std::move(buffer), 0, buffer_num_bytes)));
   if (channel_endpoint) {
-    if (!channel_endpoint->ReplaceClient(data_pipe, 0))
+    if (!channel_endpoint->ReplaceClient(data_pipe.Clone(), 0))
       data_pipe->OnDetachFromChannel(0);
   } else {
     data_pipe->SetProducerClosed();
   }
   return data_pipe;
 }
 
 // static
-DataPipe* DataPipe::CreateRemoteConsumerFromExisting(
+RefPtr<DataPipe> DataPipe::CreateRemoteConsumerFromExisting(
     const MojoCreateDataPipeOptions& validated_options,
     size_t consumer_num_bytes,
     MessageInTransitQueue* message_queue,
     RefPtr<ChannelEndpoint>&& channel_endpoint) {
   if (!RemoteConsumerDataPipeImpl::ProcessMessagesFromIncomingEndpoint(
           validated_options, &consumer_num_bytes, message_queue))
     return nullptr;
 
   // Important: This is called under |IncomingEndpoint|'s (which is a
   // |ChannelEndpointClient|) lock, in particular from
   // |IncomingEndpoint::ConvertToDataPipeProducer()|. Before releasing that
   // lock, it will reset its |endpoint_| member, which makes any later or
   // ongoing call to |IncomingEndpoint::OnReadMessage()| return false. This will
   // make |ChannelEndpoint::OnReadMessage()| retry, until its |ReplaceClient()|
   // is called.
-  DataPipe* data_pipe = new DataPipe(
+  RefPtr<DataPipe> data_pipe = AdoptRef(new DataPipe(
       true, false, validated_options,
       util::MakeUnique<RemoteConsumerDataPipeImpl>(
-          channel_endpoint.Clone(), consumer_num_bytes, nullptr, 0));
+          channel_endpoint.Clone(), consumer_num_bytes, nullptr, 0)));
   if (channel_endpoint) {
-    if (!channel_endpoint->ReplaceClient(data_pipe, 0))
+    if (!channel_endpoint->ReplaceClient(data_pipe.Clone(), 0))
       data_pipe->OnDetachFromChannel(0);
   } else {
     data_pipe->SetConsumerClosed();
   }
   return data_pipe;
 }
 
 // static
 bool DataPipe::ProducerDeserialize(Channel* channel,
                                    const void* source,
                                    size_t size,
-                                   scoped_refptr<DataPipe>* data_pipe) {
+                                   RefPtr<DataPipe>* data_pipe) {
   DCHECK(!*data_pipe);  // Not technically wrong, but unlikely.
 
   bool consumer_open = false;
   if (size == sizeof(SerializedDataPipeProducerDispatcher)) {
     consumer_open = false;
   } else if (size ==
              sizeof(SerializedDataPipeProducerDispatcher) +
                  channel->GetSerializedEndpointSize()) {
     consumer_open = true;
   } else {
@@ skipping 10 matching lines @@
     return false;
   }
 
   if (!consumer_open) {
     if (s->consumer_num_bytes != static_cast<size_t>(-1)) {
       LOG(ERROR)
           << "Invalid serialized data pipe producer (bad consumer_num_bytes)";
       return false;
     }
 
-    *data_pipe = new DataPipe(
+    *data_pipe = AdoptRef(new DataPipe(
         true, false, revalidated_options,
-        util::MakeUnique<RemoteConsumerDataPipeImpl>(nullptr, 0, nullptr, 0));
+        util::MakeUnique<RemoteConsumerDataPipeImpl>(nullptr, 0, nullptr, 0)));
     (*data_pipe)->SetConsumerClosed();
 
     return true;
   }
 
   if (s->consumer_num_bytes > revalidated_options.capacity_num_bytes ||
       s->consumer_num_bytes % revalidated_options.element_num_bytes != 0) {
     LOG(ERROR)
         << "Invalid serialized data pipe producer (bad consumer_num_bytes)";
     return false;
   }
 
   const void* endpoint_source = static_cast<const char*>(source) +
                                 sizeof(SerializedDataPipeProducerDispatcher);
-  scoped_refptr<IncomingEndpoint> incoming_endpoint =
+  RefPtr<IncomingEndpoint> incoming_endpoint =
       channel->DeserializeEndpoint(endpoint_source);
   if (!incoming_endpoint)
     return false;
 
   *data_pipe = incoming_endpoint->ConvertToDataPipeProducer(
       revalidated_options, s->consumer_num_bytes);
   if (!*data_pipe)
     return false;
 
   return true;
 }
 
 // static
 bool DataPipe::ConsumerDeserialize(Channel* channel,
                                    const void* source,
                                    size_t size,
-                                   scoped_refptr<DataPipe>* data_pipe) {
+                                   RefPtr<DataPipe>* data_pipe) {
   DCHECK(!*data_pipe);  // Not technically wrong, but unlikely.
 
   if (size !=
       sizeof(SerializedDataPipeConsumerDispatcher) +
           channel->GetSerializedEndpointSize()) {
     LOG(ERROR) << "Invalid serialized data pipe consumer";
     return false;
   }
 
   const SerializedDataPipeConsumerDispatcher* s =
       static_cast<const SerializedDataPipeConsumerDispatcher*>(source);
   MojoCreateDataPipeOptions revalidated_options = {};
   if (ValidateCreateOptions(MakeUserPointer(&s->validated_options),
                             &revalidated_options) != MOJO_RESULT_OK) {
     LOG(ERROR) << "Invalid serialized data pipe consumer (bad options)";
     return false;
   }
 
   const void* endpoint_source = static_cast<const char*>(source) +
                                 sizeof(SerializedDataPipeConsumerDispatcher);
-  scoped_refptr<IncomingEndpoint> incoming_endpoint =
+  RefPtr<IncomingEndpoint> incoming_endpoint =
       channel->DeserializeEndpoint(endpoint_source);
   if (!incoming_endpoint)
     return false;
 
   *data_pipe =
       incoming_endpoint->ConvertToDataPipeConsumer(revalidated_options);
   if (!*data_pipe)
     return false;
 
   return true;
@@ skipping 538 matching lines @@
   SetProducerClosedNoLock();
 }
 
 void DataPipe::SetConsumerClosed() {
   MutexLocker locker(&mutex_);
   SetConsumerClosedNoLock();
 }
 
 }  // namespace system
 }  // namespace mojo