Remove "ScopedHandleBase<H>::operator H() const"

mojo/public/bindings/lib/connector.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/public/bindings/lib/connector.h"
 
 #include <assert.h>
 #include <stdlib.h>
 
 #include <algorithm>
@@ skipping 37 matching lines @@
 void Connector::OnHandleReady(Callback* callback, MojoResult result) {
   if (callback == &read_callback_)
     ReadMore();
   if (callback == &write_callback_)
     WriteMore();
 }
 
 void Connector::WaitToReadMore() {
   read_callback_.SetOwnerToNotify(this);
   read_callback_.SetAsyncWaitID(
-      BindingsSupport::Get()->AsyncWait(message_pipe_,
+      BindingsSupport::Get()->AsyncWait(message_pipe_.get(),
                                         MOJO_WAIT_FLAG_READABLE,
                                         &read_callback_));
 }
 
 void Connector::WaitToWriteMore() {
   write_callback_.SetOwnerToNotify(this);
   write_callback_.SetAsyncWaitID(
-      BindingsSupport::Get()->AsyncWait(message_pipe_,
+      BindingsSupport::Get()->AsyncWait(message_pipe_.get(),
                                         MOJO_WAIT_FLAG_WRITABLE,
                                         &write_callback_));
 }
 
 void Connector::ReadMore() {
   for (;;) {
     MojoResult rv;
 
     uint32_t num_bytes = 0, num_handles = 0;
-    rv = ReadMessageRaw(message_pipe_,
+    rv = ReadMessageRaw(message_pipe_.get(),
                         NULL,
                         &num_bytes,
                         NULL,
                         &num_handles,
                         MOJO_READ_MESSAGE_FLAG_NONE);
     if (rv == MOJO_RESULT_NOT_FOUND) {
       WaitToReadMore();
       break;
     }
     if (rv != MOJO_RESULT_RESOURCE_EXHAUSTED) {
       error_ = true;
       break;
     }
 
     Message message;
     message.data = static_cast<MessageData*>(malloc(num_bytes));
     message.handles.resize(num_handles);
 
-    rv = ReadMessageRaw(message_pipe_,
+    rv = ReadMessageRaw(message_pipe_.get(),
                         message.data,
                         &num_bytes,
                         message.handles.empty() ? NULL :
                             reinterpret_cast<MojoHandle*>(&message.handles[0]),
                         &num_handles,
                         MOJO_READ_MESSAGE_FLAG_NONE);
     if (rv != MOJO_RESULT_OK) {
       error_ = true;
       break;
     }
@@ skipping 16 matching lines @@
 }
 
 void Connector::WriteOne(Message* message, bool* wait_to_write) {
   // TODO(darin): WriteMessageRaw will eventually start generating an error that
   // it cannot accept more data. In that case, we'll need to wait on the pipe
   // to determine when we can try writing again. This flag will be set to true
   // in that case.
   *wait_to_write = false;
 
   MojoResult rv = WriteMessageRaw(
-      message_pipe_,
+      message_pipe_.get(),
       message->data,
       message->data->header.num_bytes,
       message->handles.empty() ? NULL :
           reinterpret_cast<const MojoHandle*>(&message->handles[0]),
       static_cast<uint32_t>(message->handles.size()),
       MOJO_WRITE_MESSAGE_FLAG_NONE);
   if (rv == MOJO_RESULT_OK) {
     // The handles were successfully transferred, so we don't need the message
     // to track their lifetime any longer.
     message->handles.clear();
@@ skipping 24 matching lines @@
 }
 
 void Connector::Callback::OnHandleReady(MojoResult result) {
   assert(owner_);
   Connector* owner = NULL;
   std::swap(owner, owner_);
   owner->OnHandleReady(this, result);
 }
 
 }  // namespace mojo