Use scoped_ptr::Pass instead of scoped_ptr::PassAs<T>.

tools/gn/operators_unittest.cc

 // Copyright (c) 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 "testing/gtest/include/gtest/gtest.h"
 #include "tools/gn/operators.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/pattern.h"
 #include "tools/gn/test_with_scope.h"
 
@@ skipping 41 matching lines @@
   node.set_left(scoped_ptr<ParseNode>(new IdentifierNode(identifier_token)));
 
   // Set up the filter on the scope to remove everything ending with "rm"
   scoped_ptr<PatternList> pattern_list(new PatternList);
   pattern_list->Append(Pattern("*rm"));
   setup.scope()->set_sources_assignment_filter(pattern_list.Pass());
 
   // Append an integer.
   const char integer_value[] = "5";
   Token integer(Location(), Token::INTEGER, integer_value);
-  node.set_right(ListWithLiteral(integer).PassAs<ParseNode>());
+  node.set_right(ListWithLiteral(integer));
   node.Execute(setup.scope(), &err);
   EXPECT_FALSE(err.has_error());
 
   // Append a string that doesn't match the pattern, it should get appended.
   const char string_1_value[] = "\"good\"";
   Token string_1(Location(), Token::STRING, string_1_value);
-  node.set_right(ListWithLiteral(string_1).PassAs<ParseNode>());
+  node.set_right(ListWithLiteral(string_1));
   node.Execute(setup.scope(), &err);
   EXPECT_FALSE(err.has_error());
 
   // Append a string that does match the pattern, it should be a no-op.
   const char string_2_value[] = "\"foo-rm\"";
   Token string_2(Location(), Token::STRING, string_2_value);
-  node.set_right(ListWithLiteral(string_2).PassAs<ParseNode>());
+  node.set_right(ListWithLiteral(string_2));
   node.Execute(setup.scope(), &err);
   EXPECT_FALSE(err.has_error());
 
   // Append a list with the two strings from above.
   ListNode list;
   list.append_item(scoped_ptr<ParseNode>(new LiteralNode(string_1)));
   list.append_item(scoped_ptr<ParseNode>(new LiteralNode(string_2)));
   ExecuteBinaryOperator(setup.scope(), &node, node.left(), &list, &err);
   EXPECT_FALSE(err.has_error());
 
@@ skipping 24 matching lines @@
   node.set_op(op);
 
   // Append to the foo variable.
   Token identifier_token(Location(), Token::IDENTIFIER, foo);
   node.set_left(scoped_ptr<ParseNode>(new IdentifierNode(identifier_token)));
 
   // Append a list with a list, the result should be a nested list.
   scoped_ptr<ListNode> outer_list(new ListNode);
   const char twelve_str[] = "12";
   Token twelve(Location(), Token::INTEGER, twelve_str);
-  outer_list->append_item(ListWithLiteral(twelve).PassAs<ParseNode>());
-  node.set_right(outer_list.PassAs<ParseNode>());
+  outer_list->append_item(ListWithLiteral(twelve));
+  node.set_right(outer_list.Pass());
 
   Value ret = ExecuteBinaryOperator(setup.scope(), &node, node.left(),
                                     node.right(), &err);
   EXPECT_FALSE(err.has_error());
 
   // Return from the operator should always be "none", it should update the
   // value only.
   EXPECT_EQ(Value::NONE, ret.type());
 
   // The value should be updated with "[ [ 12 ] ]"
@@ skipping 61 matching lines @@
 
   // Set right as foo, but don't define a value for it.
   const char foo[] = "foo";
   Token identifier_token(Location(), Token::IDENTIFIER, foo);
   node.set_right(scoped_ptr<ParseNode>(new IdentifierNode(identifier_token)));
 
   Value ret = ExecuteBinaryOperator(setup.scope(), &node, node.left(),
                                     node.right(), &err);
   EXPECT_FALSE(err.has_error());
 }