Small non-essential fixes around the code.

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
@@ skipping 107 matching lines @@
 // It is tempting to want to use the RValue type in function parameters, but
 // excluding the limited usage here for the move constructor and move
 // operator=, doing so would mean that the function could take both r-values
 // and l-values equially which is unexpected.  See COMPARED To Boost.Move for
 // more details.
 //
 // An alternate, and incorrect, implementation of the RValue class used by
 // Boost.Move makes RValue a fieldless child of the move-only type. RValue&
 // is then used in place of RValue in the various operators.  The RValue& is
 // "created" by doing *reinterpret_cast<RValue*>(this).  This has the appeal
-// of never creating a temproary RValue struct even with optimizations
+// of never creating a temporary RValue struct even with optimizations
 // disabled.  Also, by virtue of inheritance you can treat the RValue
-// reference as if it were the move-only type itself.  Unfortuantely,
+// reference as if it were the move-only type itself.  Unfortunately,
 // using the result of this reinterpret_cast<> is actually undefined behavior
-// due to C++98 5.2.10.7. In certain compilers (eg., NaCl) the optimizer
+// due to C++98 5.2.10.7. In certain compilers (e.g., NaCl) the optimizer
 // will generate non-working code.
 //
 // In optimized builds, both implementations generate the same assembly so we
-// choose the one that adheres to the standard. ☃
+// choose the one that adheres to the standard.
 //
 //
 // COMPARED TO C++11
 //
 // In C++11, you would implement this functionality using an r-value reference
 // and our .Pass() method would be replaced with a call to std::move().
 //
 // This emulation also has a deficiency where it uses up the single
 // user-defined conversion allowed by C++ during initialization.  This can
 // cause problems in some API edge cases.  For instance, in scoped_ptr, it is
-// impossible to make an function "void Foo(scoped_ptr<Parent> p)" accept a
+// impossible to make a function "void Foo(scoped_ptr<Parent> p)" accept a
 // value of type scoped_ptr<Child> even if you add a constructor to
 // scoped_ptr<> that would make it look like it should work.  C++11 does not
 // have this deficiency.
 //
 //
 // COMPARED TO Boost.Move
 //
 // Our implementation similar to Boost.Move, but we keep the RValue struct
 // private to the move-only type, and we don't use the reinterpret_cast<> hack.
 //
@@ skipping 12 matching lines @@
 //
 //   void MyFunc(const Foo& f)
 //
 // that would catch the l-values first.  This was declared unsafe in C++11 and
 // a C++11 compiler will explicitly fail MyFunc(f).  Unfortunately, we cannot
 // ensure this in C++03.
 //
 // Since we have no need for writing such APIs yet, our implementation keeps
 // RValue private and uses a .Pass() method to do the conversion instead of
 // trying to write a version of "std::move()." Writing an API like std::move()
-// would require the RValue structs to be public.
+// would require the RValue struct to be public.
 //
 //
 // CAVEATS
 //
 // If you include a move-only type as a field inside a class that does not
 // explicitly declare a copy constructor, the containing class's implicit
 // copy constructor will change from Containing(const Containing&) to
 // Containing(Containing&).  This can cause some unexpected errors.
 //
 //   http://llvm.org/bugs/show_bug.cgi?id=11528
 //
 // The workaround is to explicitly declare your copy constructor.
 //
 #define MOVE_ONLY_TYPE_FOR_CPP_03(type, rvalue_type) \
  private: \
   struct rvalue_type { \
     explicit rvalue_type(type* object) : object(object) {} \
     type* object; \
   }; \
   type(type&); \
   void operator=(type&); \
  public: \
   operator rvalue_type() { return rvalue_type(this); } \
   type Pass() { return type(rvalue_type(this)); } \
  private:
 
 #endif  // BASE_MOVE_H_