Replaced usage of RefPtr::Release with std::move wraps.

third_party/WebKit/Source/platform/wtf/typed_arrays/TypedArrayBase.h

 /*
  * Copyright (C) 2010 Apple Inc. All rights reserved.
  * Copyright (c) 2010, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 53 matching lines @@
 
  protected:
   TypedArrayBase(PassRefPtr<ArrayBuffer> buffer,
                  unsigned byte_offset,
                  unsigned length)
       : ArrayBufferView(std::move(buffer), byte_offset), length_(length) {}
 
   template <class Subclass>
   static PassRefPtr<Subclass> Create(unsigned length) {
     RefPtr<ArrayBuffer> buffer = ArrayBuffer::Create(length, sizeof(T));
-    return Create<Subclass>(buffer.Release(), 0, length);
+    return Create<Subclass>(std::move(buffer), 0, length);
   }
 
   template <class Subclass>
   static PassRefPtr<Subclass> Create(const T* array, unsigned length) {
     RefPtr<Subclass> a = Create<Subclass>(length);
     if (a)
       for (unsigned i = 0; i < length; ++i)
         a->Set(i, array[i]);
     return a;
   }
 
   template <class Subclass>
   static PassRefPtr<Subclass> Create(PassRefPtr<ArrayBuffer> buffer,
                                      unsigned byte_offset,
                                      unsigned length) {
     RefPtr<ArrayBuffer> buf(std::move(buffer));
     CHECK(VerifySubRange<T>(buf, byte_offset, length));
-    return AdoptRef(new Subclass(buf.Release(), byte_offset, length));
+    return AdoptRef(new Subclass(std::move(buf), byte_offset, length));
   }
 
   template <class Subclass>
   static PassRefPtr<Subclass> CreateOrNull(unsigned length) {
     RefPtr<ArrayBuffer> buffer = ArrayBuffer::CreateOrNull(length, sizeof(T));
     if (!buffer)
       return nullptr;
-    return Create<Subclass>(buffer.Release(), 0, length);
+    return Create<Subclass>(std::move(buffer), 0, length);
   }
 
   void Neuter() final {
     ArrayBufferView::Neuter();
     length_ = 0;
   }
 
   // We do not want to have to access this via a virtual function in subclasses,
   // which is why it is protected rather than private.
   unsigned length_;
 };
 
 }  // namespace WTF
 
 using WTF::TypedArrayBase;
 
 #endif  // TypedArrayBase_h