Convert //tools to use std::unique_ptr

tools/gn/input_file_manager.h

 // 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.
 
 #ifndef TOOLS_GN_INPUT_FILE_MANAGER_H_
 #define TOOLS_GN_INPUT_FILE_MANAGER_H_
 
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 64 matching lines @@
   //
   // This solves the problem that sometimes we need to execute something
   // dynamic and save the result, but the values all have references to the
   // nodes and file that created it. Either we need to reset the origin of
   // the values and lose context for error reporting, or somehow keep the
   // associated parse nodes, tokens, and file data in memory. This function
   // allows the latter.
   void AddDynamicInput(const SourceFile& name,
                        InputFile** file,
                        std::vector<Token>** tokens,
-                       scoped_ptr<ParseNode>** parse_root);
+                       std::unique_ptr<ParseNode>** parse_root);
 
   // Does not count dynamic input.
   int GetInputFileCount() const;
 
   // Fills the vector with all input files.
   void GetAllPhysicalInputFileNames(std::vector<base::FilePath>* result) const;
 
  private:
   friend class base::RefCountedThreadSafe<InputFileManager>;
 
   struct InputFileData {
     explicit InputFileData(const SourceFile& file_name);
     ~InputFileData();
 
     // Don't touch this outside the lock until it's marked loaded.
     InputFile file;
 
     bool loaded;
 
     bool sync_invocation;
 
     // Lists all invocations that need to be executed when the file completes
     // loading.
     std::vector<FileLoadCallback> scheduled_callbacks;
 
     // Event to signal when the load is complete (or fails). This is lazily
     // created only when a thread is synchronously waiting for this load (which
     // only happens for imports).
-    scoped_ptr<base::WaitableEvent> completion_event;
+    std::unique_ptr<base::WaitableEvent> completion_event;
 
     std::vector<Token> tokens;
 
     // Null before the file is loaded or if loading failed.
-    scoped_ptr<ParseNode> parsed_root;
+    std::unique_ptr<ParseNode> parsed_root;
     Err parse_error;
   };
 
   virtual ~InputFileManager();
 
   void BackgroundLoadFile(const LocationRange& origin,
                           const BuildSettings* build_settings,
                           const SourceFile& name,
                           InputFile* file);
 
@@ skipping 17 matching lines @@
   //
   // See AddDynamicInput().
   //
   // Owning pointers.
   std::vector<InputFileData*> dynamic_inputs_;
 
   DISALLOW_COPY_AND_ASSIGN(InputFileManager);
 };
 
 #endif  // TOOLS_GN_INPUT_FILE_MANAGER_H_