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

ios/net/protocol_handler_util_unittest.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/protocol_handler_util.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/mac/scoped_nsobject.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/sys_string_conversions.h"
 #include "net/base/elements_upload_data_stream.h"
 #import "net/base/mac/url_conversions.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/data_protocol_handler.h"
 #include "net/url_request/url_request.h"
@@ skipping 86 matching lines @@
     return new HeadersURLRequestJob(request);
   }
 };
 
 class ProtocolHandlerUtilTest : public testing::Test,
                                 public URLRequest::Delegate {
  public:
   ProtocolHandlerUtilTest() : request_context_(new TestURLRequestContext) {
     // Ownership of the protocol handlers is transferred to the factory.
     job_factory_.SetProtocolHandler("http",
-                                    make_scoped_ptr(new NetProtocolHandler));
+                                    base::WrapUnique(new NetProtocolHandler));
     job_factory_.SetProtocolHandler("data",
-                                    make_scoped_ptr(new DataProtocolHandler));
+                                    base::WrapUnique(new DataProtocolHandler));
     request_context_->set_job_factory(&job_factory_);
   }
 
   NSURLResponse* BuildDataURLResponse(const std::string& mime_type,
                                       const std::string& encoding,
                                       const std::string& content) {
     // Build an URL in the form "data:<mime_type>;charset=<encoding>,<content>"
     // The ';' is removed if mime_type or charset is empty.
     std::string url_string = std::string("data:") + mime_type;
     if (!encoding.empty())
       url_string += ";charset=" + encoding;
     url_string += ",";
     GURL url(url_string);
 
-    scoped_ptr<URLRequest> request(
+    std::unique_ptr<URLRequest> request(
         request_context_->CreateRequest(url, DEFAULT_PRIORITY, this));
     request->Start();
     base::RunLoop loop;
     loop.RunUntilIdle();
     return GetNSURLResponseForRequest(request.get());
   }
 
   void CheckDataResponse(NSURLResponse* response,
                          const std::string& mime_type,
                          const std::string& encoding) {
     EXPECT_NSEQ(base::SysUTF8ToNSString(mime_type), [response MIMEType]);
     EXPECT_NSEQ(base::SysUTF8ToNSString(encoding), [response textEncodingName]);
     // The response class must be NSURLResponse (and not NSHTTPURLResponse) when
     // the scheme is "data".
     EXPECT_TRUE([response isMemberOfClass:[NSURLResponse class]]);
   }
 
   void OnResponseStarted(URLRequest* request) override {}
   void OnReadCompleted(URLRequest* request, int bytes_read) override {}
 
  protected:
   base::MessageLoop loop_;
   URLRequestJobFactoryImpl job_factory_;
-  scoped_ptr<URLRequestContext> request_context_;
+  std::unique_ptr<URLRequestContext> request_context_;
 };
 
 }  // namespace
 
 TEST_F(ProtocolHandlerUtilTest, GetResponseDataSchemeTest) {
   NSURLResponse* response;
   // MIME type and charset are correctly carried over.
   response = BuildDataURLResponse("#mime=type'", "$(charset-*", "content");
   CheckDataResponse(response, "#mime=type'", "$(charset-*");
   // Missing values are treated as default values.
   response = BuildDataURLResponse("", "", "content");
   CheckDataResponse(response, kTextPlain, kAscii);
 }
 
 TEST_F(ProtocolHandlerUtilTest, GetResponseHttpTest) {
   // Create a request.
   GURL url(std::string("http://url"));
-  scoped_ptr<URLRequest> request(
+  std::unique_ptr<URLRequest> request(
       request_context_->CreateRequest(url, DEFAULT_PRIORITY, this));
   request->Start();
   // Create a response from the request.
   NSURLResponse* response = GetNSURLResponseForRequest(request.get());
   EXPECT_NSEQ([NSString stringWithUTF8String:kTextHtml], [response MIMEType]);
   ASSERT_TRUE([response isKindOfClass:[NSHTTPURLResponse class]]);
   NSHTTPURLResponse* http_response = (NSHTTPURLResponse*)response;
   NSDictionary* headers = [http_response allHeaderFields];
   // Check the headers, duplicates must be appended.
   EXPECT_EQ(5u, [headers count]);
   NSString* foo_header = [headers objectForKey:@"Foo"];
   EXPECT_NSEQ(@"A,D,E", foo_header);
   NSString* bar_header = [headers objectForKey:@"Bar"];
   EXPECT_NSEQ(@"B,F", bar_header);
   NSString* baz_header = [headers objectForKey:@"Baz"];
   EXPECT_NSEQ(@"C", baz_header);
   NSString* cache_header = [headers objectForKey:@"Cache-Control"];
   EXPECT_NSEQ(@"no-store", cache_header);  // Cache-Control is overridden.
   // Check the status.
   EXPECT_EQ(request->GetResponseCode(), [http_response statusCode]);
 }
 
 TEST_F(ProtocolHandlerUtilTest, BadHttpContentType) {
   // Create a request using the magic domain that triggers a garbage
   // content-type in the test framework.
   GURL url(std::string("http://badcontenttype"));
-  scoped_ptr<URLRequest> request(
+  std::unique_ptr<URLRequest> request(
       request_context_->CreateRequest(url, DEFAULT_PRIORITY, this));
   request->Start();
   // Create a response from the request.
   @try {
     GetNSURLResponseForRequest(request.get());
   }
   @catch (id exception) {
     FAIL() << "Exception while creating response";
   }
 }
 
 TEST_F(ProtocolHandlerUtilTest, MultipleHttpContentType) {
   // Create a request using the magic domain that triggers a garbage
   // content-type in the test framework.
   GURL url(std::string("http://multiplecontenttype"));
-  scoped_ptr<URLRequest> request(
+  std::unique_ptr<URLRequest> request(
       request_context_->CreateRequest(url, DEFAULT_PRIORITY, this));
   request->Start();
   // Create a response from the request.
   NSURLResponse* response = GetNSURLResponseForRequest(request.get());
   EXPECT_NSEQ(@"text/plain", [response MIMEType]);
   EXPECT_NSEQ(@"iso-8859-4", [response textEncodingName]);
   NSHTTPURLResponse* http_response = (NSHTTPURLResponse*)response;
   NSDictionary* headers = [http_response allHeaderFields];
   NSString* content_type_header = [headers objectForKey:@"Content-Type"];
   EXPECT_NSEQ(@"text/plain; charset=iso-8859-4", content_type_header);
 }
 
 TEST_F(ProtocolHandlerUtilTest, CopyHttpHeaders) {
   GURL url(std::string("http://url"));
   base::scoped_nsobject<NSMutableURLRequest> in_request(
       [[NSMutableURLRequest alloc] initWithURL:NSURLWithGURL(url)]);
   [in_request setAllHTTPHeaderFields:@{
       @"Referer" : @"referrer",
       @"User-Agent" : @"secret",
       @"Accept" : @"money/cash",
       @"Foo" : @"bar",
   }];
-  scoped_ptr<URLRequest> out_request(
+  std::unique_ptr<URLRequest> out_request(
       request_context_->CreateRequest(url, DEFAULT_PRIORITY, nullptr));
   CopyHttpHeaders(in_request, out_request.get());
 
   EXPECT_EQ("referrer", out_request->referrer());
   const HttpRequestHeaders& headers = out_request->extra_request_headers();
   EXPECT_FALSE(headers.HasHeader("User-Agent"));    // User agent is not copied.
   EXPECT_FALSE(headers.HasHeader("Content-Type"));  // Only in POST requests.
   std::string header;
   EXPECT_TRUE(headers.GetHeader("Accept", &header));
   EXPECT_EQ("money/cash", header);
   EXPECT_TRUE(headers.GetHeader("Foo", &header));
   EXPECT_EQ("bar", header);
 }
 
 TEST_F(ProtocolHandlerUtilTest, AddMissingHeaders) {
   GURL url(std::string("http://url"));
   base::scoped_nsobject<NSMutableURLRequest> in_request(
       [[NSMutableURLRequest alloc] initWithURL:NSURLWithGURL(url)]);
-  scoped_ptr<URLRequest> out_request(
+  std::unique_ptr<URLRequest> out_request(
       request_context_->CreateRequest(url, DEFAULT_PRIORITY, nullptr));
   out_request->set_method("POST");
-  scoped_ptr<UploadElementReader> reader(
+  std::unique_ptr<UploadElementReader> reader(
       new UploadBytesElementReader(nullptr, 0));
   out_request->set_upload(
       ElementsUploadDataStream::CreateWithReader(std::move(reader), 0));
   CopyHttpHeaders(in_request, out_request.get());
 
   // Some headers are added by default if missing.
   const HttpRequestHeaders& headers = out_request->extra_request_headers();
   std::string header;
   EXPECT_TRUE(headers.GetHeader("Accept", &header));
   EXPECT_EQ("*/*", header);
   EXPECT_TRUE(headers.GetHeader("Content-Type", &header));
   EXPECT_EQ("application/x-www-form-urlencoded", header);
 }
 
 }  // namespace net