Convert //tools to use std::unique_ptr

tools/gn/loader_unittest.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 <map>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 22 matching lines @@
                          const std::string& source);
 
   // Returns true if there is/are pending load(s) matching the given file(s).
   bool HasOnePending(const SourceFile& f) const;
   bool HasTwoPending(const SourceFile& f1, const SourceFile& f2) const;
 
   void IssueAllPending();
 
  private:
   struct CannedResult {
-    scoped_ptr<InputFile> input_file;
+    std::unique_ptr<InputFile> input_file;
     std::vector<Token> tokens;
-    scoped_ptr<ParseNode> root;
+    std::unique_ptr<ParseNode> root;
   };
 
   bool AsyncLoadFile(const LocationRange& origin,
                      const BuildSettings* build_settings,
                      const SourceFile& file_name,
                      const Callback& callback,
                      Err* err) {
     pending_.push_back(std::make_pair(file_name, callback));
     return true;
   }
 
-  typedef std::map<SourceFile, scoped_ptr<CannedResult> > CannedResponseMap;
+  typedef std::map<SourceFile, std::unique_ptr<CannedResult>> CannedResponseMap;
   CannedResponseMap canned_responses_;
 
   std::vector< std::pair<SourceFile, Callback> > pending_;
 };
 
 LoaderImpl::AsyncLoadFileCallback MockInputFileManager::GetCallback() {
   return base::Bind(&MockInputFileManager::AsyncLoadFile,
                     base::Unretained(this));
 }
 
 // Sets a given response for a given source file.
 void MockInputFileManager::AddCannedResponse(const SourceFile& source_file,
                                              const std::string& source) {
-  scoped_ptr<CannedResult> canned(new CannedResult);
+  std::unique_ptr<CannedResult> canned(new CannedResult);
   canned->input_file.reset(new InputFile(source_file));
   canned->input_file->SetContents(source);
 
   // Tokenize.
   Err err;
   canned->tokens = Tokenizer::Tokenize(canned->input_file.get(), &err);
   EXPECT_FALSE(err.has_error());
 
   // Parse.
   canned->root = Parser::Parse(canned->tokens, &err);
@@ skipping 95 matching lines @@
   loader->Load(third_file, LocationRange(), second_tc);
   EXPECT_TRUE(mock_ifm_.HasOnePending(build_config));
 
   // Running the build config file should make our third file pending.
   mock_ifm_.IssueAllPending();
   scheduler_.main_loop()->RunUntilIdle();
   EXPECT_TRUE(mock_ifm_.HasTwoPending(second_file, third_file));
 
   EXPECT_FALSE(scheduler_.is_failed());
 }