Convert //extensions/browser/api from scoped_ptr to std::unique_ptr

extensions/browser/api/web_request/form_data_parser.cc

 // Copyright (c) 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.
 
 #include "extensions/browser/api/web_request/form_data_parser.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 278 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(FormDataParserMultipart);
 };
 
 FormDataParser::Result::Result() {}
 FormDataParser::Result::~Result() {}
 
 FormDataParser::~FormDataParser() {}
 
 // static
-scoped_ptr<FormDataParser> FormDataParser::Create(
+std::unique_ptr<FormDataParser> FormDataParser::Create(
     const net::URLRequest& request) {
   std::string value;
   const bool found = request.extra_request_headers().GetHeader(
       net::HttpRequestHeaders::kContentType, &value);
   return CreateFromContentTypeHeader(found ? &value : NULL);
 }
 
 // static
-scoped_ptr<FormDataParser> FormDataParser::CreateFromContentTypeHeader(
+std::unique_ptr<FormDataParser> FormDataParser::CreateFromContentTypeHeader(
     const std::string* content_type_header) {
   enum ParserChoice {URL_ENCODED, MULTIPART, ERROR_CHOICE};
   ParserChoice choice = ERROR_CHOICE;
   std::string boundary;
 
   if (content_type_header == NULL) {
     choice = URL_ENCODED;
   } else {
     const std::string content_type(
         content_type_header->substr(0, content_type_header->find(';')));
 
     if (base::EqualsCaseInsensitiveASCII(content_type,
                                          "application/x-www-form-urlencoded")) {
       choice = URL_ENCODED;
     } else if (base::EqualsCaseInsensitiveASCII(content_type,
                                                 "multipart/form-data")) {
       static const char kBoundaryString[] = "boundary=";
       size_t offset = content_type_header->find(kBoundaryString);
       if (offset == std::string::npos) {
         // Malformed header.
-        return scoped_ptr<FormDataParser>();
+        return std::unique_ptr<FormDataParser>();
       }
       offset += sizeof(kBoundaryString) - 1;
       boundary = content_type_header->substr(
           offset, content_type_header->find(';', offset));
       if (!boundary.empty())
         choice = MULTIPART;
     }
   }
   // Other cases are unparseable, including when |content_type| is "text/plain".
 
   switch (choice) {
     case URL_ENCODED:
-      return scoped_ptr<FormDataParser>(new FormDataParserUrlEncoded());
+      return std::unique_ptr<FormDataParser>(new FormDataParserUrlEncoded());
     case MULTIPART:
-      return scoped_ptr<FormDataParser>(new FormDataParserMultipart(boundary));
+      return std::unique_ptr<FormDataParser>(
+          new FormDataParserMultipart(boundary));
     case ERROR_CHOICE:
-      return scoped_ptr<FormDataParser>();
+      return std::unique_ptr<FormDataParser>();
   }
   NOTREACHED();  // Some compilers do not believe this is unreachable.
-  return scoped_ptr<FormDataParser>();
+  return std::unique_ptr<FormDataParser>();
 }
 
 FormDataParser::FormDataParser() {}
 
 const net::UnescapeRule::Type FormDataParserUrlEncoded::unescape_rules_ =
     net::UnescapeRule::PATH_SEPARATORS |
     net::UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS |
     net::UnescapeRule::SPOOFING_AND_CONTROL_CHARS | net::UnescapeRule::SPACES |
     net::UnescapeRule::REPLACE_PLUS_WITH_SPACE;
 
@@ skipping 232 matching lines @@
   if (value_pattern().Match(header,
                             kContentDispositionLength, header.size(),
                             RE2::UNANCHORED, groups, 2)) {
     value->set(groups[1].data(), groups[1].size());
     *value_assigned = true;
   }
   return true;
 }
 
 }  // namespace extensions