Sampling profiling thread should be joined in a FILE thread

chrome/test/base/tracing.cc

 // Copyright (c) 2012 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 "chrome/test/base/tracing.h"
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 16 matching lines @@
   InProcessTraceController()
       : is_waiting_on_watch_(false),
         watch_notification_count_(0) {}
   virtual ~InProcessTraceController() {}
 
   bool BeginTracing(const std::string& category_patterns) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     return content::TracingController::GetInstance()->EnableRecording(
         category_patterns, content::TracingController::DEFAULT_OPTIONS,
         content::TracingController::EnableRecordingDoneCallback());
-    return true;
   }
 
   bool BeginTracingWithWatch(const std::string& category_patterns,
                              const std::string& category_name,
                              const std::string& event_name,
                              int num_occurrences) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     DCHECK(num_occurrences > 0);
     watch_notification_count_ = num_occurrences;
-    return content::TracingController::GetInstance()->SetWatchEvent(
-        category_name, event_name,
-        base::Bind(&InProcessTraceController::OnWatchEventMatched,
-                   base::Unretained(this))) &&
-        BeginTracing(category_patterns);
+    if (!content::TracingController::GetInstance()->SetWatchEvent(
+            category_name, event_name,
+            base::Bind(&InProcessTraceController::OnWatchEventMatched,
+                       base::Unretained(this)))) {

[sky, 2014/01/06 18:14:24]

How do you know unretained is safe here and on 55? Also, don't you need to
cancel the watch?

[haraken, 2014/01/07 02:04:43]

InProcessTraceController is a Singleton, so I think it's safe to use unretained.
(Previous code is also using unretained.)
I don't know, but there has been no code about cancellation.

+      return false;
+    }
+    if (!content::TracingController::GetInstance()->EnableRecording(
+            category_patterns, content::TracingController::DEFAULT_OPTIONS,
+            base::Bind(&InProcessTraceController::OnEnableTracingComplete,
+                       base::Unretained(this)))) {
+      return false;
+    }
+
+    message_loop_runner_ = new content::MessageLoopRunner;
+    message_loop_runner_->Run();
+    return true;
   }
 
   bool WaitForWatchEvent(base::TimeDelta timeout) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (watch_notification_count_ == 0)
       return true;
 
     if (timeout != base::TimeDelta()) {
       timer_.Start(FROM_HERE, timeout, this,
                    &InProcessTraceController::Timeout);
@@ skipping 24 matching lines @@
 
     // Watch notifications can occur during this method's message loop run, but
     // not after, so clear them here.
     watch_notification_count_ = 0;
     return true;
   }
 
  private:
   friend struct DefaultSingletonTraits<InProcessTraceController>;
 
+  void OnEnableTracingComplete() {
+    message_loop_runner_->Quit();
+  }
+
   void OnEndTracingComplete() {
     message_loop_runner_->Quit();
   }
 
   void OnTraceDataCollected(std::string* json_trace_output,
                             const base::FilePath& path) {
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
         base::Bind(&InProcessTraceController::ReadTraceData,
                    base::Unretained(this),
                    base::Unretained(json_trace_output),
@@ skipping 65 matching lines @@
 bool WaitForWatchEvent(base::TimeDelta timeout) {
   return InProcessTraceController::GetInstance()->WaitForWatchEvent(timeout);
 }
 
 bool EndTracing(std::string* json_trace_output) {
   return InProcessTraceController::GetInstance()->EndTracing(json_trace_output);
 }
 
 }  // namespace tracing