Convert "return local_var.Pass();" to "return local_var;".

mojo/public/cpp/bindings/tests/struct_unittest.cc

 // Copyright 2014 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 <string.h>
 #include <type_traits>
 
 #include "mojo/public/cpp/bindings/lib/fixed_buffer.h"
 #include "mojo/public/cpp/bindings/lib/validation_errors.h"
 #include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 #include "mojo/public/interfaces/bindings/tests/test_structs.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 namespace {
 
 static_assert(std::is_same<std::underlying_type<ScopedConstants::EType>::type,
                            int32_t>::value,
               "The underlying type of mojom generated enums must be int32_t.");
 
 RectPtr MakeRect(int32_t factor = 1) {
   RectPtr rect(Rect::New());
   rect->x = 1 * factor;
   rect->y = 2 * factor;
   rect->width = 10 * factor;
   rect->height = 20 * factor;
-  return rect.Pass();
+  return rect;
 }
 
 void CheckRect(const Rect& rect, int32_t factor = 1) {
   EXPECT_EQ(1 * factor, rect.x);
   EXPECT_EQ(2 * factor, rect.y);
   EXPECT_EQ(10 * factor, rect.width);
   EXPECT_EQ(20 * factor, rect.height);
 }
 
 MultiVersionStructPtr MakeMultiVersionStruct() {
   MultiVersionStructPtr output(MultiVersionStruct::New());
   output->f_int32 = 123;
   output->f_rect = MakeRect(5);
   output->f_string = "hello";
   output->f_array = Array<int8_t>::New(3);
   output->f_array[0] = 10;
   output->f_array[1] = 9;
   output->f_array[2] = 8;
   MessagePipe pipe;
   output->f_message_pipe = pipe.handle0.Pass();
   output->f_int16 = 42;
 
-  return output.Pass();
+  return output;
 }
 
 template <typename U, typename T>
 U SerializeAndDeserialize(T input) {
   typedef typename mojo::internal::WrapperTraits<T>::DataType InputDataType;
   typedef typename mojo::internal::WrapperTraits<U>::DataType OutputDataType;
 
   size_t size = GetSerializedSize_(*input);
   mojo::internal::FixedBufferForTesting buf(size + 32);
   InputDataType data;
   EXPECT_EQ(mojo::internal::ValidationError::NONE,
             Serialize_(input.get(), &buf, &data));
 
   std::vector<Handle> handles;
   data->EncodePointersAndHandles(&handles);
 
   // Set the subsequent area to a special value, so that we can find out if we
   // mistakenly access the area.
   void* subsequent_area = buf.Allocate(32);
   memset(subsequent_area, 0xAA, 32);
 
   OutputDataType output_data = reinterpret_cast<OutputDataType>(data);
   output_data->DecodePointersAndHandles(&handles);
 
   using RawUType = typename mojo::internal::RemoveStructPtr<U>::type;
   U output(RawUType::New());
   Deserialize_(output_data, output.get());
-  return output.Pass();
+  return output;
 }
 
 class StructTest : public testing::Test {
  public:
   ~StructTest() override {}
 
  private:
   Environment env_;
 };
 
@@ skipping 363 matching lines @@
 
     MultiVersionStructV0Ptr output =
         SerializeAndDeserialize<MultiVersionStructV0Ptr>(input.Pass());
     EXPECT_TRUE(output);
     EXPECT_TRUE(output->Equals(*expected_output));
   }
 }
 
 }  // namespace test
 }  // namespace mojo