Replace SmartPointer<T> with unique_ptr<T>

src/debug/debug.cc

 // Copyright 2012 the V8 project 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 "src/debug/debug.h"
 
+#include <memory>
+
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
 #include "src/codegen.h"
 #include "src/compilation-cache.h"
 #include "src/compiler.h"
 #include "src/deoptimizer.h"
 #include "src/execution.h"
 #include "src/frames-inl.h"
@@ skipping 217 matching lines @@
 
 BreakLocation BreakLocation::BytecodeArrayIterator::GetBreakLocation() {
   return BreakLocation(debug_info_, GetDebugBreakType(), code_offset(),
                        position(), statement_position());
 }
 
 // Find the break point at the supplied address, or the closest one before
 // the address.
 BreakLocation BreakLocation::FromCodeOffset(Handle<DebugInfo> debug_info,
                                             int offset) {
-  base::SmartPointer<Iterator> it(GetIterator(debug_info));
+  std::unique_ptr<Iterator> it(GetIterator(debug_info));
   it->SkipTo(BreakIndexFromCodeOffset(debug_info, offset));
   return it->GetBreakLocation();
 }
 
 BreakLocation BreakLocation::FromFrame(Handle<DebugInfo> debug_info,
                                        JavaScriptFrame* frame) {
   int code_offset = FrameSummary::GetFirst(frame).code_offset();
   int call_offset =
       CallOffsetFromCodeOffset(code_offset, frame->is_interpreted());
   return FromCodeOffset(debug_info, call_offset);
 }
 
 void BreakLocation::AllForStatementPosition(Handle<DebugInfo> debug_info,
                                             int statement_position,
                                             List<BreakLocation>* result_out) {
-  for (base::SmartPointer<Iterator> it(GetIterator(debug_info)); !it->Done();
+  for (std::unique_ptr<Iterator> it(GetIterator(debug_info)); !it->Done();
        it->Next()) {
     if (it->statement_position() == statement_position) {
       result_out->Add(it->GetBreakLocation());
     }
   }
 }
 
 int BreakLocation::BreakIndexFromCodeOffset(Handle<DebugInfo> debug_info,
                                             int offset) {
   // Run through all break points to locate the one closest to the address.
   int closest_break = 0;
   int distance = kMaxInt;
   DCHECK(0 <= offset && offset < debug_info->abstract_code()->Size());
-  for (base::SmartPointer<Iterator> it(GetIterator(debug_info)); !it->Done();
+  for (std::unique_ptr<Iterator> it(GetIterator(debug_info)); !it->Done();
        it->Next()) {
     // Check if this break point is closer that what was previously found.
     if (it->code_offset() <= offset && offset - it->code_offset() < distance) {
       closest_break = it->break_index();
       distance = offset - it->code_offset();
       // Check whether we can't get any closer.
       if (distance == 0) break;
     }
   }
   return closest_break;
 }
 
 
 BreakLocation BreakLocation::FromPosition(Handle<DebugInfo> debug_info,
                                           int position,
                                           BreakPositionAlignment alignment) {
   // Run through all break points to locate the one closest to the source
   // position.
   int distance = kMaxInt;
-  base::SmartPointer<Iterator> it(GetIterator(debug_info));
+  std::unique_ptr<Iterator> it(GetIterator(debug_info));
   BreakLocation closest_break = it->GetBreakLocation();
   while (!it->Done()) {
     int next_position;
     if (alignment == STATEMENT_ALIGNED) {
       next_position = it->statement_position();
     } else {
       DCHECK(alignment == BREAK_POSITION_ALIGNED);
       next_position = it->position();
     }
     if (position <= next_position && next_position - position < distance) {
@@ skipping 539 matching lines @@
   }
 }
 
 
 // Clear out all the debug break code. This is ONLY supposed to be used when
 // shutting down the debugger as it will leave the break point information in
 // DebugInfo even though the code is patched back to the non break point state.
 void Debug::ClearAllBreakPoints() {
   for (DebugInfoListNode* node = debug_info_list_; node != NULL;
        node = node->next()) {
-    for (base::SmartPointer<BreakLocation::Iterator> it(
+    for (std::unique_ptr<BreakLocation::Iterator> it(
              BreakLocation::GetIterator(node->debug_info()));
          !it->Done(); it->Next()) {
       it->GetBreakLocation().ClearDebugBreak();
     }
   }
   // Remove all debug info.
   while (debug_info_list_ != NULL) {
     RemoveDebugInfoAndClearFromShared(debug_info_list_->debug_info());
   }
 }
@@ skipping 13 matching lines @@
   }
   // Make sure the function is compiled and has set up the debug info.
   Handle<SharedFunctionInfo> shared(function->shared());
   if (!EnsureDebugInfo(shared, function)) {
     // Return if we failed to retrieve the debug info.
     return;
   }
 
   // Flood the function with break points.
   Handle<DebugInfo> debug_info(shared->GetDebugInfo());
-  for (base::SmartPointer<BreakLocation::Iterator> it(
+  for (std::unique_ptr<BreakLocation::Iterator> it(
            BreakLocation::GetIterator(debug_info, type));
        !it->Done(); it->Next()) {
     it->GetBreakLocation().SetOneShot();
   }
 }
 
 
 void Debug::ChangeBreakOnException(ExceptionBreakType type, bool enable) {
   if (type == BreakUncaughtException) {
     break_on_uncaught_exception_ = enable;
@@ skipping 221 matching lines @@
 
 // Clears all the one-shot break points that are currently set. Normally this
 // function is called each time a break point is hit as one shot break points
 // are used to support stepping.
 void Debug::ClearOneShot() {
   // The current implementation just runs through all the breakpoints. When the
   // last break point for a function is removed that function is automatically
   // removed from the list.
   for (DebugInfoListNode* node = debug_info_list_; node != NULL;
        node = node->next()) {
-    for (base::SmartPointer<BreakLocation::Iterator> it(
+    for (std::unique_ptr<BreakLocation::Iterator> it(
              BreakLocation::GetIterator(node->debug_info()));
          !it->Done(); it->Next()) {
       it->GetBreakLocation().ClearOneShot();
     }
   }
 }
 
 
 bool MatchingCodeTargets(Code* target1, Code* target2) {
   if (target1 == target2) return true;
@@ skipping 1431 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8