Merge gpu_trace_event back into base/debug/trace_event

content/browser/trace_controller.cc

 // Copyright (c) 2011 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 "content/browser/trace_controller.h"
 
+#include "base/bind.h"
+#include "base/debug/trace_event.h"
 #include "base/task.h"
 #include "content/browser/browser_message_filter.h"
 #include "content/browser/trace_message_filter.h"
 #include "content/common/child_process_messages.h"
-#include "gpu/common/gpu_trace_event.h"
 
 
 TraceController::TraceController() :
     subscriber_(NULL),
     pending_end_ack_count_(0),
     pending_bpf_ack_count_(0),
     maximum_bpf_(0.0f),
     is_tracing_(false) {
-  gpu::TraceLog::GetInstance()->SetOutputCallback(
-      NewCallback(this, &TraceController::OnTraceDataCollected));
+  base::debug::TraceLog::GetInstance()->SetOutputCallback(
+      base::Bind(&TraceController::OnTraceDataCollected,
+                 base::Unretained(this)));
 }
 
 TraceController::~TraceController() {
-  gpu::TraceLog::GetInstance()->SetOutputCallback(NULL);
+  base::debug::TraceLog::GetInstance()->SetOutputCallback(
+    base::debug::TraceLog::OutputCallback());

[Sigurður Ásgeirsson, 2011/05/04 18:58:09]

nit: 4 spaces for continuation.

[scheib, 2011/05/05 00:06:37]

Done.

 }
 
 //static
 TraceController* TraceController::GetInstance() {
   return Singleton<TraceController>::get();
 }
 
 bool TraceController::BeginTracing(TraceSubscriber* subscriber) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!can_begin_tracing() ||
       (subscriber_ != NULL && subscriber != subscriber_))
     return false;
 
   subscriber_ = subscriber;
 
   // Enable tracing
   is_tracing_ = true;
-  gpu::TraceLog::GetInstance()->SetEnabled(true);
+  base::debug::TraceLog::GetInstance()->SetEnabled(true);
 
   // Notify all child processes.
   for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
     it->get()->SendBeginTracing();
   }
 
   return true;
 }
 
 bool TraceController::EndTracingAsync(TraceSubscriber* subscriber) {
@@ skipping 30 matching lines @@
 
   if (!can_get_buffer_percent_full() || subscriber != subscriber_)
     return false;
 
   maximum_bpf_ = 0.0f;
   pending_bpf_ack_count_ = filters_.size() + 1;
 
   // Handle special case of zero child processes.
   if (pending_bpf_ack_count_ == 1) {
     // Ack asynchronously now, because we don't have any children to wait for.
-    float bpf = gpu::TraceLog::GetInstance()->GetBufferPercentFull();
+    float bpf = base::debug::TraceLog::GetInstance()->GetBufferPercentFull();
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this,
                           &TraceController::OnTraceBufferPercentFullReply,
                           bpf));
   }
 
   // Message all child processes.
   for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
     it->get()->SendGetTraceBufferPercentFull();
   }
@@ skipping 48 matching lines @@
     return;
 
   if (--pending_end_ack_count_ == 0) {
     // All acks have been received.
     is_tracing_ = false;
 
     // Disable local trace. During this call, our OnTraceDataCollected will be
     // called with the last of the local trace data. Since we are on the UI
     // thread, the call to OnTraceDataCollected will be synchronous, so we can
     // immediately call OnEndTracingComplete below.
-    gpu::TraceLog::GetInstance()->SetEnabled(false);
+    base::debug::TraceLog::GetInstance()->SetEnabled(false);
 
     // Trigger callback if one is set.
     if (subscriber_) {
       subscriber_->OnEndTracingComplete();
       // Clear subscriber so that others can use TraceController.
       subscriber_ = NULL;
     }
   }
 
   if (pending_end_ack_count_ == 1) {
     // The last ack represents local trace, so we need to ack it now. Note that
     // this code only executes if there were child processes.
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this, &TraceController::OnEndTracingAck));
   }
 }
 
-void TraceController::OnTraceDataCollected(const std::string& data) {
+void TraceController::OnTraceDataCollected(
+    const scoped_refptr<base::debug::TraceLog::RefCountedString>&

[Sigurður Ásgeirsson, 2011/05/04 18:58:09]

nit: is there a typedef you can borrow to make this a little less verbose?

[scheib, 2011/05/05 00:06:37]

Style guidance from jam is to not typedef scoped_refptr

+        json_events_str_ptr) {
   // OnTraceDataCollected may be called from any browser thread, either by the
   // local event trace system or from child processes via TraceMessageFilter.
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        NewRunnableMethod(this, &TraceController::OnTraceDataCollected, data));
+        NewRunnableMethod(this,
+                          &TraceController::OnTraceDataCollected,
+                          json_events_str_ptr));
     return;
   }
 
   if (subscriber_)
-    subscriber_->OnTraceDataCollected(data);
+    subscriber_->OnTraceDataCollected(json_events_str_ptr->data);
 }
 
 void TraceController::OnTraceBufferFull() {
   // OnTraceBufferFull may be called from any browser thread, either by the
   // local event trace system or from child processes via TraceMessageFilter.
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this, &TraceController::OnTraceBufferFull));
     return;
   }
@@ skipping 19 matching lines @@
 
   if (--pending_bpf_ack_count_ == 0) {
     // Trigger callback if one is set.
     if (subscriber_)
       subscriber_->OnTraceBufferPercentFullReply(maximum_bpf_);
   }
 
   if (pending_bpf_ack_count_ == 1) {
     // The last ack represents local trace, so we need to ack it now. Note that
     // this code only executes if there were child processes.
-    float bpf = gpu::TraceLog::GetInstance()->GetBufferPercentFull();
+    float bpf = base::debug::TraceLog::GetInstance()->GetBufferPercentFull();
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this,
                           &TraceController::OnTraceBufferPercentFullReply,
                           bpf));
   }
 }