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

extensions/browser/api/web_request/web_request_api.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/web_request_api.h"
 
 #include <stddef.h>
 
 #include <algorithm>
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/child_process_host.h"
@@ skipping 198 matching lines @@
 // |extension_id| identifies the extension that sends and receives the event.
 // |is_web_view_guest| indicates whether the action is for a <webview>.
 // |web_view_info| is a struct containing information about the <webview>
 // embedder.
 // |event_details| is passed to the event listener.
 void SendOnMessageEventOnUI(
     void* browser_context_id,
     const std::string& extension_id,
     bool is_web_view_guest,
     const WebViewRendererState::WebViewInfo& web_view_info,
-    scoped_ptr<WebRequestEventDetails> event_details) {
+    std::unique_ptr<WebRequestEventDetails> event_details) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   content::BrowserContext* browser_context =
       reinterpret_cast<content::BrowserContext*>(browser_context_id);
   if (!ExtensionsBrowserClient::Get()->IsValidContext(browser_context))
     return;
 
-  scoped_ptr<base::ListValue> event_args(new base::ListValue);
+  std::unique_ptr<base::ListValue> event_args(new base::ListValue);
   event_details->DetermineFrameIdOnUI();
   event_args->Append(event_details->GetAndClearDict());
 
   EventRouter* event_router = EventRouter::Get(browser_context);
 
   EventFilteringInfo event_filtering_info;
 
   events::HistogramValue histogram_value = events::UNKNOWN;
   std::string event_name;
   // The instance ID uniquely identifies a <webview> instance within an embedder
   // process. We use a filter here so that only event listeners for a particular
   // <webview> will fire.
   if (is_web_view_guest) {
     event_filtering_info.SetInstanceID(web_view_info.instance_id);
     histogram_value = events::WEB_VIEW_INTERNAL_ON_MESSAGE;
     event_name = webview::kEventMessage;
   } else {
     histogram_value = events::DECLARATIVE_WEB_REQUEST_ON_MESSAGE;
     event_name = declarative_keys::kOnMessage;
   }
 
