Remove base's implicit_cast.

base/memory/scoped_ptr.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.
 
 // Scopers help you manage ownership of a pointer, helping you easily manage a
 // pointer within a scope, and automatically destroying the pointer at the end
 // of a scope.  There are two main classes you will use, which correspond to the
 // operators new/delete and new[]/delete[].
 //
 // Example usage (scoped_ptr<T>):
@@ skipping 447 matching lines @@
   // Constructor. Stores the given array. Note that the argument's type
   // must exactly match T*. In particular:
   // - it cannot be a pointer to a type derived from T, because it is
   //   inherently unsafe in the general case to access an array through a
   //   pointer whose dynamic type does not match its static type (eg., if
   //   T and the derived types had different sizes access would be
   //   incorrectly calculated). Deletion is also always undefined
   //   (C++98 [expr.delete]p3). If you're doing this, fix your code.
   // - it cannot be const-qualified differently from T per unique_ptr spec
   //   (http://cplusplus.github.com/LWG/lwg-active.html#2118). Users wanting
-  //   to work around this may use implicit_cast<const T*>().
+  //   to work around this may use static_cast<const T*>().
   //   However, because of the first bullet in this comment, users MUST
-  //   NOT use implicit_cast<Base*>() to upcast the static type of the array.
+  //   NOT use static_cast<Base*>() to upcast the static type of the array.

[danakj, 2015/09/11 20:44:20]

I'm not sure this is really the right way to say things still.. please confirm.

[Nico, 2015/09/11 20:53:54]

This probably needs const_cast?

[danakj, 2015/09/11 21:20:28]

Ah yah, ok changed both to const_cast in the comment.

   explicit scoped_ptr(element_type* array) : impl_(array) {}
 
   // Constructor.  Allows construction from a nullptr.
   scoped_ptr(decltype(nullptr)) : impl_(nullptr) {}
 
   // Constructor.  Allows construction from a scoped_ptr rvalue.
   scoped_ptr(scoped_ptr&& other) : impl_(&other.impl_) {}
 
   // operator=.  Allows assignment from a scoped_ptr rvalue.
   scoped_ptr& operator=(scoped_ptr&& rhs) {
@@ skipping 104 matching lines @@
 scoped_ptr<T> make_scoped_ptr(T* ptr) {
   return scoped_ptr<T>(ptr);
 }
 
 template <typename T>
 std::ostream& operator<<(std::ostream& out, const scoped_ptr<T>& p) {
   return out << p.get();
 }
 
 #endif  // BASE_MEMORY_SCOPED_PTR_H_