tracing: get rid of files in TracingController interface

content/browser/tracing/tracing_ui.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 "content/browser/tracing/tracing_ui.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
-#include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "content/browser/tracing/grit/tracing_resources.h"
@@ skipping 102 matching lines @@
   base::RefCountedString* res = new base::RefCountedString();
   callback.Run(res);
 }
 
 void OnTraceBufferPercentFullResult(
     const WebUIDataSource::GotDataCallback& callback, float result) {
   std::string str = base::DoubleToString(result);
   callback.Run(base::RefCountedString::TakeString(&str));
 }
 
-void ReadRecordingResult(const WebUIDataSource::GotDataCallback& callback,
-                         const base::FilePath& path) {
-  std::string tmp;
-  if (!base::ReadFileToString(path, &tmp))
-    LOG(ERROR) << "Failed to read file " << path.value();
-  base::DeleteFile(path, false);
-  callback.Run(base::RefCountedString::TakeString(&tmp));
-}
-
-void BeginReadingRecordingResult(
-    const WebUIDataSource::GotDataCallback& callback,
-    const base::FilePath& path) {
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(ReadRecordingResult, callback, path));
-}
-
 void OnMonitoringEnabledAck(const WebUIDataSource::GotDataCallback& callback);
 
 bool EnableMonitoring(const std::string& data64,
                       const WebUIDataSource::GotDataCallback& callback) {
   base::debug::TraceOptions tracing_options;
   base::debug::CategoryFilter category_filter("");
   if (!GetTracingOptions(data64, &category_filter, &tracing_options))
     return false;
 
   return TracingController::GetInstance()->EnableMonitoring(
@@ skipping 32 matching lines @@
   std::string monitoring_options_json;
   base::JSONWriter::Write(monitoring_options.get(), &monitoring_options_json);
 
   base::RefCountedString* monitoring_options_base64 =
     new base::RefCountedString();
   base::Base64Encode(monitoring_options_json,
                      &monitoring_options_base64->data());
   callback.Run(monitoring_options_base64);
 }
 
-void ReadMonitoringSnapshot(const WebUIDataSource::GotDataCallback& callback,
-                            const base::FilePath& path) {
-  std::string tmp;
-  if (!base::ReadFileToString(path, &tmp))
-    LOG(ERROR) << "Failed to read file " << path.value();
-  base::DeleteFile(path, false);
-  callback.Run(base::RefCountedString::TakeString(&tmp));
-}
-
-void OnMonitoringSnapshotCaptured(
-    const WebUIDataSource::GotDataCallback& callback,
-    const base::FilePath& path) {
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(ReadMonitoringSnapshot, callback, path));
+void TracingCallbackWrapper(const WebUIDataSource::GotDataCallback& callback,
+                            base::RefCountedString* data) {
+  callback.Run(data);
 }
 
 bool OnBeginJSONRequest(const std::string& path,
                         const WebUIDataSource::GotDataCallback& callback) {
   if (path == "json/categories") {
     return TracingController::GetInstance()->GetCategories(
         base::Bind(OnGotCategories, callback));
   }
 
   const char* beginRecordingPath = "json/begin_recording?";
   if (StartsWithASCII(path, beginRecordingPath, true)) {
     std::string data = path.substr(strlen(beginRecordingPath));
     return BeginRecording(data, callback);
   }
   if (path == "json/get_buffer_percent_full") {
     return TracingController::GetInstance()->GetTraceBufferPercentFull(
         base::Bind(OnTraceBufferPercentFullResult, callback));
   }
   if (path == "json/end_recording") {
     return TracingController::GetInstance()->DisableRecording(
-        base::FilePath(), base::Bind(BeginReadingRecordingResult, callback));
+        TracingControllerImpl::CreateStringSink(
+            base::Bind(TracingCallbackWrapper, callback)));
   }
 
   const char* enableMonitoringPath = "json/begin_monitoring?";
   if (path.find(enableMonitoringPath) == 0) {
     std::string data = path.substr(strlen(enableMonitoringPath));
     return EnableMonitoring(data, callback);
   }
   if (path == "json/end_monitoring") {
     return TracingController::GetInstance()->DisableMonitoring(
         base::Bind(OnMonitoringDisabled, callback));
   }
   if (path == "json/capture_monitoring") {
     TracingController::GetInstance()->CaptureMonitoringSnapshot(
-        base::FilePath(), base::Bind(OnMonitoringSnapshotCaptured, callback));
+        TracingControllerImpl::CreateStringSink(
+            base::Bind(TracingCallbackWrapper, callback)));
     return true;
   }
   if (path == "json/get_monitoring_status") {
     GetMonitoringStatus(callback);
     return true;
   }
 
   LOG(ERROR) << "Unhandled request to " << path;
   return false;
 }
@@ skipping 137 matching lines @@
   if (success) {
     web_ui()->CallJavascriptFunction("onUploadComplete",
                                      base::StringValue(report_id));
   } else {
     web_ui()->CallJavascriptFunction("onUploadError",
                                      base::StringValue(error_message));
   }
 }
 
 }  // namespace content