-  scoped_ptr<Event> event(new Event(
+  std::unique_ptr<Event> event(new Event(
       histogram_value, event_name, std::move(event_args), browser_context,
       GURL(), EventRouter::USER_GESTURE_UNKNOWN, event_filtering_info));
   event_router->DispatchEventToExtension(extension_id, std::move(event));
 }
 
 void RemoveEventListenerOnIOThread(
     void* browser_context,
     const std::string& extension_id,
     const std::string& sub_event_name,
     int embedder_process_id,
@@ skipping 309 matching lines @@
     void* browser_context,
     int rules_registry_id,
     scoped_refptr<WebRequestRulesRegistry> rules_registry) {
   RulesRegistryKey key(browser_context, rules_registry_id);
   if (rules_registry.get())
     rules_registries_[key] = rules_registry;
   else
     rules_registries_.erase(key);
 }
 
-scoped_ptr<WebRequestEventDetails>
+std::unique_ptr<WebRequestEventDetails>
 ExtensionWebRequestEventRouter::CreateEventDetails(
     const net::URLRequest* request,
     int extra_info_spec) {
-  scoped_ptr<WebRequestEventDetails> event_details(
+  std::unique_ptr<WebRequestEventDetails> event_details(
       new WebRequestEventDetails(request, extra_info_spec));
 
   int render_frame_id = -1;
   int render_process_id = -1;
   int tab_id = -1;
   ExtensionApiFrameIdMap::FrameData frame_data;
   if (content::ResourceRequestInfo::GetRenderFrameForRequest(
           request, &render_process_id, &render_frame_id) &&
       ExtensionApiFrameIdMap::Get()->GetCachedFrameDataOnIO(
           render_process_id, render_frame_id, &frame_data)) {
@@ skipping 27 matching lines @@
       ProcessDeclarativeRules(browser_context, extension_info_map,
                               web_request::OnBeforeRequest::kEventName, request,
                               ON_BEFORE_REQUEST, NULL);
 
   int extra_info_spec = 0;
   EventListeners listeners = GetMatchingListeners(
       browser_context, extension_info_map,
       web_request::OnBeforeRequest::kEventName, request, &extra_info_spec);
   if (!listeners.empty() &&
       !GetAndSetSignaled(request->identifier(), kOnBeforeRequest)) {
-    scoped_ptr<WebRequestEventDetails> event_details(
+    std::unique_ptr<WebRequestEventDetails> event_details(
         CreateEventDetails(request, extra_info_spec));
     event_details->SetRequestBody(request);
 
     initialize_blocked_requests |= DispatchEvent(
         browser_context, request, listeners, std::move(event_details));
   }
 
   if (!initialize_blocked_requests)
     return net::OK;  // Nobody saw a reason for modifying the request.
 
@@ skipping 28 matching lines @@
   initialize_blocked_requests |= ProcessDeclarativeRules(
       browser_context, extension_info_map, keys::kOnBeforeSendHeadersEvent,
       request, ON_BEFORE_SEND_HEADERS, NULL);
 
   int extra_info_spec = 0;
   EventListeners listeners = GetMatchingListeners(
       browser_context, extension_info_map, keys::kOnBeforeSendHeadersEvent,
       request, &extra_info_spec);
   if (!listeners.empty() &&
       !GetAndSetSignaled(request->identifier(), kOnBeforeSendHeaders)) {
-    scoped_ptr<WebRequestEventDetails> event_details(
+    std::unique_ptr<WebRequestEventDetails> event_details(
         CreateEventDetails(request, extra_info_spec));
     event_details->SetRequestHeaders(*headers);
 
     initialize_blocked_requests |= DispatchEvent(
         browser_context, request, listeners, std::move(event_details));
   }
 
   if (!initialize_blocked_requests)
     return net::OK;  // Nobody saw a reason for modifying the request.
 
@@ skipping 27 matching lines @@
 
   ClearSignaled(request->identifier(), kOnBeforeRedirect);
 
   int extra_info_spec = 0;
   EventListeners listeners = GetMatchingListeners(
       browser_context, extension_info_map, keys::kOnSendHeadersEvent, request,
       &extra_info_spec);
   if (listeners.empty())
     return;
 
-  scoped_ptr<WebRequestEventDetails> event_details(
+  std::unique_ptr<WebRequestEventDetails> event_details(
       CreateEventDetails(request, extra_info_spec));
   event_details->SetRequestHeaders(headers);
 
   DispatchEvent(browser_context, request, listeners, std::move(event_details));
 }
 
 int ExtensionWebRequestEventRouter::OnHeadersReceived(
     void* browser_context,
     const InfoMap* extension_info_map,
     net::URLRequest* request,
@@ skipping 10 matching lines @@
       browser_context, extension_info_map, keys::kOnHeadersReceivedEvent,
       request, ON_HEADERS_RECEIVED, original_response_headers);
 
   int extra_info_spec = 0;
   EventListeners listeners = GetMatchingListeners(
       browser_context, extension_info_map, keys::kOnHeadersReceivedEvent,
       request, &extra_info_spec);
 
   if (!listeners.empty() &&
       !GetAndSetSignaled(request->identifier(), kOnHeadersReceived)) {
-    scoped_ptr<WebRequestEventDetails> event_details(
+    std::unique_ptr<WebRequestEventDetails> event_details(
         CreateEventDetails(request, extra_info_spec));
     event_details->SetResponseHeaders(request, original_response_headers);
 
     initialize_blocked_requests |= DispatchEvent(
         browser_context, request, listeners, std::move(event_details));
   }
 
   if (!initialize_blocked_requests)
     return net::OK;  // Nobody saw a reason for modifying the request.
 
@@ skipping 31 matching lines @@
     return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
   }
 
   int extra_info_spec = 0;
   EventListeners listeners = GetMatchingListeners(
       browser_context, extension_info_map, keys::kOnAuthRequiredEvent, request,
       &extra_info_spec);
   if (listeners.empty())
     return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
 
-  scoped_ptr<WebRequestEventDetails> event_details(
+  std::unique_ptr<WebRequestEventDetails> event_details(
       CreateEventDetails(request, extra_info_spec));
   event_details->SetResponseHeaders(request, request->response_headers());
   event_details->SetAuthInfo(auth_info);
 
   if (DispatchEvent(browser_context, request, listeners,
                     std::move(event_details))) {
     BlockedRequest& blocked_request = blocked_requests_[request->identifier()];
     blocked_request.event = kOnAuthRequired;
     blocked_request.is_incognito |= IsIncognitoBrowserContext(browser_context);
     blocked_request.request = request;
@@ skipping 21 matching lines @@
   ClearSignaled(request->identifier(), kOnSendHeaders);
   ClearSignaled(request->identifier(), kOnHeadersReceived);
 
   int extra_info_spec = 0;
   EventListeners listeners = GetMatchingListeners(
       browser_context, extension_info_map, keys::kOnBeforeRedirectEvent,
       request, &extra_info_spec);
   if (listeners.empty())
     return;
 
-  scoped_ptr<WebRequestEventDetails> event_details(
+  std::unique_ptr<WebRequestEventDetails> event_details(
       CreateEventDetails(request, extra_info_spec));
   event_details->SetResponseHeaders(request, request->response_headers());
   event_details->SetResponseSource(request);
   event_details->SetString(keys::kRedirectUrlKey, new_location.spec());
 
   DispatchEvent(browser_context, request, listeners, std::move(event_details));
 }
 
 void ExtensionWebRequestEventRouter::OnResponseStarted(
     void* browser_context,
     const InfoMap* extension_info_map,
     net::URLRequest* request) {
   if (ShouldHideEvent(browser_context, extension_info_map, request))
     return;
 
   // OnResponseStarted is even triggered, when the request was cancelled.
   if (request->status().status() != net::URLRequestStatus::SUCCESS)
     return;
 
   int extra_info_spec = 0;
   EventListeners listeners = GetMatchingListeners(
       browser_context, extension_info_map, keys::kOnResponseStartedEvent,
       request, &extra_info_spec);
   if (listeners.empty())
     return;
 
-  scoped_ptr<WebRequestEventDetails> event_details(
+  std::unique_ptr<WebRequestEventDetails> event_details(
       CreateEventDetails(request, extra_info_spec));
   event_details->SetResponseHeaders(request, request->response_headers());
   event_details->SetResponseSource(request);
 
   DispatchEvent(browser_context, request, listeners, std::move(event_details));
 }
 
 void ExtensionWebRequestEventRouter::OnCompleted(
     void* browser_context,
     const InfoMap* extension_info_map,
@@ skipping 17 matching lines @@
 
   ClearPendingCallbacks(request);
 
   int extra_info_spec = 0;
   EventListeners listeners =
       GetMatchingListeners(browser_context, extension_info_map,
                            keys::kOnCompletedEvent, request, &extra_info_spec);
   if (listeners.empty())
     return;
 
-  scoped_ptr<WebRequestEventDetails> event_details(
+  std::unique_ptr<WebRequestEventDetails> event_details(
       CreateEventDetails(request, extra_info_spec));
   event_details->SetResponseHeaders(request, request->response_headers());
   event_details->SetResponseSource(request);
 
   DispatchEvent(browser_context, request, listeners, std::move(event_details));
 }
 
 void ExtensionWebRequestEventRouter::OnErrorOccurred(
     void* browser_context,
     const InfoMap* extension_info_map,
@@ skipping 19 matching lines @@
 
   ClearPendingCallbacks(request);
 
   int extra_info_spec = 0;
   EventListeners listeners = GetMatchingListeners(
       browser_context, extension_info_map,
       web_request::OnErrorOccurred::kEventName, request, &extra_info_spec);
   if (listeners.empty())
     return;
 
-  scoped_ptr<WebRequestEventDetails> event_details(
+  std::unique_ptr<WebRequestEventDetails> event_details(
       CreateEventDetails(request, extra_info_spec));
   if (started)
     event_details->SetResponseSource(request);
   else
     event_details->SetBoolean(keys::kFromCache, request->was_cached());
   event_details->SetString(keys::kErrorKey,
                            net::ErrorToString(request->status().error()));
 
   DispatchEvent(browser_context, request, listeners, std::move(event_details));
 }
@@ skipping 11 matching lines @@
 
 void ExtensionWebRequestEventRouter::ClearPendingCallbacks(
     const net::URLRequest* request) {
   blocked_requests_.erase(request->identifier());
 }
 
 bool ExtensionWebRequestEventRouter::DispatchEvent(
     void* browser_context,
     net::URLRequest* request,
     const std::vector<const EventListener*>& listeners,
-    scoped_ptr<WebRequestEventDetails> event_details) {
+    std::unique_ptr<WebRequestEventDetails> event_details) {
   // TODO(mpcomplete): Consider consolidating common (extension_id,json_args)
   // pairs into a single message sent to a list of sub_event_names.
   int num_handlers_blocking = 0;
 
-  scoped_ptr<std::vector<EventListener>> listeners_to_dispatch(
+  std::unique_ptr<std::vector<EventListener>> listeners_to_dispatch(
       new std::vector<EventListener>());
   listeners_to_dispatch->reserve(listeners.size());
   for (const EventListener* listener : listeners) {
     listeners_to_dispatch->push_back(*listener);
     if (listener->extra_info_spec &
         (ExtraInfoSpec::BLOCKING | ExtraInfoSpec::ASYNC_BLOCKING)) {
       listener->blocked_requests.insert(request->identifier());
       // If this is the first delegate blocking the request, go ahead and log
       // it.
       if (num_handlers_blocking == 0) {
@@ skipping 19 matching lines @@
     blocked_request.num_handlers_blocking += num_handlers_blocking;
     blocked_request.blocking_time = base::Time::Now();
     return true;
   }
 
   return false;
 }
 
 void ExtensionWebRequestEventRouter::DispatchEventToListeners(
     void* browser_context,
-    scoped_ptr<std::vector<EventListener>> listeners,
-    scoped_ptr<WebRequestEventDetails> event_details) {
+    std::unique_ptr<std::vector<EventListener>> listeners,
+    std::unique_ptr<WebRequestEventDetails> event_details) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(listeners.get());
   DCHECK_GT(listeners->size(), 0UL);
   DCHECK(event_details.get());
 
   std::string event_name =
       EventRouter::GetBaseEventName((*listeners)[0].sub_event_name);
   DCHECK(IsWebRequestEvent(event_name));
 
   const std::set<EventListener>& event_listeners =
@@ skipping 12 matching lines @@
         continue;
       listener = cross_event_listeners->find(target);
       if (listener == cross_event_listeners->end())
         continue;
     }
 
     if (!listener->ipc_sender.get())
       continue;
 
     // Filter out the optional keys that this listener didn't request.
-    scoped_ptr<base::ListValue> args_filtered(new base::ListValue);
+    std::unique_ptr<base::ListValue> args_filtered(new base::ListValue);
     args_filtered->Append(
         event_details->GetFilteredDict(listener->extra_info_spec));
 
     EventRouter::DispatchEventToSender(
         listener->ipc_sender.get(), browser_context, listener->extension_id,
         listener->histogram_value, listener->sub_event_name,
         std::move(args_filtered), EventRouter::USER_GESTURE_UNKNOWN,
         EventFilteringInfo());
   }
 }
@@ skipping 387 matching lines @@
       return helpers::CalculateOnAuthRequiredDelta(
           response->extension_id, response->extension_install_time,
           response->cancel, &response->auth_credentials);
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 base::Value* SerializeResponseHeaders(const helpers::ResponseHeaders& headers) {
-  scoped_ptr<base::ListValue> serialized_headers(new base::ListValue());
+  std::unique_ptr<base::ListValue> serialized_headers(new base::ListValue());
   for (const auto& it : headers) {
     serialized_headers->Append(
         helpers::CreateHeaderDictionary(it.first, it.second));
   }
   return serialized_headers.release();
 }
 
 // Convert a RequestCookieModifications/ResponseCookieModifications object to a
 // base::ListValue which summarizes the changes made.  This is templated since
 // the two types (request/response) are different but contain essentially the
 // same fields.
 template <typename CookieType>
 base::ListValue* SummarizeCookieModifications(
     const std::vector<linked_ptr<CookieType>>& modifications) {
-  scoped_ptr<base::ListValue> cookie_modifications(new base::ListValue());
+  std::unique_ptr<base::ListValue> cookie_modifications(new base::ListValue());
   for (const auto& it : modifications) {
-    scoped_ptr<base::DictionaryValue> summary(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> summary(new base::DictionaryValue());
     const CookieType& mod = *(it.get());
     switch (mod.type) {
       case helpers::ADD:
         summary->SetString(activity_log::kCookieModificationTypeKey,
                            activity_log::kCookieModificationAdd);
         break;
       case helpers::EDIT:
         summary->SetString(activity_log::kCookieModificationTypeKey,
                            activity_log::kCookieModificationEdit);
         break;
@@ skipping 22 matching lines @@
                            *mod.modification->name);
       }
     }
     cookie_modifications->Append(summary.release());
   }
   return cookie_modifications.release();
 }
 
 // Converts an EventResponseDelta object to a dictionary value suitable for the
 // activity log.
-scoped_ptr<base::DictionaryValue> SummarizeResponseDelta(
+std::unique_ptr<base::DictionaryValue> SummarizeResponseDelta(
     const std::string& event_name,
     const helpers::EventResponseDelta& delta) {
-  scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> details(new base::DictionaryValue());
   if (delta.cancel)
     details->SetBoolean(activity_log::kCancelKey, true);
   if (!delta.new_url.is_empty())
     details->SetString(activity_log::kNewUrlKey, delta.new_url.spec());
 
-  scoped_ptr<base::ListValue> modified_headers(new base::ListValue());
+  std::unique_ptr<base::ListValue> modified_headers(new base::ListValue());
   net::HttpRequestHeaders::Iterator iter(delta.modified_request_headers);
   while (iter.GetNext()) {
     modified_headers->Append(
         helpers::CreateHeaderDictionary(iter.name(), iter.value()));
   }
   if (!modified_headers->empty()) {
     details->Set(activity_log::kModifiedRequestHeadersKey,
                  modified_headers.release());
   }
 
-  scoped_ptr<base::ListValue> deleted_headers(new base::ListValue());
+  std::unique_ptr<base::ListValue> deleted_headers(new base::ListValue());
   deleted_headers->AppendStrings(delta.deleted_request_headers);
   if (!deleted_headers->empty()) {
     details->Set(activity_log::kDeletedRequestHeadersKey,
                  deleted_headers.release());
   }
 
   if (!delta.added_response_headers.empty()) {
     details->Set(activity_log::kAddedRequestHeadersKey,
                  SerializeResponseHeaders(delta.added_response_headers));
   }
@@ skipping 17 matching lines @@
 }
 
 }  // namespace
 
 void ExtensionWebRequestEventRouter::LogExtensionActivity(
     void* browser_context_id,
     bool is_incognito,
     const std::string& extension_id,
     const GURL& url,
     const std::string& api_call,
-    scoped_ptr<base::DictionaryValue> details) {
+    std::unique_ptr<base::DictionaryValue> details) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&ExtensionWebRequestEventRouter::LogExtensionActivity,
                     base::Unretained(this),
                     browser_context_id,
                     is_incognito,
                     extension_id,
                     url,
                     api_call,
                     base::Passed(&details)));
   } else {
     if (web_request_event_router_delegate_) {
       web_request_event_router_delegate_->LogExtensionActivity(
           reinterpret_cast<content::BrowserContext*>(browser_context_id),
           is_incognito, extension_id, url, api_call, std::move(details));
     }
   }
 }
 
 void ExtensionWebRequestEventRouter::DecrementBlockCount(
     void* browser_context,
     const std::string& extension_id,
     const std::string& event_name,
     uint64_t request_id,
     EventResponse* response) {
-  scoped_ptr<EventResponse> response_scoped(response);
+  std::unique_ptr<EventResponse> response_scoped(response);
 
   // It's possible that this request was deleted, or cancelled by a previous
   // event handler. If so, ignore this response.
   auto it = blocked_requests_.find(request_id);
   if (it == blocked_requests_.end())
     return;
 
   BlockedRequest& blocked_request = it->second;
   int num_handlers_blocking = --blocked_request.num_handlers_blocking;
   CHECK_GE(num_handlers_blocking, 0);
@@ skipping 45 matching lines @@
   }
 }
 
 void ExtensionWebRequestEventRouter::SendMessages(
     void* browser_context,
     const BlockedRequest& blocked_request) {
   const helpers::EventResponseDeltas& deltas = blocked_request.response_deltas;
   for (const auto& delta : deltas) {
     const std::set<std::string>& messages = delta->messages_to_extension;
     for (const std::string& message : messages) {
-      scoped_ptr<WebRequestEventDetails> event_details(
+      std::unique_ptr<WebRequestEventDetails> event_details(
           CreateEventDetails(blocked_request.request, /* extra_info_spec */ 0));
       WebViewRendererState::WebViewInfo web_view_info;
       bool is_web_view_guest = GetWebViewInfo(blocked_request.request,
                                               &web_view_info);
       event_details->SetString(keys::kMessageKey, message);
       event_details->SetString(keys::kStageKey,
                                GetRequestStageAsString(blocked_request.event));
 
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
@@ skipping 395 matching lines @@
                                        profile_id(), extension_id_safe()));
   }
 
   return true;
 }
 
 void WebRequestInternalEventHandledFunction::RespondWithError(
     const std::string& event_name,
     const std::string& sub_event_name,
     uint64_t request_id,
-    scoped_ptr<ExtensionWebRequestEventRouter::EventResponse> response,
+    std::unique_ptr<ExtensionWebRequestEventRouter::EventResponse> response,
     const std::string& error) {
   error_ = error;
   ExtensionWebRequestEventRouter::GetInstance()->OnEventHandled(
       profile_id(),
       extension_id_safe(),
       event_name,
       sub_event_name,
       request_id,
       response.release());
 }
 
 bool WebRequestInternalEventHandledFunction::RunSync() {
   std::string event_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &event_name));
 
   std::string sub_event_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &sub_event_name));
 
   std::string request_id_str;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &request_id_str));
   uint64_t request_id;
   EXTENSION_FUNCTION_VALIDATE(base::StringToUint64(request_id_str,
                                                    &request_id));
 
