test launcher: Fix running a single test using filter.

base/test/test_launcher.cc

 // Copyright 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 "base/test/test_launcher.h"
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/environment.h"
@@ skipping 110 matching lines @@
   // Called when test named |name| is scheduled to be started.
   void OnTestStarted(const std::string& name);
 
   // Called when all tests that were to be started have been scheduled
   // to be started.
   void OnAllTestsStarted();
 
   // Adds |result| to the stored test results.
   void AddTestResult(const TestResult& result);
 
+  WeakPtr<ResultsPrinter> GetWeakPtr();
+
  private:
   // Prints a list of tests that finished with |status|.
   void PrintTestsByStatus(TestResult::Status status,
                           const std::string& description);
 
   // Test results grouped by test case name.
   typedef std::map<std::string, std::vector<TestResult> > ResultsMap;
   ResultsMap results_;
 
   // List of full names of failed tests.
   typedef std::map<TestResult::Status, std::vector<std::string> > StatusMap;
   StatusMap tests_by_status_;
 
   size_t test_started_count_;
 
   // Total number of tests run.
   size_t test_run_count_;
 
   // File handle of output file (can be NULL if no file).
   FILE* out_;
 
   RunTestsCallback callback_;
 
   ThreadChecker thread_checker_;
 
+  WeakPtrFactory<ResultsPrinter> weak_ptr_;
+
   DISALLOW_COPY_AND_ASSIGN(ResultsPrinter);
 };
 
 ResultsPrinter::ResultsPrinter(const CommandLine& command_line,
                                const RunTestsCallback& callback)
     : test_started_count_(0),
       test_run_count_(0),
       out_(NULL),
-      callback_(callback) {
+      callback_(callback),
+      weak_ptr_(this) {
   if (!command_line.HasSwitch(kGTestOutputFlag))
     return;
   std::string flag = command_line.GetSwitchValueASCII(kGTestOutputFlag);
   size_t colon_pos = flag.find(':');
   FilePath path;
   if (colon_pos != std::string::npos) {
     FilePath flag_path =
         command_line.GetSwitchValuePath(kGTestOutputFlag);
     FilePath::StringType path_string = flag_path.value();
     path = FilePath(path_string.substr(colon_pos + 1));
@@ skipping 109 matching lines @@
     PrintTestsByStatus(TestResult::TEST_CRASH, "crashed");
     PrintTestsByStatus(TestResult::TEST_UNKNOWN, "had unknown result");
 
     callback_.Run(
         tests_by_status_[TestResult::TEST_SUCCESS].size() == test_run_count_);
 
     delete this;
   }
 }
 
+WeakPtr<ResultsPrinter> ResultsPrinter::GetWeakPtr() {
+  return weak_ptr_.GetWeakPtr();
+}
+
 void ResultsPrinter::PrintTestsByStatus(TestResult::Status status,
                                         const std::string& description) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const std::vector<std::string>& tests = tests_by_status_[status];
   if (tests.empty())
     return;
   fprintf(stdout,
           "%" PRIuS " test%s %s:\n",
           tests.size(),
@@ skipping 113 matching lines @@
     }
   }
 
   MessageLoop::current()->PostTask(
       FROM_HERE,
       Bind(&TestLauncherDelegate::RunRemainingTests,
       Unretained(launcher_delegate)));
 
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      Bind(&ResultsPrinter::OnAllTestsStarted, Unretained(printer)));
+      Bind(&ResultsPrinter::OnAllTestsStarted, printer->GetWeakPtr()));
 }
 
 void RunTestIteration(TestLauncherDelegate* launcher_delegate,
                       int32 total_shards,
                       int32 shard_index,
                       int cycles,
                       int* exit_code,
                       bool run_tests_success) {
   if (!run_tests_success) {
     *exit_code = 1;
@@ skipping 148 matching lines @@
            cycles,
            &exit_code,
            true));
 
   MessageLoop::current()->Run();
 
   return exit_code;
 }
 
 }  // namespace base