Convert //tools to use std::unique_ptr

tools/gn/input_file_manager.cc

 // Copyright (c) 2013 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.
 
 #include "tools/gn/input_file_manager.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/parser.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/scope_per_file_provider.h"
 #include "tools/gn/tokenizer.h"
 #include "tools/gn/trace.h"
 
 namespace {
 
 void InvokeFileLoadCallback(const InputFileManager::FileLoadCallback& cb,
                             const ParseNode* node) {
   cb.Run(node);
 }
 
 bool DoLoadFile(const LocationRange& origin,
                 const BuildSettings* build_settings,
                 const SourceFile& name,
                 InputFile* file,
                 std::vector<Token>* tokens,
-                scoped_ptr<ParseNode>* root,
+                std::unique_ptr<ParseNode>* root,
                 Err* err) {
   // Do all of this stuff outside the lock. We should not give out file
   // pointers until the read is complete.
   if (g_scheduler->verbose_logging()) {
     std::string logmsg = name.value();
     if (origin.begin().file())
       logmsg += " (referenced from " + origin.begin().Describe(false) + ")";
     g_scheduler->Log("Loading", logmsg);
   }
 
@@ skipping 178 matching lines @@
 
   // The other load could have failed. It is possible that this thread's error
   // will be reported to the scheduler before the other thread's (and the first
   // error reported "wins"). Forward the parse error from the other load for
   // this thread so that the error message is useful.
   if (!data->parsed_root)
     *err = data->parse_error;
   return data->parsed_root.get();
 }
 
-void InputFileManager::AddDynamicInput(const SourceFile& name,
-                                       InputFile** file,
-                                       std::vector<Token>** tokens,
-                                       scoped_ptr<ParseNode>** parse_root) {
+void InputFileManager::AddDynamicInput(
+    const SourceFile& name,
+    InputFile** file,
+    std::vector<Token>** tokens,
+    std::unique_ptr<ParseNode>** parse_root) {
   InputFileData* data = new InputFileData(name);
   {
     base::AutoLock lock(lock_);
     dynamic_inputs_.push_back(data);
   }
   *file = &data->file;
   *tokens = &data->tokens;
   *parse_root = &data->parsed_root;
 }
 
@@ skipping 20 matching lines @@
   if (!LoadFile(origin, build_settings, name, file, &err))
     g_scheduler->FailWithError(err);
 }
 
 bool InputFileManager::LoadFile(const LocationRange& origin,
                                 const BuildSettings* build_settings,
                                 const SourceFile& name,
                                 InputFile* file,
                                 Err* err) {
   std::vector<Token> tokens;
-  scoped_ptr<ParseNode> root;
+  std::unique_ptr<ParseNode> root;
   bool success = DoLoadFile(origin, build_settings, name, file,
                             &tokens, &root, err);
   // Can't return early. We have to ensure that the completion event is
   // signaled in all cases bacause another thread could be blocked on this one.
 
   // Save this pointer for running the callbacks below, which happens after the
   // scoped ptr ownership is taken away inside the lock.
   ParseNode* unowned_root = root.get();
 
   std::vector<FileLoadCallback> callbacks;
@@ skipping 29 matching lines @@
 
   // Run pending invocations. Theoretically we could schedule each of these
   // separately to get some parallelism. But normally there will only be one
   // item in the list, so that's extra overhead and complexity for no gain.
   if (success) {
     for (const auto& cb : callbacks)
       cb.Run(unowned_root);
   }
   return success;
 }