Remove ScopedVector from proxy_resolver_factory_mojo_unittest

net/proxy/proxy_resolver_factory_mojo_unittest.cc

 // Copyright 2015 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 "net/proxy/proxy_resolver_factory_mojo.h"
 
 #include <list>
 #include <map>
 #include <queue>
 #include <string>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/dns/host_resolver.h"
 #include "net/log/test_net_log.h"
@@ skipping 169 matching lines @@
       interfaces::ProxyResolverRequestClientPtr client) override;
 
   void WakeWaiter();
 
   std::string pac_script_data_;
 
   std::queue<GetProxyForUrlAction> get_proxy_actions_;
 
   base::Closure quit_closure_;
 
-  ScopedVector<interfaces::ProxyResolverRequestClientPtr> blocked_clients_;
+  std::vector<scoped_ptr<interfaces::ProxyResolverRequestClientPtr>>
+      blocked_clients_;
   mojo::Binding<interfaces::ProxyResolver> binding_;
 };
 
 MockMojoProxyResolver::~MockMojoProxyResolver() {
   EXPECT_TRUE(get_proxy_actions_.empty())
       << "Actions remaining: " << get_proxy_actions_.size();
 }
 
 MockMojoProxyResolver::MockMojoProxyResolver() : binding_(this) {
 }
@@ skipping 53 matching lines @@
       break;
     }
     case GetProxyForUrlAction::MAKE_DNS_REQUEST: {
       interfaces::HostResolverRequestInfoPtr request(
           interfaces::HostResolverRequestInfo::New());
       request->host = url;
       request->port = 12345;
       interfaces::HostResolverRequestClientPtr dns_client;
       mojo::GetProxy(&dns_client);
       client->ResolveDns(request.Pass(), dns_client.Pass());
-      blocked_clients_.push_back(
-          new interfaces::ProxyResolverRequestClientPtr(client.Pass()));
+      blocked_clients_.push_back(make_scoped_ptr(
+          new interfaces::ProxyResolverRequestClientPtr(std::move(client))));
       break;
     }
   }
   WakeWaiter();
 }
 
 class Request {
  public:
   Request(ProxyResolver* resolver, const GURL& url);
 
@@ skipping 54 matching lines @@
       mojo::InterfaceRequest<interfaces::ProxyResolver> request,
       interfaces::ProxyResolverFactoryRequestClientPtr client) override;
 
   void WakeWaiter();
 
   MockMojoProxyResolver* resolver_;
   std::queue<CreateProxyResolverAction> create_resolver_actions_;
 
   base::Closure quit_closure_;
 
-  ScopedVector<interfaces::ProxyResolverFactoryRequestClientPtr>
+  std::vector<scoped_ptr<interfaces::ProxyResolverFactoryRequestClientPtr>>
       blocked_clients_;
-  ScopedVector<mojo::InterfaceRequest<interfaces::ProxyResolver>>
+  std::vector<scoped_ptr<mojo::InterfaceRequest<interfaces::ProxyResolver>>>
       blocked_resolver_requests_;
   mojo::Binding<interfaces::ProxyResolverFactory> binding_;
 };
 
 MockMojoProxyResolverFactory::MockMojoProxyResolverFactory(
     MockMojoProxyResolver* resolver,
     mojo::InterfaceRequest<interfaces::ProxyResolverFactory> req)
     : resolver_(resolver), binding_(this, req.Pass()) {
 }
 
@@ skipping 37 matching lines @@
   switch (action.action) {
     case CreateProxyResolverAction::COMPLETE: {
       if (action.error == OK)
         resolver_->AddConnection(request.Pass());
       client->ReportResult(action.error);
       break;
     }
     case CreateProxyResolverAction::DROP_CLIENT: {
       // Save |request| so its pipe isn't closed.
       blocked_resolver_requests_.push_back(
-          new mojo::InterfaceRequest<interfaces::ProxyResolver>(
-              request.Pass()));
+          make_scoped_ptr(new mojo::InterfaceRequest<interfaces::ProxyResolver>(
+              std::move(request))));
       break;
     }
     case CreateProxyResolverAction::DROP_RESOLVER: {
       // Save |client| so its pipe isn't closed.
       blocked_clients_.push_back(
-          new interfaces::ProxyResolverFactoryRequestClientPtr(client.Pass()));
+          make_scoped_ptr(new interfaces::ProxyResolverFactoryRequestClientPtr(
+              std::move(client))));
       break;
     }
     case CreateProxyResolverAction::DROP_BOTH: {
       // Both |request| and |client| will be closed.
       break;
     }
     case CreateProxyResolverAction::WAIT_FOR_CLIENT_DISCONNECT: {
       ASSERT_FALSE(client.WaitForIncomingResponse());
       break;
     }
     case CreateProxyResolverAction::MAKE_DNS_REQUEST: {
       interfaces::HostResolverRequestInfoPtr request(
           interfaces::HostResolverRequestInfo::New());
       request->host = pac_script;
       request->port = 12345;
       interfaces::HostResolverRequestClientPtr dns_client;
       mojo::GetProxy(&dns_client);
       client->ResolveDns(request.Pass(), dns_client.Pass());
       blocked_clients_.push_back(
-          new interfaces::ProxyResolverFactoryRequestClientPtr(client.Pass()));

[eroman, 2015/12/08 19:50:17]

strictly speaking these changes from .Pass() --> std::move() are not part of the
CL description (or necessary for this refactor).

That said should be fine, since our style guide now permits move()

+          make_scoped_ptr(new interfaces::ProxyResolverFactoryRequestClientPtr(
+              std::move(client))));
       break;
     }
   }
   WakeWaiter();
 }
 
 void DeleteResolverFactoryRequestCallback(
     scoped_ptr<ProxyResolverFactory::Request>* request,
     const CompletionCallback& callback,
     int result) {
@@ skipping 432 matching lines @@
   mock_proxy_resolver_.ClearBlockedClients();
   request->WaitForResult();
 }
 
 TEST_F(ProxyResolverFactoryMojoTest, DeleteResolver) {
   CreateProxyResolver();
   proxy_resolver_mojo_.reset();
   on_delete_callback_.WaitForResult();
 }
 }  // namespace net