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

media/blink/buffered_resource_loader.cc

 // Copyright 2013 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 "media/blink/buffered_resource_loader.h"
 
 #include <stddef.h>
 #include <stdint.h>
-
 #include <limits>
+#include <utility>
 
 #include "base/bits.h"
 #include "base/callback_helpers.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "media/base/media_log.h"
 #include "media/blink/cache_util.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_request_headers.h"
@@ skipping 155 matching lines @@
   frame->setReferrerForRequest(request, blink::WebURL());
 
   // Disable compression, compression for audio/video doesn't make sense...
   request.setHTTPHeaderField(
       WebString::fromUTF8(net::HttpRequestHeaders::kAcceptEncoding),
       WebString::fromUTF8("identity;q=1, *;q=0"));
 
   // Check for our test WebURLLoader.
   scoped_ptr<WebURLLoader> loader;
   if (test_loader_) {
-    loader = test_loader_.Pass();
+    loader = std::move(test_loader_);
   } else {
     WebURLLoaderOptions options;
     if (cors_mode_ == kUnspecified) {
       options.allowCredentials = true;
       options.crossOriginRequestPolicy =
           WebURLLoaderOptions::CrossOriginRequestPolicyAllow;
     } else {
       options.exposeAllResponseHeaders = true;
       // The author header set is empty, no preflight should go ahead.
       options.preflightPolicy = WebURLLoaderOptions::PreventPreflight;
       options.crossOriginRequestPolicy =
           WebURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl;
       if (cors_mode_ == kUseCredentials)
         options.allowCredentials = true;
     }
     loader.reset(frame->createAssociatedURLLoader(options));
   }
 
   // Start the resource loading.
   loader->loadAsynchronously(request, this);
-  active_loader_.reset(new ActiveLoader(loader.Pass()));
+  active_loader_.reset(new ActiveLoader(std::move(loader)));
   loading_cb_.Run(kLoading);
 }
 
 void BufferedResourceLoader::Stop() {
   // Reset callbacks.
   start_cb_.Reset();
   loading_cb_.Reset();
   progress_cb_.Reset();
   read_cb_.Reset();
 
@@ skipping 330 matching lines @@
            << ", domain=" << error.domain.utf8().data()
            << ", localizedDescription="
            << error.localizedDescription.utf8().data();
   DCHECK(active_loader_.get());
   MEDIA_LOG(ERROR, media_log_)
       << "Failed loading buffered resource. Error code=" << error.reason;
 
   // We don't need to continue loading after failure.
   //
   // Keep it alive until we exit this method so that |error| remains valid.
-  scoped_ptr<ActiveLoader> active_loader = active_loader_.Pass();
+  scoped_ptr<ActiveLoader> active_loader = std::move(active_loader_);
   loader_failed_ = true;
   loading_cb_.Run(kLoadingFailed);
 
   // Don't leave start callbacks hanging around.
   if (!start_cb_.is_null()) {
     DCHECK(read_cb_.is_null())
         << "Shouldn't have a read callback during start";
     DoneStart(kFailed);
     return;
   }
@@ skipping 254 matching lines @@
 
 void BufferedResourceLoader::Log() {
   media_log_->AddEvent(
       media_log_->CreateBufferedExtentsChangedEvent(
           offset_ - buffer_.backward_bytes(),
           offset_,
           offset_ + buffer_.forward_bytes()));
 }
 
 }  // namespace media