Convert Pass()→std::move() in mojo/

mojo/fetcher/network_fetcher_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 "mojo/fetcher/network_fetcher.h"
+
+#include <utility>
+
 #include "base/at_exit.h"
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
-#include "mojo/fetcher/network_fetcher.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/services/network/public/interfaces/url_loader.mojom.h"
 #include "mojo/services/network/public/interfaces/url_loader_factory.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace fetcher {
 namespace {
 
 const char k200Request[] = "http://request_expect_200";
 const char k404Request[] = "http://request_expect_404";
 const char k504Request[] = "http://request_expect_504";
 const char kErrorRequest[] = "http://request_expect_error";
 
 class TestURLLoaderImpl : public URLLoader {
  public:
   explicit TestURLLoaderImpl(InterfaceRequest<URLLoader> request)
-      : binding_(this, request.Pass()) {}
+      : binding_(this, std::move(request)) {}
   ~TestURLLoaderImpl() override {}
 
  private:
   // URLLoader implementation.
   void Start(URLRequestPtr request,
              const Callback<void(URLResponsePtr)>& callback) override {
     URLResponsePtr response(URLResponse::New());
     response->url = request->url;
     if (request->url == std::string(k200Request)) {
       response->mime_type = "text/html";
       response->status_code = 200;
     } else if (request->url == std::string(k404Request)) {
       response->mime_type = "text/html";
       response->status_code = 404;
     } else if (request->url == std::string(k504Request)) {
       response->mime_type = "text/html";
       response->status_code = 504;
     } else {
       response->error = NetworkError::New();
       response->error->code = -2;
     }
-    callback.Run(response.Pass());
+    callback.Run(std::move(response));
   }
   void FollowRedirect(const Callback<void(URLResponsePtr)>& callback) override {
     NOTREACHED();
   }
   void QueryStatus(
       const Callback<void(URLLoaderStatusPtr)>& callback) override {
     NOTREACHED();
   }
 
   StrongBinding<URLLoader> binding_;
   DISALLOW_COPY_AND_ASSIGN(TestURLLoaderImpl);
 };
 
 class TestURLLoaderFactoryImpl : public URLLoaderFactory {
  public:
   explicit TestURLLoaderFactoryImpl(InterfaceRequest<URLLoaderFactory> request)
-      : binding_(this, request.Pass()) {}
+      : binding_(this, std::move(request)) {}
   ~TestURLLoaderFactoryImpl() override {}
 
  private:
   // URLLoaderFactory implementation.
   void CreateURLLoader(InterfaceRequest<URLLoader> loader) override {
-    new TestURLLoaderImpl(loader.Pass());
+    new TestURLLoaderImpl(std::move(loader));
   }
 
   StrongBinding<URLLoaderFactory> binding_;
   DISALLOW_COPY_AND_ASSIGN(TestURLLoaderFactoryImpl);
 };
 
 class FetchCallbackHelper {
  public:
   FetchCallbackHelper() : run_loop_(nullptr) {}
   ~FetchCallbackHelper() {}
 
   shell::Fetcher::FetchCallback GetCallback() {
     return base::Bind(&FetchCallbackHelper::CallbackHandler,
                       base::Unretained(this));
   }
 
   void WaitForCallback() {
     base::RunLoop run_loop;
     base::AutoReset<base::RunLoop*> auto_reset(&run_loop_, &run_loop);
     run_loop.Run();
   }
 
   shell::Fetcher* fetcher() const { return fetcher_.get(); }
 
  private:
   void CallbackHandler(scoped_ptr<shell::Fetcher> fetcher) {
-    fetcher_ = fetcher.Pass();
+    fetcher_ = std::move(fetcher);
     if (run_loop_)
       run_loop_->Quit();
   }
 
   // If it is not null, it points to a stack-allocated base::RunLoop instance in
   // WaitForCallback().
   base::RunLoop* run_loop_;
   scoped_ptr<shell::Fetcher> fetcher_;
   DISALLOW_COPY_AND_ASSIGN(FetchCallbackHelper);
 };
@@ skipping 11 matching lines @@
   }
 
   // When |expect_fetch_success| is false, |expected_status_code| is ignored.
   void TestFetchURL(const std::string& url,
                     bool expect_fetch_success,
                     uint32_t expected_status_code) {
     FetchCallbackHelper helper;
 
     URLRequestPtr request(URLRequest::New());
     request->url = url;
-    new NetworkFetcher(true, request.Pass(), url_loader_factory_.get(),
+    new NetworkFetcher(true, std::move(request), url_loader_factory_.get(),
                        helper.GetCallback());
     helper.WaitForCallback();
 
     if (!expect_fetch_success) {
       ASSERT_FALSE(helper.fetcher());
     } else {
       ASSERT_TRUE(helper.fetcher());
       URLResponsePtr response = helper.fetcher()->AsURLResponse(nullptr, 0);
       ASSERT_TRUE(response);
       EXPECT_EQ(url, response->url);
@@ skipping 21 matching lines @@
   TestFetchURL(k504Request, true, 504u);
 }
 
 TEST_F(NetworkFetcherTest, FetchFailed) {
   TestFetchURL(kErrorRequest, false, 0u);
 }
 
 }  // namespace
 }  // namespace fetcher
 }  // namespace mojo