Convert //ios from scoped_ptr to std::unique_ptr.

ios/net/crn_http_protocol_handler.mm

 // Copyright 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.
 
 #import "ios/net/crn_http_protocol_handler.h"
 
 #include <stdint.h>
 
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #import "ios/net/clients/crn_network_client_protocol.h"
 #import "ios/net/crn_http_protocol_handler_proxy_with_client_thread.h"
 #import "ios/net/http_protocol_logging.h"
 #include "ios/net/nsurlrequest_util.h"
 #import "ios/net/protocol_handler_util.h"
 #include "ios/net/request_tracker.h"
@@ skipping 163 matching lines @@
   // NSURLProtocol client, and the following clients are ordered such as the
   // ith client is responsible for managing the (i-1)th client.
   base::scoped_nsobject<NSMutableArray> clients_;
   // Weak. This is the last client in |clients_|.
   id<CRNNetworkClientProtocol> top_level_client_;
   scoped_refptr<IOBuffer> buffer_;
   base::scoped_nsobject<NSMutableURLRequest> request_;
   // Stream delegate to read the HTTPBodyStream.
   base::scoped_nsobject<CRWHTTPStreamDelegate> stream_delegate_;
   // Vector of readers used to accumulate a POST data stream.
-  std::vector<scoped_ptr<UploadElementReader>> post_data_readers_;
+  std::vector<std::unique_ptr<UploadElementReader>> post_data_readers_;
 
   // This cannot be a scoped pointer because it must be deleted on the IO
   // thread.
   URLRequest* net_request_;
 
   base::WeakPtr<RequestTracker> tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpProtocolHandlerCore);
 };
 
@@ skipping 23 matching lines @@
           << "Failed to read POST data: "
           << base::SysNSStringToUTF8([[stream streamError] description]);
       StopListeningStream(stream);
       StopRequestWithError(NSURLErrorUnknown, ERR_UNEXPECTED);
       break;
     case NSStreamEventEndEncountered:
       StopListeningStream(stream);
       if (!post_data_readers_.empty()) {
         // NOTE: This call will result in |post_data_readers_| being cleared,
         // which is the desired behavior.
-        net_request_->set_upload(make_scoped_ptr(
+        net_request_->set_upload(base::WrapUnique(
             new ElementsUploadDataStream(std::move(post_data_readers_), 0)));
         DCHECK(post_data_readers_.empty());
       }
       net_request_->Start();
       if (tracker_)
         tracker_->StartRequest(net_request_);
       break;
     case NSStreamEventHasBytesAvailable: {
       NSUInteger length;
       DCHECK([stream isKindOfClass:[NSInputStream class]]);
       length = [(NSInputStream*)stream read:(unsigned char*)buffer_->data()
                                   maxLength:kIOBufferSize];
       if (length) {
         std::vector<char> owned_data(buffer_->data(), buffer_->data() + length);
         post_data_readers_.push_back(
-            make_scoped_ptr(new UploadOwnedBytesElementReader(&owned_data)));
+            base::WrapUnique(new UploadOwnedBytesElementReader(&owned_data)));
       }
       break;
     }
     case NSStreamEventNone:
     case NSStreamEventOpenCompleted:
     case NSStreamEventHasSpaceAvailable:
       break;
     default:
       NOTREACHED() << "Unexpected stream event: " << event;
       break;
@@ skipping 441 matching lines @@
     [input_stream open];
     // The request will be started when the stream is fully read.
     return;
   }
 
   NSData* body = [request_ HTTPBody];
   const NSUInteger body_length = [body length];
   if (body_length > 0) {
     const char* source_bytes = reinterpret_cast<const char*>([body bytes]);
     std::vector<char> owned_data(source_bytes, source_bytes + body_length);
-    scoped_ptr<UploadElementReader> reader(
+    std::unique_ptr<UploadElementReader> reader(
         new UploadOwnedBytesElementReader(&owned_data));
     net_request_->set_upload(
         ElementsUploadDataStream::CreateWithReader(std::move(reader), 0));
   }
 
   net_request_->Start();
   if (tracker_)
     tracker_->StartRequest(net_request_);
 }
 
@@ skipping 360 matching lines @@
       [[DeferredCancellation alloc] initWithCore:[self getCore]];
   NSArray* modes = @[ [[NSRunLoop currentRunLoop] currentMode] ];
   [cancellation performSelector:@selector(cancel)
                        onThread:[self getClientThread]
                      withObject:nil
                   waitUntilDone:NO
                           modes:modes];
 }
 
 @end