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

media/blink/resource_multibuffer_data_provider.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 "media/blink/resource_multibuffer_data_provider.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bits.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/blink/active_loader.h"
 #include "media/blink/cache_util.h"
 #include "media/blink/media_blink_export.h"
@@ skipping 57 matching lines @@
   url_data_->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 (url_data_->cors_mode() == UrlData::CORS_UNSPECIFIED) {
       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 (url_data_->cors_mode() == UrlData::CORS_USE_CREDENTIALS)
         options.allowCredentials = true;
     }
     loader.reset(url_data_->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)));
 }
 
 ResourceMultiBufferDataProvider::~ResourceMultiBufferDataProvider() {}
 
 /////////////////////////////////////////////////////////////////////////////
 // MultiBuffer::DataProvider implementation.
 MultiBufferBlockId ResourceMultiBufferDataProvider::Tell() const {
   return pos_;
 }
 
@@ skipping 174 matching lines @@
 
     // First, let's take a ref on the current url data.
     scoped_refptr<UrlData> old_url_data(url_data_);
     destination_url_data->Use();
 
     // Take ownership of ourselves. (From the multibuffer)
     scoped_ptr<DataProvider> self(
         url_data_->multibuffer()->RemoveProvider(this));
     url_data_ = destination_url_data.get();
     // Give the ownership to our new owner.
-    url_data_->multibuffer()->AddProvider(self.Pass());
+    url_data_->multibuffer()->AddProvider(std::move(self));
 
     // Call callback to let upstream users know about the transfer.
     // This will merge the data from the two multibuffers and
     // cause clients to start using the new UrlData.
     old_url_data->RedirectTo(destination_url_data);
   }
 }
 
 void ResourceMultiBufferDataProvider::didReceiveData(WebURLLoader* loader,
                                                      const char* data,
@@ skipping 62 matching lines @@
       size < url_data_->length()) {
     if (retries_ < kMaxRetries) {
       DVLOG(1) << " Partial data received.... @ pos = " << size;
       retries_++;
       base::MessageLoop::current()->PostDelayedTask(
           FROM_HERE, base::Bind(&ResourceMultiBufferDataProvider::Start,
                                 weak_factory_.GetWeakPtr()),
           base::TimeDelta::FromMilliseconds(kLoaderPartialRetryDelayMs));
       return;
     } else {
-      scoped_ptr<ActiveLoader> active_loader = active_loader_.Pass();
+      scoped_ptr<ActiveLoader> active_loader = std::move(active_loader_);
       url_data_->Fail();
       return;
     }
   }
 
   url_data_->set_length(size);
   fifo_.push_back(DataBuffer::CreateEOSBuffer());
 
   DCHECK(Available());
   url_data_->multibuffer()->OnDataProviderEvent(this);
@@ skipping 13 matching lines @@
   if (retries_ < kMaxRetries && pos_ != 0) {
     retries_++;
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE, base::Bind(&ResourceMultiBufferDataProvider::Start,
                               weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(kLoaderFailedRetryDelayMs));
   } else {
     // 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_);
     url_data_->Fail();
   }
 }
 
 bool ResourceMultiBufferDataProvider::ParseContentRange(
     const std::string& content_range_str,
     int64_t* first_byte_position,
     int64_t* last_byte_position,
     int64_t* instance_size) {
   const std::string kUpThroughBytesUnit = "bytes ";
@@ skipping 62 matching lines @@
   }
 
   if (byte_pos() != first_byte_position) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace media