Update scoped_ptr references to be unique_ptr in src/base comments.

base/scoped_generic.h

 // 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.
 
 #ifndef BASE_SCOPED_GENERIC_H_
 #define BASE_SCOPED_GENERIC_H_
 
 #include <stdlib.h>
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 
 namespace base {
 
-// This class acts like ScopedPtr with a custom deleter (although is slightly
+// This class acts like unique_ptr with a custom deleter (although is slightly
 // less fancy in some of the more escoteric respects) except that it keeps a
 // copy of the object rather than a pointer, and we require that the contained
 // object has some kind of "invalid" value.
 //
 // Defining a scoper based on this class allows you to get a scoper for
 // non-pointer types without having to write custom code for set, reset, and
 // move, etc. and get almost identical semantics that people are used to from
-// scoped_ptr.
+// unique_ptr.
 //
 // It is intended that you will typedef this class with an appropriate deleter
 // to implement clean up tasks for objects that act like pointers from a
 // resource management standpoint but aren't, such as file descriptors and
-// various types of operating system handles. Using scoped_ptr for these
+// various types of operating system handles. Using unique_ptr for these
 // things requires that you keep a pointer to the handle valid for the lifetime
 // of the scoper (which is easy to mess up).
 //
 // For an object to be able to be put into a ScopedGeneric, it must support
 // standard copyable semantics and have a specific "invalid" value. The traits
 // must define a free function and also the invalid value to assign for
 // default-constructed and released objects.
 //
 //   struct FooScopedTraits {
 //     // It's assumed that this is a fast inline function with little-to-no
@@ skipping 49 matching lines @@
     FreeIfNecessary();
   }
 
   // operator=. Allows assignment from a ScopedGeneric rvalue.
   ScopedGeneric& operator=(ScopedGeneric<T, Traits>&& rvalue) {
     reset(rvalue.release());
     return *this;
   }
 
   // Frees the currently owned object, if any. Then takes ownership of a new
-  // object, if given. Self-resets are not allowd as on scoped_ptr. See
+  // object, if given. Self-resets are not allowd as on unique_ptr. See
   // http://crbug.com/162971
   void reset(const element_type& value = traits_type::InvalidValue()) {
     if (data_.generic != traits_type::InvalidValue() && data_.generic == value)
       abort();
     FreeIfNecessary();
     data_.generic = value;
   }
 
   void swap(ScopedGeneric& other) {
     // Standard swap idiom: 'using std::swap' ensures that std::swap is
@@ skipping 62 matching lines @@
 }
 
 template<class T, class Traits>
 bool operator!=(const T& value, const ScopedGeneric<T, Traits>& scoped) {
   return value != scoped.get();
 }
 
 }  // namespace base
 
 #endif  // BASE_SCOPED_GENERIC_H_