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

extensions/browser/api/web_request/web_request_api_helpers.h

 // 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.
 
 // Helper classes and functions used for the WebRequest API.
 
 #ifndef EXTENSIONS_BROWSER_API_WEB_REQUEST_WEB_REQUEST_API_HELPERS_H_
 #define EXTENSIONS_BROWSER_API_WEB_REQUEST_WEB_REQUEST_API_HELPERS_H_
 
 #include <list>
+#include <memory>
 #include <set>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "content/public/common/resource_type.h"
 #include "extensions/browser/warning_set.h"
 #include "net/base/auth.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "url/gurl.h"
 
 namespace base {
 class ListValue;
@@ skipping 31 matching lines @@
   };
 
   static bool InitFromValue(const base::ListValue& value, int* extra_info_spec);
 };
 
 // Data container for RequestCookies as defined in the declarative WebRequest
 // API definition.
 struct RequestCookie {
   RequestCookie();
   ~RequestCookie();
-  scoped_ptr<std::string> name;
-  scoped_ptr<std::string> value;
+  std::unique_ptr<std::string> name;
+  std::unique_ptr<std::string> value;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(RequestCookie);
 };
 
 bool NullableEquals(const RequestCookie* a, const RequestCookie* b);
 
 // Data container for ResponseCookies as defined in the declarative WebRequest
 // API definition.
 struct ResponseCookie {
   ResponseCookie();
   ~ResponseCookie();
-  scoped_ptr<std::string> name;
-  scoped_ptr<std::string> value;
-  scoped_ptr<std::string> expires;
-  scoped_ptr<int> max_age;
-  scoped_ptr<std::string> domain;
-  scoped_ptr<std::string> path;
-  scoped_ptr<bool> secure;
-  scoped_ptr<bool> http_only;
+  std::unique_ptr<std::string> name;
+  std::unique_ptr<std::string> value;
+  std::unique_ptr<std::string> expires;
+  std::unique_ptr<int> max_age;
+  std::unique_ptr<std::string> domain;
+  std::unique_ptr<std::string> path;
+  std::unique_ptr<bool> secure;
+  std::unique_ptr<bool> http_only;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(ResponseCookie);
 };
 
 bool NullableEquals(const ResponseCookie* a, const ResponseCookie* b);
 
 // Data container for FilterResponseCookies as defined in the declarative
 // WebRequest API definition.
 struct FilterResponseCookie : ResponseCookie {
   FilterResponseCookie();
   ~FilterResponseCookie();
-  scoped_ptr<int> age_lower_bound;
-  scoped_ptr<int> age_upper_bound;
-  scoped_ptr<bool> session_cookie;
+  std::unique_ptr<int> age_lower_bound;
+  std::unique_ptr<int> age_upper_bound;
+  std::unique_ptr<bool> session_cookie;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(FilterResponseCookie);
 };
 
 bool NullableEquals(const FilterResponseCookie* a,
                     const FilterResponseCookie* b);
 
 enum CookieModificationType {
   ADD,
   EDIT,
   REMOVE,
 };
 
 struct RequestCookieModification {
   RequestCookieModification();
   ~RequestCookieModification();
   CookieModificationType type;
   // Used for EDIT and REMOVE. NULL for ADD.
-  scoped_ptr<RequestCookie> filter;
+  std::unique_ptr<RequestCookie> filter;
   // Used for ADD and EDIT. NULL for REMOVE.
-  scoped_ptr<RequestCookie> modification;
+  std::unique_ptr<RequestCookie> modification;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(RequestCookieModification);
 };
 
 bool NullableEquals(const RequestCookieModification* a,
                     const RequestCookieModification* b);
 
 struct ResponseCookieModification {
   ResponseCookieModification();
   ~ResponseCookieModification();
   CookieModificationType type;
   // Used for EDIT and REMOVE.
-  scoped_ptr<FilterResponseCookie> filter;
+  std::unique_ptr<FilterResponseCookie> filter;
   // Used for ADD and EDIT.
-  scoped_ptr<ResponseCookie> modification;
+  std::unique_ptr<ResponseCookie> modification;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(ResponseCookieModification);
 };
 
 bool NullableEquals(const ResponseCookieModification* a,
                     const ResponseCookieModification* b);
 
 typedef std::vector<linked_ptr<RequestCookieModification> >
     RequestCookieModifications;
 typedef std::vector<linked_ptr<ResponseCookieModification> >
@@ skipping 20 matching lines @@
   std::vector<std::string> deleted_request_headers;
 
   // Headers that were added to the response. A modification of a header
   // corresponds to a deletion and subsequent addition of the new header.
   ResponseHeaders added_response_headers;
 
   // Headers that were deleted from the response.
   ResponseHeaders deleted_response_headers;
 
   // Authentication Credentials to use.
-  scoped_ptr<net::AuthCredentials> auth_credentials;
+  std::unique_ptr<net::AuthCredentials> auth_credentials;
 
   // Modifications to cookies in request headers.
   RequestCookieModifications request_cookie_modifications;
 
   // Modifications to cookies in response headers.
   ResponseCookieModifications response_cookie_modifications;
 
   // Messages that shall be sent to the background/event/... pages of the
   // extension.
   std::set<std::string> messages_to_extension;
@@ skipping 45 matching lines @@
     bool cancel,
     const GURL& new_url,
     const net::HttpResponseHeaders* old_response_headers,
     ResponseHeaders* new_response_headers);
 // Destructively moves the auth credentials from |auth_credentials| to the
 // returned EventResponseDelta.
 EventResponseDelta* CalculateOnAuthRequiredDelta(
     const std::string& extension_id,
     const base::Time& extension_install_time,
     bool cancel,
-    scoped_ptr<net::AuthCredentials>* auth_credentials);
+    std::unique_ptr<net::AuthCredentials>* auth_credentials);
 
 // These functions merge the responses (the |deltas|) of request handlers.
 // The |deltas| need to be sorted in decreasing order of precedence of
 // extensions. In case extensions had |deltas| that could not be honored, their
 // IDs are reported in |conflicting_extensions|. NetLog events that shall be
 // reported will be stored in |event_log_entries|.
 
 // Stores in |canceled| whether any extension wanted to cancel the request.
 void MergeCancelOfResponses(
     const EventResponseDeltas& deltas,
@@ skipping 94 matching lines @@
 
 // Stores a |content::ResourceType| representation in |types| if |type_str| is
 // a resource type handled by the web request API. Returns true in case of
 // success.
 bool ParseResourceType(const std::string& type_str,
                        std::vector<content::ResourceType>* types);
 
 }  // namespace extension_web_request_api_helpers
 
 #endif  // EXTENSIONS_BROWSER_API_WEB_REQUEST_WEB_REQUEST_API_HELPERS_H_