Replaced PassRefPtr copites with moves in Source/modules.

third_party/WebKit/Source/modules/fetch/FetchFormDataConsumerHandle.cpp

 // 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 "modules/fetch/FetchFormDataConsumerHandle.h"
 
 #include "modules/fetch/DataConsumerHandleUtil.h"
 #include "modules/fetch/FetchBlobDataConsumerHandle.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/ThreadingPrimitives.h"
@@ skipping 29 matching lines @@
 
 protected:
     explicit Context() {}
 };
 
 class FetchFormDataConsumerHandle::SimpleContext final : public Context {
     class ReaderImpl;
 public:
     static PassRefPtr<SimpleContext> create(const String& body) { return adoptRef(new SimpleContext(body)); }
     static PassRefPtr<SimpleContext> create(const void* data, size_t size) { return adoptRef(new SimpleContext(data, size)); }
-    static PassRefPtr<SimpleContext> create(PassRefPtr<EncodedFormData> body) { return adoptRef(new SimpleContext(body)); }
+    static PassRefPtr<SimpleContext> create(PassRefPtr<EncodedFormData> body) { return adoptRef(new SimpleContext(std::move(body))); }
 
     std::unique_ptr<Reader> obtainReader(Client* client) override
     {
         // For memory barrier.
         Mutex m;
         MutexLocker locker(m);
         return ReaderImpl::create(this, client);
     }
 
     PassRefPtr<BlobDataHandle> drainAsBlobDataHandle()
@@ skipping 54 matching lines @@
         RELEASE_ASSERT(read <= m_flattenFormData.size() - m_flattenFormDataOffset);
         m_flattenFormDataOffset += read;
 
         return WebDataConsumerHandle::Ok;
     }
 
 private:
     class ReaderImpl final : public FetchDataConsumerHandle::Reader {
         WTF_MAKE_NONCOPYABLE(ReaderImpl);
     public:
-        static std::unique_ptr<ReaderImpl> create(PassRefPtr<SimpleContext> context, Client* client) { return wrapUnique(new ReaderImpl(context, client)); }
+        static std::unique_ptr<ReaderImpl> create(PassRefPtr<SimpleContext> context, Client* client) { return wrapUnique(new ReaderImpl(std::move(context), client)); }
         Result read(void* data, size_t size, Flags flags, size_t* readSize) override
         {
             return m_context->read(data, size, flags, readSize);
         }
         Result beginRead(const void** buffer, Flags flags, size_t* available) override
         {
             return m_context->beginRead(buffer, flags, available);
         }
         Result endRead(size_t read) override
         {
@@ skipping 39 matching lines @@
     size_t m_flattenFormDataOffset;
 };
 
 class FetchFormDataConsumerHandle::ComplexContext final : public Context {
     class ReaderImpl;
 public:
     static PassRefPtr<ComplexContext> create(ExecutionContext* executionContext,
         PassRefPtr<EncodedFormData> formData,
         FetchBlobDataConsumerHandle::LoaderFactory* factory)
     {
-        return adoptRef(new ComplexContext(executionContext, formData, factory));
+        return adoptRef(new ComplexContext(executionContext, std::move(formData), factory));
     }
 
     std::unique_ptr<FetchFormDataConsumerHandle::Reader> obtainReader(Client* client) override
     {
         // For memory barrier.
         Mutex m;
         MutexLocker locker(m);
         return ReaderImpl::create(this, client);
     }
 
 private:
     class ReaderImpl final : public FetchDataConsumerHandle::Reader {
         WTF_MAKE_NONCOPYABLE(ReaderImpl);
     public:
-        static std::unique_ptr<ReaderImpl> create(PassRefPtr<ComplexContext> context, Client* client) { return wrapUnique(new ReaderImpl(context, client)); }
+        static std::unique_ptr<ReaderImpl> create(PassRefPtr<ComplexContext> context, Client* client) { return wrapUnique(new ReaderImpl(std::move(context), client)); }
         Result read(void* data, size_t size, Flags flags, size_t* readSize) override
         {
             Result r = m_reader->read(data, size, flags, readSize);
             if (!(size == 0 && (r == Ok || r == ShouldWait))) {
                 m_context->drainFormData();
             }
             return r;
         }
         Result beginRead(const void** buffer, Flags flags, size_t* available) override
         {
@@ skipping 88 matching lines @@
 std::unique_ptr<FetchDataConsumerHandle> FetchFormDataConsumerHandle::create(DOMArrayBufferView* body)
 {
     return wrapUnique(new FetchFormDataConsumerHandle(body->baseAddress(), body->byteLength()));
 }
 std::unique_ptr<FetchDataConsumerHandle> FetchFormDataConsumerHandle::create(const void* data, size_t size)
 {
     return wrapUnique(new FetchFormDataConsumerHandle(data, size));
 }
 std::unique_ptr<FetchDataConsumerHandle> FetchFormDataConsumerHandle::create(ExecutionContext* executionContext, PassRefPtr<EncodedFormData> body)
 {
-    return wrapUnique(new FetchFormDataConsumerHandle(executionContext, body));
+    return wrapUnique(new FetchFormDataConsumerHandle(executionContext, std::move(body)));
 }
 std::unique_ptr<FetchDataConsumerHandle> FetchFormDataConsumerHandle::createForTest(
     ExecutionContext* executionContext,
     PassRefPtr<EncodedFormData> body,
     FetchBlobDataConsumerHandle::LoaderFactory* loaderFactory)
 {
-    return wrapUnique(new FetchFormDataConsumerHandle(executionContext, body, loaderFactory));
+    return wrapUnique(new FetchFormDataConsumerHandle(executionContext, std::move(body), loaderFactory));
 }
 
 FetchFormDataConsumerHandle::FetchFormDataConsumerHandle(const String& body) : m_context(SimpleContext::create(body)) {}
 FetchFormDataConsumerHandle::FetchFormDataConsumerHandle(const void* data, size_t size) : m_context(SimpleContext::create(data, size)) {}
 FetchFormDataConsumerHandle::FetchFormDataConsumerHandle(ExecutionContext* executionContext,
     PassRefPtr<EncodedFormData> body,
     FetchBlobDataConsumerHandle::LoaderFactory* loaderFactory)
 {
     if (isSimple(body.get())) {
-        m_context = SimpleContext::create(body);
+        m_context = SimpleContext::create(std::move(body));
     } else {
-        m_context = ComplexContext::create(executionContext, body, loaderFactory);
+        m_context = ComplexContext::create(executionContext, std::move(body), loaderFactory);
     }
 }
 FetchFormDataConsumerHandle::~FetchFormDataConsumerHandle() {}
 
 std::unique_ptr<FetchDataConsumerHandle::Reader> FetchFormDataConsumerHandle::obtainFetchDataReader(Client* client)
 {
     return m_context->obtainReader(client);
 }
 
 } // namespace blink