tools/gn: replace usage of linked_ptr by using scoped_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/memory/linked_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tools/gn/build_settings.h"
 #include "tools/gn/err.h"
 #include "tools/gn/loader.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/parser.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/tokenizer.h"
 
@@ skipping 27 matching lines @@
 
   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;
   }
 
   // Owning pointers.

[brettw, 2015/12/01 20:28:49]

Can you delete this comment now?

[tfarina, 2015/12/01 20:40:25]

Done.

-  typedef std::map<SourceFile, linked_ptr<CannedResult> > CannedResponseMap;
+  typedef std::map<SourceFile, scoped_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) {
-  CannedResult* canned = new CannedResult;
+  scoped_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).Pass();
   EXPECT_FALSE(err.has_error());
 
-  canned_responses_[source_file] = linked_ptr<CannedResult>(canned);
+  canned_responses_[source_file] = std::move(canned);
 }
 
 bool MockInputFileManager::HasOnePending(const SourceFile& f) const {
   return pending_.size() == 1u && pending_[0].first == f;
 }
 
 bool MockInputFileManager::HasTwoPending(const SourceFile& f1,
                                          const SourceFile& f2) const {
   if (pending_.size() != 2u)
     return false;
@@ skipping 82 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());
 }