Convert Pass()→std::move() in //content/browser

content/browser/loader/resource_scheduler_unittest.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 "content/browser/loader/resource_scheduler.h"
 
+#include <utility>
+
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/mock_entropy_provider.h"
 #include "base/timer/mock_timer.h"
 #include "base/timer/timer.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
@@ skipping 29 matching lines @@
 const int kBackgroundRouteId = 43;
 const int kBackgroundChildId2 = 54;
 const int kBackgroundRouteId2 = 82;
 
 class TestRequest : public ResourceController {
  public:
   TestRequest(scoped_ptr<net::URLRequest> url_request,
               scoped_ptr<ResourceThrottle> throttle,
               ResourceScheduler* scheduler)
       : started_(false),
-        url_request_(url_request.Pass()),
-        throttle_(throttle.Pass()),
+        url_request_(std::move(url_request)),
+        throttle_(std::move(throttle)),
         scheduler_(scheduler) {
     throttle_->set_controller_for_testing(this);
   }
   ~TestRequest() override {
     // The URLRequest must still be valid when the ScheduledResourceRequest is
     // destroyed, so that it can unregister itself.
     throttle_.reset();
   }
 
   bool started() const { return started_; }
@@ skipping 27 matching lines @@
   scoped_ptr<net::URLRequest> url_request_;
   scoped_ptr<ResourceThrottle> throttle_;
   ResourceScheduler* scheduler_;
 };
 
 class CancelingTestRequest : public TestRequest {
  public:
   CancelingTestRequest(scoped_ptr<net::URLRequest> url_request,
                        scoped_ptr<ResourceThrottle> throttle,
                        ResourceScheduler* scheduler)
-      : TestRequest(url_request.Pass(), throttle.Pass(), scheduler) {}
+      : TestRequest(std::move(url_request), std::move(throttle), scheduler) {}
 
   void set_request_to_cancel(scoped_ptr<TestRequest> request_to_cancel) {
-    request_to_cancel_ = request_to_cancel.Pass();
+    request_to_cancel_ = std::move(request_to_cancel);
   }
 
  private:
   void Resume() override {
     TestRequest::Resume();
     request_to_cancel_.reset();
   }
 
   scoped_ptr<TestRequest> request_to_cancel_;
 };
@@ skipping 55 matching lines @@
         std::set<std::string>());
   }
 
   scoped_ptr<net::URLRequest> NewURLRequestWithChildAndRoute(
       const char* url,
       net::RequestPriority priority,
       int child_id,
       int route_id) {
     scoped_ptr<net::URLRequest> url_request(
         context_.CreateRequest(GURL(url), priority, NULL));
-    return url_request.Pass();
+    return url_request;
   }
 
   scoped_ptr<net::URLRequest> NewURLRequest(const char* url,
                                             net::RequestPriority priority) {
     return NewURLRequestWithChildAndRoute(url, priority, kChildId, kRouteId);
   }
 
   TestRequest* NewRequestWithRoute(const char* url,
                                    net::RequestPriority priority,
                                    int route_id) {
@@ skipping 36 matching lines @@
 
   TestRequest* GetNewTestRequest(const char* url,
                                  net::RequestPriority priority,
                                  int child_id,
                                  int route_id,
                                  bool is_async) {
     scoped_ptr<net::URLRequest> url_request(
         NewURLRequestWithChildAndRoute(url, priority, child_id, route_id));
     scoped_ptr<ResourceThrottle> throttle(scheduler_->ScheduleRequest(
         child_id, route_id, is_async, url_request.get()));
-    TestRequest* request =
-        new TestRequest(url_request.Pass(), throttle.Pass(), scheduler());
+    TestRequest* request = new TestRequest(std::move(url_request),
+                                           std::move(throttle), scheduler());
     request->Start();
     return request;
   }
 
   void ChangeRequestPriority(TestRequest* request,
                              net::RequestPriority new_priority,
                              int intra_priority = 0) {
     request->ChangePriority(new_priority, intra_priority);
   }
 
@@ skipping 143 matching lines @@
 
 TEST_F(ResourceSchedulerTest, CancelOtherRequestsWhileResuming) {
   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> low1(NewRequest("http://host/low1", net::LOWEST));
 
   scoped_ptr<net::URLRequest> url_request(
       NewURLRequest("http://host/low2", net::LOWEST));
   scoped_ptr<ResourceThrottle> throttle(scheduler()->ScheduleRequest(
       kChildId, kRouteId, true, url_request.get()));
   scoped_ptr<CancelingTestRequest> low2(new CancelingTestRequest(
-      url_request.Pass(), throttle.Pass(), scheduler()));
+      std::move(url_request), std::move(throttle), scheduler()));
   low2->Start();
 
   scoped_ptr<TestRequest> low3(NewRequest("http://host/low3", net::LOWEST));
-  low2->set_request_to_cancel(low3.Pass());
+  low2->set_request_to_cancel(std::move(low3));
   scoped_ptr<TestRequest> low4(NewRequest("http://host/low4", net::LOWEST));
 
   EXPECT_TRUE(high->started());
   EXPECT_FALSE(low2->started());
 
   high.reset();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(low1->started());
   EXPECT_TRUE(low2->started());
   EXPECT_TRUE(low4->started());
@@ skipping 2303 matching lines @@
   }
 
   scoped_ptr<TestRequest> last_different_host(NewRequest("http://host_new/last",
                                                          net::LOWEST));
   EXPECT_FALSE(last_different_host->started());
 }
 
 }  // unnamed namespace
 
 }  // namespace content