-  scoped_ptr<ExtensionWebRequestEventRouter::EventResponse> response;
+  std::unique_ptr<ExtensionWebRequestEventRouter::EventResponse> response;
   if (HasOptionalArgument(3)) {
     base::DictionaryValue* value = NULL;
     EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(3, &value));
 
     if (!value->empty()) {
       base::Time install_time =
           extension_info_map()->GetInstallTime(extension_id_safe());
       response.reset(new ExtensionWebRequestEventRouter::EventResponse(
           extension_id_safe(), install_time));
     }
@@ skipping 30 matching lines @@
     if (has_request_headers || has_response_headers) {
       if (has_request_headers && has_response_headers) {
         // Allow only one of the keys, not both.
         RespondWithError(event_name, sub_event_name, request_id,
                          std::move(response),
                          keys::kInvalidHeaderKeyCombination);
         return false;
       }
 
       base::ListValue* headers_value = NULL;
-      scoped_ptr<net::HttpRequestHeaders> request_headers;
-      scoped_ptr<helpers::ResponseHeaders> response_headers;
+      std::unique_ptr<net::HttpRequestHeaders> request_headers;
+      std::unique_ptr<helpers::ResponseHeaders> response_headers;
       if (has_request_headers) {
         request_headers.reset(new net::HttpRequestHeaders());
         EXTENSION_FUNCTION_VALIDATE(value->GetList(keys::kRequestHeadersKey,
                                                    &headers_value));
       } else {
         response_headers.reset(new helpers::ResponseHeaders());
         EXTENSION_FUNCTION_VALIDATE(value->GetList(keys::kResponseHeadersKey,
                                                    &headers_value));
       }
 
@@ skipping 84 matching lines @@
   // Continue gracefully.
   RunSync();
 }
 
 bool WebRequestHandlerBehaviorChangedFunction::RunSync() {
   helpers::ClearCacheOnNavigation();
   return true;
 }
 
 }  // namespace extensions