Coverity: Fix a few pass-by-values.

base/move.h

 // Copyright (c) 2012 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.
 
 #ifndef BASE_MOVE_H_
 #define BASE_MOVE_H_
 
 // Macro with the boilerplate that makes a type move-only in C++03.
 //
 // USAGE
 //
 // This macro should be used instead of DISALLOW_COPY_AND_ASSIGN to create
 // a "move-only" type.  Unlike DISALLOW_COPY_AND_ASSIGN, this macro should be
 // the first line in a class declaration.
 //
 // A class using this macro must call .Pass() (or somehow be an r-value already)
 // before it can be:
 //
 //   * Passed as a function argument
 //   * Used as the right-hand side of an assignment
-//   * Return from a function
+//   * Returned from a function
 //
 // Each class will still need to define their own "move constructor" and "move
 // operator=" to make this useful.  Here's an example of the macro, the move
 // constructor, and the move operator= from the scoped_ptr class:
 //
 //  template <typename T>
 //  class scoped_ptr {
 //     MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)
 //   public:
 //    scoped_ptr(RValue& other) : ptr_(other.release()) { }
@@ skipping 83 matching lines @@
 //
 //   1) All its methods are declared, but intentionally not defined.
 //   2) It is *never* instantiated.
 //   3) It is a child of the move-only type.
 //
 // (1) is a guard against accidental violation of (2).  If an instance of
 // RValue were ever created, either as a temporary, or as a copy to some
 // function parameter or field of a class, the binary will not link.
 //
 // This ensures that RValue can only exist as a temporary which is important
-// to avoid accidental danging references.
+// to avoid accidental dangling references.
 //
 // (3) allows us to get around instantiations because our user-defined
 // conversion can return a downcast of this pointer.
 //
 //    operator RValue&() { return *reinterpret_cast<RValue*>(this); }
 //
 // Because RValue does not extend the object size or add any virtual methods,
 // this type-pun is safe.
 //
 // An alternative implementation would be to make RValue into a concrete
@@ skipping 66 matching lines @@
     void operator=(const rvalue_type&); \
   }; \
   type(type&); \
   void operator=(type&); \
  public: \
   operator rvalue_type&() { return *reinterpret_cast<rvalue_type*>(this); } \
   type Pass() { return type(*reinterpret_cast<rvalue_type*>(this)); } \
  private:
 
 #endif  // BASE_MOVE_H_