tracing: get rid of files in TracingController interface

content/browser/tracing/tracing_controller_browsertest.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/file_util.h"
+#include "base/memory/ref_counted_memory.h"
 #include "base/run_loop.h"
 #include "content/browser/tracing/tracing_controller_impl.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/shell/browser/shell.h"
 
 using base::debug::CategoryFilter;
 using base::debug::TraceOptions;
 using base::debug::RECORD_CONTINUOUSLY;
@@ skipping 28 matching lines @@
     get_categories_done_callback_count_++;
     EXPECT_TRUE(categories.size() > 0);
     quit_callback.Run();
   }
 
   void EnableRecordingDoneCallbackTest(base::Closure quit_callback) {
     enable_recording_done_callback_count_++;
     quit_callback.Run();
   }
 
-  void DisableRecordingDoneCallbackTest(base::Closure quit_callback,
-                                        const base::FilePath& file_path) {
+  void DisableRecordingStringDoneCallbackTest(base::Closure quit_callback,
+      base::RefCountedMemory* data) {
+    disable_recording_done_callback_count_++;
+    EXPECT_TRUE(data->size() > 0);
+    quit_callback.Run();
+  }
+
+  void DisableRecordingFileDoneCallbackTest(base::Closure quit_callback,
+                                            const base::FilePath& file_path) {
     disable_recording_done_callback_count_++;
     EXPECT_TRUE(PathExists(file_path));
     int64 file_size;
     base::GetFileSize(file_path, &file_size);
     EXPECT_TRUE(file_size > 0);
     quit_callback.Run();
     last_actual_recording_file_path_ = file_path;
   }
 
   void EnableMonitoringDoneCallbackTest(base::Closure quit_callback) {
@@ skipping 42 matching lines @@
   }
 
   base::FilePath last_actual_recording_file_path() const {
     return last_actual_recording_file_path_;
   }
 
   base::FilePath last_actual_monitoring_file_path() const {
     return last_actual_monitoring_file_path_;
   }
 
-  void TestEnableAndDisableRecording(const base::FilePath& result_file_path) {
+  void TestEnableAndDisableRecordingString() {
     Navigate(shell());
 
     TracingController* controller = TracingController::GetInstance();
 
     {
       base::RunLoop run_loop;
       TracingController::EnableRecordingDoneCallback callback =
           base::Bind(&TracingControllerTest::EnableRecordingDoneCallbackTest,
                      base::Unretained(this),
                      run_loop.QuitClosure());
       bool result = controller->EnableRecording(
           CategoryFilter(), TraceOptions(), callback);
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(enable_recording_done_callback_count(), 1);
     }
 
     {
       base::RunLoop run_loop;
-      TracingController::TracingFileResultCallback callback =
-          base::Bind(&TracingControllerTest::DisableRecordingDoneCallbackTest,
+      base::Callback<void(base::RefCountedMemory*)> callback =
+          base::Bind(&TracingControllerTest
+                         ::DisableRecordingStringDoneCallbackTest,
                      base::Unretained(this),
                      run_loop.QuitClosure());
-      bool result = controller->DisableRecording(result_file_path, callback);
+      bool result = controller->DisableRecording(
+          TracingControllerImpl::CreateStringSink(callback));
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(disable_recording_done_callback_count(), 1);
+    }
+  }
+
+  void TestEnableAndDisableRecordingFile(
+      const base::FilePath& result_file_path) {
+    Navigate(shell());
+
+    TracingController* controller = TracingController::GetInstance();
+
+    {
+      base::RunLoop run_loop;
+      TracingController::EnableRecordingDoneCallback callback =
+          base::Bind(&TracingControllerTest::EnableRecordingDoneCallbackTest,
+                     base::Unretained(this),
+                     run_loop.QuitClosure());
+      bool result = controller->EnableRecording(
+          CategoryFilter(), TraceOptions(), callback);
+      ASSERT_TRUE(result);
+      run_loop.Run();
+      EXPECT_EQ(enable_recording_done_callback_count(), 1);
+    }
+
+    {
+      base::RunLoop run_loop;
+      base::Closure callback =
+          base::Bind(&TracingControllerTest
+                         ::DisableRecordingFileDoneCallbackTest,
+                     base::Unretained(this),
+                     run_loop.QuitClosure(),
+                     result_file_path);
+      bool result = controller->DisableRecording(
+          TracingControllerImpl::CreateFileSink(result_file_path, callback));
+      ASSERT_TRUE(result);
+      run_loop.Run();
+      EXPECT_EQ(disable_recording_done_callback_count(), 1);
     }
   }
 
   void TestEnableCaptureAndDisableMonitoring(
       const base::FilePath& result_file_path) {
     Navigate(shell());
 
     TracingController* controller = TracingController::GetInstance();
 
     {
@@ skipping 36 matching lines @@
           &is_monitoring, &category_filter, &options);
       EXPECT_TRUE(is_monitoring);
       EXPECT_EQ("*", category_filter.ToString());
       EXPECT_FALSE(options.record_mode == RECORD_CONTINUOUSLY);
       EXPECT_TRUE(options.enable_sampling);
       EXPECT_FALSE(options.enable_systrace);
     }
 
     {
       base::RunLoop run_loop;
-      TracingController::TracingFileResultCallback callback =
+      base::Closure callback =
           base::Bind(&TracingControllerTest::
                          CaptureMonitoringSnapshotDoneCallbackTest,
                      base::Unretained(this),
-                     run_loop.QuitClosure());
-      ASSERT_TRUE(controller->CaptureMonitoringSnapshot(result_file_path,
-                                                        callback));
+                     run_loop.QuitClosure(),
+                     result_file_path);
+      ASSERT_TRUE(controller->CaptureMonitoringSnapshot(
+          TracingControllerImpl::CreateFileSink(result_file_path, callback)));
       run_loop.Run();
       EXPECT_EQ(capture_monitoring_snapshot_done_callback_count(), 1);
     }
 
     {
       base::RunLoop run_loop;
       TracingController::DisableMonitoringDoneCallback callback =
           base::Bind(&TracingControllerTest::DisableMonitoringDoneCallbackTest,
                      base::Unretained(this),
                      run_loop.QuitClosure());
@@ skipping 38 matching lines @@
   TracingController::GetCategoriesDoneCallback callback =
       base::Bind(&TracingControllerTest::GetCategoriesDoneCallbackTest,
                  base::Unretained(this),
                  run_loop.QuitClosure());
   ASSERT_TRUE(controller->GetCategories(callback));
   run_loop.Run();
   EXPECT_EQ(get_categories_done_callback_count(), 1);
 }
 
 IN_PROC_BROWSER_TEST_F(TracingControllerTest, EnableAndDisableRecording) {
-  TestEnableAndDisableRecording(base::FilePath());
+  TestEnableAndDisableRecordingString();
 }
 
 IN_PROC_BROWSER_TEST_F(TracingControllerTest,
                        EnableAndDisableRecordingWithFilePath) {
   base::FilePath file_path;
   base::CreateTemporaryFile(&file_path);
-  TestEnableAndDisableRecording(file_path);
+  TestEnableAndDisableRecordingFile(file_path);
   EXPECT_EQ(file_path.value(), last_actual_recording_file_path().value());
 }
 
 IN_PROC_BROWSER_TEST_F(TracingControllerTest,
                        EnableAndDisableRecordingWithEmptyFileAndNullCallback) {
   Navigate(shell());
 
   TracingController* controller = TracingController::GetInstance();
   EXPECT_TRUE(controller->EnableRecording(
       CategoryFilter(),
       TraceOptions(),
       TracingController::EnableRecordingDoneCallback()));
-  EXPECT_TRUE(controller->DisableRecording(
-      base::FilePath(), TracingController::TracingFileResultCallback()));
+  EXPECT_TRUE(controller->DisableRecording(NULL));
   base::RunLoop().RunUntilIdle();
 }
 
 IN_PROC_BROWSER_TEST_F(TracingControllerTest,
                        EnableCaptureAndDisableMonitoring) {
-  TestEnableCaptureAndDisableMonitoring(base::FilePath());
+  base::FilePath file_path;
+  base::CreateTemporaryFile(&file_path);
+  TestEnableCaptureAndDisableMonitoring(file_path);
 }
 
 IN_PROC_BROWSER_TEST_F(TracingControllerTest,
                        EnableCaptureAndDisableMonitoringWithFilePath) {
   base::FilePath file_path;
   base::CreateTemporaryFile(&file_path);
   TestEnableCaptureAndDisableMonitoring(file_path);
   EXPECT_EQ(file_path.value(), last_actual_monitoring_file_path().value());
 }
 
@@ skipping 10 matching lines @@
     MAYBE_EnableCaptureAndDisableMonitoringWithEmptyFileAndNullCallback) {
   Navigate(shell());
 
   TracingController* controller = TracingController::GetInstance();
   TraceOptions trace_options;
   trace_options.enable_sampling = true;
   EXPECT_TRUE(controller->EnableMonitoring(
       CategoryFilter("*"),
       trace_options,
       TracingController::EnableMonitoringDoneCallback()));
-  controller->CaptureMonitoringSnapshot(
-      base::FilePath(), TracingController::TracingFileResultCallback());
+  controller->CaptureMonitoringSnapshot(NULL);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(controller->DisableMonitoring(
       TracingController::DisableMonitoringDoneCallback()));
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace content