Convert ScopedVector<T> to std::vector<std::unique_ptr<T>>.

ios/web/public/test/http_server.mm

 // Copyright 2014 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/web/public/test/http_server.h"
 
 #import <Foundation/Foundation.h>
 
 #include <string>
 
@@ skipping 30 matching lines @@
   }];
   return web::ResponseProvider::Request(url, method,
                                         base::SysNSStringToUTF8(body), headers);
 }
 
 }  // namespace
 
 namespace web {
 namespace test {
 
-
 RefCountedResponseProviderWrapper::RefCountedResponseProviderWrapper(
-    ResponseProvider* response_provider) {
-  response_provider_.reset(response_provider);
-}
+    std::unique_ptr<ResponseProvider> response_provider)
+    : response_provider_(std::move(response_provider)) {}
 
 RefCountedResponseProviderWrapper::~RefCountedResponseProviderWrapper() {}
 
 // static
 HttpServer& HttpServer::GetSharedInstance() {
   static web::test::HttpServer* shared_instance = nullptr;
   static dispatch_once_t once;
   dispatch_once(&once, ^{
       shared_instance = new HttpServer();
   });
   return *shared_instance;
 }
 
 // static
 HttpServer& HttpServer::GetSharedInstanceWithResponseProviders(
-    const ProviderList& response_providers) {
+    ProviderList response_providers) {
   DCHECK([NSThread isMainThread]);
   HttpServer& server = HttpServer::GetSharedInstance();
-  for (const auto& response_provider : response_providers) {
-    server.AddResponseProvider(response_provider);
-  }
+  // Use non-const reference as the response_provider ownership is transfered.
+  for (std::unique_ptr<ResponseProvider>& provider : response_providers)
+    server.AddResponseProvider(std::move(provider));
   return server;
 }
 
 void HttpServer::InitHttpServer() {
   DCHECK(gcd_web_server_);
   // Note: This block is called from an arbitrary GCD thread.
   id process_request =
       ^GCDWebServerResponse*(GCDWebServerDataRequest* request) {
       ResponseProvider::Request provider_request =
           ResponseProviderRequestFromGCDWebServerRequest(request);
@@ skipping 99 matching lines @@
         ref_counted_response_provider.get()->GetResponseProvider();
     if (response_provider->CanHandleRequest(request)) {
       DCHECK(!result) <<
           "No more than one response provider can handle the same request.";
       result = ref_counted_response_provider;
     }
   }
   return result;
 }
 
-void HttpServer::AddResponseProvider(ResponseProvider* response_provider) {
+void HttpServer::AddResponseProvider(
+    std::unique_ptr<ResponseProvider> response_provider) {
   DCHECK([NSThread isMainThread]);
   DCHECK(IsRunning()) << "Can add a response provider only when the server is "
                       << "running.";
   base::AutoLock autolock(provider_list_lock_);
   scoped_refptr<RefCountedResponseProviderWrapper>
       ref_counted_response_provider(
-          new RefCountedResponseProviderWrapper(response_provider));
+          new RefCountedResponseProviderWrapper(std::move(response_provider)));
   providers_.push_back(ref_counted_response_provider);
 }
 
 void HttpServer::RemoveResponseProvider(ResponseProvider* response_provider) {
   DCHECK([NSThread isMainThread]);
   base::AutoLock autolock(provider_list_lock_);
   auto found_iter = providers_.end();
   for (auto it = providers_.begin(); it != providers_.end(); ++it) {
     if ((*it)->GetResponseProvider() == response_provider) {
       found_iter = it;
@@ skipping 16 matching lines @@
   port_ = port;
 }
 
 NSUInteger HttpServer::GetPort() const {
   base::AutoLock autolock(port_lock_);
   return port_;
 }
 
 } // namespace test
 } // namespace web