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

extensions/browser/api/declarative_webrequest/webrequest_action.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/declarative_webrequest/webrequest_action.h"
 
 #include <limits>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 35 matching lines @@
     "EUgAAAAEAAAABCAYAAAAfFcSJAAAACklEQVR4nGMAAQAABQABDQottAAAAABJRU5ErkJggg==";
 const char kEmptyDocumentUrl[] = "data:text/html,";
 
 #define INPUT_FORMAT_VALIDATE(test) do { \
     if (!(test)) { \
       *bad_message = true; \
       return scoped_refptr<const WebRequestAction>(NULL); \
     } \
   } while (0)
 
-scoped_ptr<helpers::RequestCookie> ParseRequestCookie(
+std::unique_ptr<helpers::RequestCookie> ParseRequestCookie(
     const base::DictionaryValue* dict) {
-  scoped_ptr<helpers::RequestCookie> result(new helpers::RequestCookie);
+  std::unique_ptr<helpers::RequestCookie> result(new helpers::RequestCookie);
   std::string tmp;
   if (dict->GetString(keys::kNameKey, &tmp))
     result->name.reset(new std::string(tmp));
   if (dict->GetString(keys::kValueKey, &tmp))
     result->value.reset(new std::string(tmp));
   return result;
 }
 
 void ParseResponseCookieImpl(const base::DictionaryValue* dict,
                              helpers::ResponseCookie* cookie) {
@@ skipping 11 matching lines @@
   if (dict->GetString(keys::kDomainKey, &string_tmp))
     cookie->domain.reset(new std::string(string_tmp));
   if (dict->GetString(keys::kPathKey, &string_tmp))
     cookie->path.reset(new std::string(string_tmp));
   if (dict->GetBoolean(keys::kSecureKey, &bool_tmp))
     cookie->secure.reset(new bool(bool_tmp));
   if (dict->GetBoolean(keys::kHttpOnlyKey, &bool_tmp))
     cookie->http_only.reset(new bool(bool_tmp));
 }
 
-scoped_ptr<helpers::ResponseCookie> ParseResponseCookie(
+std::unique_ptr<helpers::ResponseCookie> ParseResponseCookie(
     const base::DictionaryValue* dict) {
-  scoped_ptr<helpers::ResponseCookie> result(new helpers::ResponseCookie);
+  std::unique_ptr<helpers::ResponseCookie> result(new helpers::ResponseCookie);
   ParseResponseCookieImpl(dict, result.get());
   return result;
 }
 
-scoped_ptr<helpers::FilterResponseCookie> ParseFilterResponseCookie(
+std::unique_ptr<helpers::FilterResponseCookie> ParseFilterResponseCookie(
     const base::DictionaryValue* dict) {
-  scoped_ptr<helpers::FilterResponseCookie> result(
+  std::unique_ptr<helpers::FilterResponseCookie> result(
       new helpers::FilterResponseCookie);
   ParseResponseCookieImpl(dict, result.get());
 
   int int_tmp = 0;
   bool bool_tmp = false;
   if (dict->GetInteger(keys::kAgeUpperBoundKey, &int_tmp))
     result->age_upper_bound.reset(new int(int_tmp));
   if (dict->GetInteger(keys::kAgeLowerBoundKey, &int_tmp))
     result->age_lower_bound.reset(new int(int_tmp));
   if (dict->GetBoolean(keys::kSessionCookieKey, &bool_tmp))
@@ skipping 36 matching lines @@
   CHECK(value->GetAsDictionary(&dict));
   std::string from;
   std::string to;
   INPUT_FORMAT_VALIDATE(dict->GetString(keys::kFromKey, &from));
   INPUT_FORMAT_VALIDATE(dict->GetString(keys::kToKey, &to));
 
   to = WebRequestRedirectByRegExAction::PerlToRe2Style(to);
 
   RE2::Options options;
   options.set_case_sensitive(false);
-  scoped_ptr<RE2> from_pattern(new RE2(from, options));
+  std::unique_ptr<RE2> from_pattern(new RE2(from, options));
 
   if (!from_pattern->ok()) {
     *error = "Invalid pattern '" + from + "' -> '" + to + "'";
     return scoped_refptr<const WebRequestAction>(NULL);
   }
   return scoped_refptr<const WebRequestAction>(
       new WebRequestRedirectByRegExAction(std::move(from_pattern), to));
 }
 
 scoped_refptr<const WebRequestAction> CreateSetRequestHeaderAction(
@@ skipping 521 matching lines @@
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   result->new_url = GURL(kEmptyDocumentUrl);
   return result;
 }
 
 //
 // WebRequestRedirectByRegExAction
 //
 
 WebRequestRedirectByRegExAction::WebRequestRedirectByRegExAction(
-    scoped_ptr<RE2> from_pattern,
+    std::unique_ptr<RE2> from_pattern,
     const std::string& to_pattern)
     : WebRequestAction(ON_BEFORE_REQUEST | ON_HEADERS_RECEIVED,
                        ACTION_REDIRECT_BY_REGEX_DOCUMENT,
                        std::numeric_limits<int>::min(),
                        STRATEGY_DEFAULT),
       from_pattern_(std::move(from_pattern)),
       to_pattern_(to_pattern.data(), to_pattern.size()) {}
 
 WebRequestRedirectByRegExAction::~WebRequestRedirectByRegExAction() {}
 
@@ skipping 449 matching lines @@
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & stages());
   LinkedPtrEventResponseDelta result(
       new extension_web_request_api_helpers::EventResponseDelta(
           extension_id, extension_install_time));
   result->messages_to_extension.insert(message_);
   return result;
 }
 
 }  // namespace extensions