Revert "Integrate transaction tracing with perfetto"

This reverts commit 8a5640ab9c305b2e03929f2255aabed3ec1b40b3.

Reason for revert: 298512106

Change-Id: I0182c3b75d4b38580430c9ba6b94666e03d48efb

7 files changed, 62 insertions, 372 deletions

diff --git a/services/surfaceflinger/Android.bp b/services/surfaceflinger/Android.bp
index 1718e0b10f..a13dc656c7 100644
--- a/services/surfaceflinger/Android.bp
+++ b/services/surfaceflinger/Android.bp
@@ -200,7 +200,6 @@ filegroup {
         "SurfaceFlingerDefaultFactory.cpp",
         "Tracing/LayerDataSource.cpp",
         "Tracing/LayerTracing.cpp",
-        "Tracing/TransactionDataSource.cpp",
         "Tracing/TransactionTracing.cpp",
         "Tracing/TransactionProtoParser.cpp",
         "Tracing/tools/LayerTraceGenerator.cpp",
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index 38188c05b5..b30469d85c 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -6941,7 +6941,7 @@ status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* r
                         // Transaction tracing is always running but allow the user to temporarily
                         // increase the buffer when actively debugging.
                         mTransactionTracing->setBufferSize(
-                                TransactionTracing::LEGACY_ACTIVE_TRACING_BUFFER_SIZE);
+                                TransactionTracing::ACTIVE_TRACING_BUFFER_SIZE);
                     } else {
                         TransactionTraceWriter::getInstance().invoke("", /* overwrite= */ true);
                         mTransactionTracing->setBufferSize(
@@ -6951,7 +6951,7 @@ status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* r
                 reply->writeInt32(NO_ERROR);
                 return NO_ERROR;
             }
-            case 1042: { // Write transaction trace to file
+            case 1042: { // Write layers trace or transaction trace to file
                 if (mTransactionTracing) {
                     mTransactionTracing->writeToFile();
                 }
diff --git a/services/surfaceflinger/Tracing/TransactionDataSource.cpp b/services/surfaceflinger/Tracing/TransactionDataSource.cpp
deleted file mode 100644
index 05b89b84ad..0000000000
--- a/services/surfaceflinger/Tracing/TransactionDataSource.cpp
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright 2023 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "TransactionDataSource.h"
-#include "TransactionTracing.h"
-
-#undef LOG_TAG
-#define LOG_TAG "TransactionTracing"
-
-#include <log/log.h>
-
-namespace android {
-
-void TransactionDataSource::Initialize(TransactionTracing& transactionTracing) {
-    mTransactionTracing.store(&transactionTracing);
-
-    auto args = perfetto::TracingInitArgs{};
-    args.backends = perfetto::kSystemBackend;
-    perfetto::Tracing::Initialize(args);
-
-    perfetto::DataSourceDescriptor descriptor;
-    descriptor.set_name(kName);
-    TransactionDataSource::Register(descriptor);
-}
-
-void TransactionDataSource::UnregisterTransactionTracing() {
-    mTransactionTracing.store(nullptr);
-}
-
-void TransactionDataSource::OnSetup(const TransactionDataSource::SetupArgs& args) {
-    const auto configRaw = args.config->surfaceflinger_transactions_config_raw();
-    const auto config =
-            perfetto::protos::pbzero::SurfaceFlingerTransactionsConfig::Decoder{configRaw};
-
-    if (config.has_mode() && config.mode() != TransactionTracing::Mode::MODE_UNSPECIFIED) {
-        mMode = static_cast<TransactionTracing::Mode>(config.mode());
-    } else {
-        mMode = TransactionTracing::Mode::MODE_CONTINUOUS;
-        ALOGV("Received config with unspecified 'mode'. Using 'CONTINUOUS' as default");
-    }
-}
-
-void TransactionDataSource::OnStart(const StartArgs&) {
-    ALOGV("Received OnStart event");
-    if (auto* p = mTransactionTracing.load()) {
-        p->onStart(mMode);
-    }
-}
-
-void TransactionDataSource::OnFlush(const FlushArgs&) {
-    ALOGV("Received OnFlush event");
-    if (auto* p = mTransactionTracing.load()) {
-        p->onFlush(mMode);
-    }
-}
-
-void TransactionDataSource::OnStop(const StopArgs&) {
-    ALOGV("Received OnStop event");
-}
-
-TransactionTracing::Mode TransactionDataSource::GetMode() const {
-    return mMode;
-}
-
-std::atomic<TransactionTracing*> TransactionDataSource::mTransactionTracing = nullptr;
-
-} // namespace android
-
-PERFETTO_DEFINE_DATA_SOURCE_STATIC_MEMBERS(android::TransactionDataSource);
diff --git a/services/surfaceflinger/Tracing/TransactionDataSource.h b/services/surfaceflinger/Tracing/TransactionDataSource.h
deleted file mode 100644
index be8373b4ac..0000000000
--- a/services/surfaceflinger/Tracing/TransactionDataSource.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright 2023 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "TransactionTracing.h"
-
-#include <perfetto/tracing.h>
-
-namespace android {
-
-/*
- * Thread local storage used for fast (lock free) read of data source's properties.
- *
- */
-struct TransactionDataSourceTlsState {
-    template <typename TraceContext>
-    explicit TransactionDataSourceTlsState(const TraceContext& trace_context) {
-        auto dataSource = trace_context.GetDataSourceLocked();
-        mMode = dataSource.valid() ? dataSource->GetMode()
-                                   : TransactionTracing::Mode::MODE_CONTINUOUS;
-    }
-
-    TransactionTracing::Mode mMode;
-};
-
-struct TransactionDataSourceTraits : public perfetto::DefaultDataSourceTraits {
-    using TlsStateType = TransactionDataSourceTlsState;
-};
-
-/*
- * Defines the Perfetto custom data source 'android.surfaceflinger.transactions'.
- *
- * Registers the data source with Perfetto, listens to Perfetto events (setup/start/flush/stop)
- * and writes trace packets to Perfetto.
- *
- */
-class TransactionDataSource
-      : public perfetto::DataSource<TransactionDataSource, TransactionDataSourceTraits> {
-public:
-    static void Initialize(TransactionTracing&);
-    static void UnregisterTransactionTracing();
-    void OnSetup(const SetupArgs&) override;
-    void OnStart(const StartArgs&) override;
-    void OnFlush(const FlushArgs&) override;
-    void OnStop(const StopArgs&) override;
-    TransactionTracing::Mode GetMode() const;
-
-    static constexpr auto* kName = "android.surfaceflinger.transactions";
-    static constexpr perfetto::BufferExhaustedPolicy kBufferExhaustedPolicy =
-            perfetto::BufferExhaustedPolicy::kStall;
-    static constexpr bool kRequiresCallbacksUnderLock = false;
-
-private:
-    static std::atomic<TransactionTracing*> mTransactionTracing;
-    TransactionTracing::Mode mMode;
-};
-
-} // namespace android
-
-PERFETTO_DECLARE_DATA_SOURCE_STATIC_MEMBERS(android::TransactionDataSource);
diff --git a/services/surfaceflinger/Tracing/TransactionRingBuffer.h b/services/surfaceflinger/Tracing/TransactionRingBuffer.h
index 7d1d3fd7f2..e6f85ca4a5 100644
--- a/services/surfaceflinger/Tracing/TransactionRingBuffer.h
+++ b/services/surfaceflinger/Tracing/TransactionRingBuffer.h
@@ -47,7 +47,7 @@ public:
         mUsedInBytes = 0U;
     }
 
-    void writeToProto(FileProto& fileProto) const {
+    void writeToProto(FileProto& fileProto) {
         fileProto.mutable_entry()->Reserve(static_cast<int>(mStorage.size()) +
                                            fileProto.entry().size());
         for (const std::string& entry : mStorage) {
@@ -56,6 +56,24 @@ public:
         }
     }
 
+    status_t writeToFile(FileProto& fileProto, std::string filename) {
+        ATRACE_CALL();
+        writeToProto(fileProto);
+        std::string output;
+        if (!fileProto.SerializeToString(&output)) {
+            ALOGE("Could not serialize proto.");
+            return UNKNOWN_ERROR;
+        }
+
+        // -rw-r--r--
+        const mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
+        if (!android::base::WriteStringToFile(output, filename, mode, getuid(), getgid(), true)) {
+            ALOGE("Could not save the proto file %s", filename.c_str());
+            return PERMISSION_DENIED;
+        }
+        return NO_ERROR;
+    }
+
     status_t appendToStream(FileProto& fileProto, std::ofstream& out) {
         ATRACE_CALL();
         writeToProto(fileProto);
diff --git a/services/surfaceflinger/Tracing/TransactionTracing.cpp b/services/surfaceflinger/Tracing/TransactionTracing.cpp
index 0517984dab..8aacbca90c 100644
--- a/services/surfaceflinger/Tracing/TransactionTracing.cpp
+++ b/services/surfaceflinger/Tracing/TransactionTracing.cpp
@@ -25,7 +25,6 @@
 
 #include "Client.h"
 #include "FrontEnd/LayerCreationArgs.h"
-#include "TransactionDataSource.h"
 #include "TransactionTracing.h"
 
 namespace android {
@@ -35,20 +34,15 @@ TransactionTracing::TransactionTracing()
       : mProtoParser(std::make_unique<TransactionProtoParser::FlingerDataMapper>()) {
     std::scoped_lock lock(mTraceLock);
 
-    mBuffer.setSize(CONTINUOUS_TRACING_BUFFER_SIZE);
-
+    mBuffer.setSize(mBufferSizeInBytes);
     mStartingTimestamp = systemTime();
-
     {
         std::scoped_lock lock(mMainThreadLock);
         mThread = std::thread(&TransactionTracing::loop, this);
     }
-
-    TransactionDataSource::Initialize(*this);
 }
 
 TransactionTracing::~TransactionTracing() {
-    TransactionDataSource::UnregisterTransactionTracing();
     std::thread thread;
     {
         std::scoped_lock lock(mMainThreadLock);
@@ -59,94 +53,21 @@ TransactionTracing::~TransactionTracing() {
     if (thread.joinable()) {
         thread.join();
     }
-}
-
-void TransactionTracing::onStart(TransactionTracing::Mode mode) {
-    // In "active" mode write the ring buffer (starting state + following sequence of transactions)
-    // to perfetto when tracing starts (only once).
-    if (mode != Mode::MODE_ACTIVE) {
-        return;
-    }
-
-    writeRingBufferToPerfetto(TransactionTracing::Mode::MODE_ACTIVE);
-
-    ALOGV("Started active mode tracing (wrote initial transactions ring buffer to perfetto)");
-}
-
-void TransactionTracing::onFlush(TransactionTracing::Mode mode) {
-    // In "continuous" mode write the ring buffer (starting state + following sequence of
-    // transactions) to perfetto when a "flush" event is received (bugreport is taken or tracing is
-    // stopped).
-    if (mode != Mode::MODE_CONTINUOUS) {
-        return;
-    }
-
-    writeRingBufferToPerfetto(TransactionTracing::Mode::MODE_CONTINUOUS);
-
-    ALOGV("Flushed continuous mode tracing (wrote transactions ring buffer to perfetto");
-}
-
-void TransactionTracing::writeRingBufferToPerfetto(TransactionTracing::Mode mode) {
-    // Write the ring buffer (starting state + following sequence of transactions) to perfetto
-    // tracing sessions with the specified mode.
-    const auto fileProto = writeToProto();
-
-    TransactionDataSource::Trace([&](TransactionDataSource::TraceContext context) {
-        // Write packets only to tracing sessions with specified mode
-        if (context.GetCustomTlsState()->mMode != mode) {
-            return;
-        }
-        for (const auto& entryProto : fileProto.entry()) {
-            const auto entryBytes = entryProto.SerializeAsString();
-
-            auto packet = context.NewTracePacket();
-            packet->set_timestamp(static_cast<uint64_t>(entryProto.elapsed_realtime_nanos()));
-            packet->set_timestamp_clock_id(perfetto::protos::pbzero::BUILTIN_CLOCK_MONOTONIC);
 
-            auto* transactionsProto = packet->set_surfaceflinger_transactions();
-            transactionsProto->AppendRawProtoBytes(entryBytes.data(), entryBytes.size());
-        }
-        {
-            // TODO (b/162206162): remove empty packet when perfetto bug is fixed.
-            //  It is currently needed in order not to lose the last trace entry.
-            context.NewTracePacket();
-        }
-    });
+    writeToFile();
 }
 
 status_t TransactionTracing::writeToFile(const std::string& filename) {
-    auto fileProto = writeToProto();
-
-    std::string output;
-    if (!fileProto.SerializeToString(&output)) {
-        ALOGE("Could not serialize proto.");
-        return UNKNOWN_ERROR;
-    }
-
-    // -rw-r--r--
-    const mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
-    if (!android::base::WriteStringToFile(output, filename, mode, getuid(), getgid(), true)) {
-        ALOGE("Could not save the proto file %s", filename.c_str());
-        return PERMISSION_DENIED;
-    }
-
-    return NO_ERROR;
-}
-
-perfetto::protos::TransactionTraceFile TransactionTracing::writeToProto() {
-    std::scoped_lock<std::mutex> lock(mTraceLock);
+    std::scoped_lock lock(mTraceLock);
     perfetto::protos::TransactionTraceFile fileProto = createTraceFileProto();
-    const auto startingStateProto = createStartingStateProtoLocked();
-    if (startingStateProto) {
-        *fileProto.add_entry() = std::move(*startingStateProto);
-    }
-    mBuffer.writeToProto(fileProto);
-    return fileProto;
+    addStartingStateToProtoLocked(fileProto);
+    return mBuffer.writeToFile(fileProto, filename);
 }
 
 void TransactionTracing::setBufferSize(size_t bufferSizeInBytes) {
     std::scoped_lock lock(mTraceLock);
-    mBuffer.setSize(bufferSizeInBytes);
+    mBufferSizeInBytes = bufferSizeInBytes;
+    mBuffer.setSize(mBufferSizeInBytes);
 }
 
 perfetto::protos::TransactionTraceFile TransactionTracing::createTraceFileProto() const {
@@ -154,8 +75,8 @@ perfetto::protos::TransactionTraceFile TransactionTracing::createTraceFileProto(
     proto.set_magic_number(
             uint64_t(perfetto::protos::TransactionTraceFile_MagicNumber_MAGIC_NUMBER_H) << 32 |
             perfetto::protos::TransactionTraceFile_MagicNumber_MAGIC_NUMBER_L);
-    auto timeOffsetNs = static_cast<uint64_t>(systemTime(SYSTEM_TIME_REALTIME) -
-                                              systemTime(SYSTEM_TIME_MONOTONIC));
+    auto timeOffsetNs = static_cast<std::uint64_t>(systemTime(SYSTEM_TIME_REALTIME) -
+                                                   systemTime(SYSTEM_TIME_MONOTONIC));
     proto.set_real_to_elapsed_time_offset_nanos(timeOffsetNs);
     proto.set_version(TRACING_VERSION);
     return proto;
@@ -285,34 +206,11 @@ void TransactionTracing::addEntry(const std::vector<CommittedUpdates>& committed
 
         std::string serializedProto;
         entryProto.SerializeToString(&serializedProto);
-
-        TransactionDataSource::Trace([&](TransactionDataSource::TraceContext context) {
-            // In "active" mode write each committed transaction to perfetto.
-            // Note: the starting state is written (once) when the perfetto "start" event is
-            // received.
-            if (context.GetCustomTlsState()->mMode != Mode::MODE_ACTIVE) {
-                return;
-            }
-            {
-                auto packet = context.NewTracePacket();
-                packet->set_timestamp(static_cast<uint64_t>(entryProto.elapsed_realtime_nanos()));
-                packet->set_timestamp_clock_id(perfetto::protos::pbzero::BUILTIN_CLOCK_MONOTONIC);
-                auto* transactions = packet->set_surfaceflinger_transactions();
-                transactions->AppendRawProtoBytes(serializedProto.data(), serializedProto.size());
-            }
-            {
-                // TODO (b/162206162): remove empty packet when perfetto bug is fixed.
-                //  It is currently needed in order not to lose the last trace entry.
-                context.NewTracePacket();
-            }
-        });
-
+        entryProto.Clear();
         std::vector<std::string> entries = mBuffer.emplace(std::move(serializedProto));
         removedEntries.reserve(removedEntries.size() + entries.size());
         removedEntries.insert(removedEntries.end(), std::make_move_iterator(entries.begin()),
                               std::make_move_iterator(entries.end()));
-
-        entryProto.Clear();
     }
 
     perfetto::protos::TransactionTraceEntry removedEntryProto;
@@ -411,38 +309,44 @@ void TransactionTracing::updateStartingStateLocked(
     }
 }
 
-std::optional<perfetto::protos::TransactionTraceEntry>
-TransactionTracing::createStartingStateProtoLocked() {
-    if (mStartingStates.empty()) {
-        return std::nullopt;
+void TransactionTracing::addStartingStateToProtoLocked(
+        perfetto::protos::TransactionTraceFile& proto) {
+    if (mStartingStates.size() == 0) {
+        return;
     }
 
-    perfetto::protos::TransactionTraceEntry entryProto;
-    entryProto.set_elapsed_realtime_nanos(mStartingTimestamp);
-    entryProto.set_vsync_id(0);
+    perfetto::protos::TransactionTraceEntry* entryProto = proto.add_entry();
+    entryProto->set_elapsed_realtime_nanos(mStartingTimestamp);
+    entryProto->set_vsync_id(0);
 
-    entryProto.mutable_added_layers()->Reserve(static_cast<int32_t>(mStartingStates.size()));
+    entryProto->mutable_added_layers()->Reserve(static_cast<int32_t>(mStartingStates.size()));
     for (auto& [layerId, state] : mStartingStates) {
-        entryProto.mutable_added_layers()->Add(mProtoParser.toProto(state.args));
+        entryProto->mutable_added_layers()->Add(mProtoParser.toProto(state.args));
     }
 
     perfetto::protos::TransactionState transactionProto = mProtoParser.toProto(mStartingStates);
     transactionProto.set_vsync_id(0);
     transactionProto.set_post_time(mStartingTimestamp);
-    entryProto.mutable_transactions()->Add(std::move(transactionProto));
+    entryProto->mutable_transactions()->Add(std::move(transactionProto));
 
-    entryProto.mutable_destroyed_layer_handles()->Reserve(
+    entryProto->mutable_destroyed_layer_handles()->Reserve(
             static_cast<int32_t>(mRemovedLayerHandlesAtStart.size()));
     for (const uint32_t destroyedLayerHandleId : mRemovedLayerHandlesAtStart) {
-        entryProto.mutable_destroyed_layer_handles()->Add(destroyedLayerHandleId);
+        entryProto->mutable_destroyed_layer_handles()->Add(destroyedLayerHandleId);
     }
 
-    entryProto.mutable_displays()->Reserve(static_cast<int32_t>(mStartingDisplayInfos.size()));
+    entryProto->mutable_displays()->Reserve(static_cast<int32_t>(mStartingDisplayInfos.size()));
     for (auto& [layerStack, displayInfo] : mStartingDisplayInfos) {
-        entryProto.mutable_displays()->Add(mProtoParser.toProto(displayInfo, layerStack.id));
+        entryProto->mutable_displays()->Add(mProtoParser.toProto(displayInfo, layerStack.id));
     }
+}
 
-    return entryProto;
+perfetto::protos::TransactionTraceFile TransactionTracing::writeToProto() {
+    std::scoped_lock<std::mutex> lock(mTraceLock);
+    perfetto::protos::TransactionTraceFile proto = createTraceFileProto();
+    addStartingStateToProtoLocked(proto);
+    mBuffer.writeToProto(proto);
+    return proto;
 }
 
 } // namespace android
diff --git a/services/surfaceflinger/Tracing/TransactionTracing.h b/services/surfaceflinger/Tracing/TransactionTracing.h
index ddbf3e4873..09fcd8ad96 100644
--- a/services/surfaceflinger/Tracing/TransactionTracing.h
+++ b/services/surfaceflinger/Tracing/TransactionTracing.h
@@ -22,8 +22,8 @@
 #include <utils/Singleton.h>
 #include <utils/Timers.h>
 
+#include <memory>
 #include <mutex>
-#include <optional>
 #include <thread>
 
 #include "FrontEnd/DisplayInfo.h"
@@ -41,7 +41,7 @@ class SurfaceFlinger;
 class TransactionTracingTest;
 
 /*
- * Records all committed transactions into a ring buffer.
+ * Records all committed transactions into a ring bufffer.
  *
  * Transactions come in via the binder thread. They are serialized to proto
  * and stored in a map using the transaction id as key. Main thread will
@@ -49,104 +49,26 @@ class TransactionTracingTest;
  * the tracing thread. The tracing thread will then wake up and add the
  * committed transactions to the ring buffer.
  *
- * The traced data can then be collected via:
- * - Perfetto (preferred).
- * - File system, after triggering the disk write through SF backdoor. This is legacy and is going
- *   to be phased out.
- *
- * The Perfetto custom data source TransactionDataSource is registered with perfetto and is used
- * to listen to perfetto events (setup, start, stop, flush) and to write trace packets to perfetto.
- *
- * The user can configure/start/stop tracing via /system/bin/perfetto.
- *
- * Tracing can operate in the following modes.
- *
- * ACTIVE mode:
- * The transactions ring buffer (starting state + following committed transactions) is written
- * (only once) to perfetto when the 'start' event is received.
- * Transactions are then written to perfetto each time they are committed.
- * On the receiver side, the data source is to be configured to periodically
- * flush data to disk providing virtually infinite storage.
- *
- * CONTINUOUS mode:
- * Listens to the perfetto 'flush' event (e.g. when a bugreport is taken).
- * When a 'flush' event is received, the ring buffer of transactions (starting state + following
- * committed transactions) is written to perfetto. On the receiver side, the data source is to be
- * configured with a dedicated buffer large enough to store all the flushed data.
- *
- *
- * E.g. start active mode tracing:
- *
-   adb shell perfetto \
-     -c - --txt \
-     -o /data/misc/perfetto-traces/trace \
-   <<EOF
-   unique_session_name: "surfaceflinger_transactions_active"
-   buffers: {
-       size_kb: 1024
-       fill_policy: RING_BUFFER
-   }
-   data_sources: {
-       config {
-           name: "android.surfaceflinger.transactions"
-           surfaceflinger_transactions_config: {
-               mode: MODE_ACTIVE
-           }
-       }
-   }
-   write_into_file: true
-   file_write_period_ms: 100
-   EOF
- *
- *
- * E.g. start continuous mode tracing:
- *
-   adb shell perfetto \
-     -c - --txt \
-     -o /data/misc/perfetto-traces/trace \
-   <<EOF
-   unique_session_name: "surfaceflinger_transactions_continuous"
-   buffers: {
-       size_kb: 1024
-       fill_policy: RING_BUFFER
-   }
-   data_sources: {
-       config {
-           name: "android.surfaceflinger.transactions"
-           surfaceflinger_transactions_config: {
-               mode: MODE_CONTINUOUS
-           }
-       }
-   }
-   EOF
+ * When generating SF dump state, we will flush the buffer to a file which
+ * will then be included in the bugreport.
  *
  */
 class TransactionTracing {
 public:
-    using Mode = perfetto::protos::pbzero::SurfaceFlingerTransactionsConfig::Mode;
-
     TransactionTracing();
     ~TransactionTracing();
 
-    // Start event from perfetto data source
-    void onStart(Mode mode);
-    // Flush event from perfetto data source
-    void onFlush(Mode mode);
-
     void addQueuedTransaction(const TransactionState&);
     void addCommittedTransactions(int64_t vsyncId, nsecs_t commitTime, frontend::Update& update,
                                   const frontend::DisplayInfos&, bool displayInfoChanged);
     status_t writeToFile(const std::string& filename = FILE_PATH);
-    // Return buffer contents as trace file proto
-    perfetto::protos::TransactionTraceFile writeToProto() EXCLUDES(mMainThreadLock);
     void setBufferSize(size_t bufferSizeInBytes);
     void onLayerRemoved(int layerId);
     void dump(std::string&) const;
     // Wait until all the committed transactions for the specified vsync id are added to the buffer.
     void flush() EXCLUDES(mMainThreadLock);
-
     static constexpr auto CONTINUOUS_TRACING_BUFFER_SIZE = 512 * 1024;
-    static constexpr auto LEGACY_ACTIVE_TRACING_BUFFER_SIZE = 100 * 1024 * 1024;
+    static constexpr auto ACTIVE_TRACING_BUFFER_SIZE = 100 * 1024 * 1024;
     // version 1 - switching to support new frontend
     static constexpr auto TRACING_VERSION = 1;
 
@@ -166,6 +88,7 @@ private:
     TransactionRingBuffer<perfetto::protos::TransactionTraceFile,
                           perfetto::protos::TransactionTraceEntry>
             mBuffer GUARDED_BY(mTraceLock);
+    size_t mBufferSizeInBytes GUARDED_BY(mTraceLock) = CONTINUOUS_TRACING_BUFFER_SIZE;
     std::unordered_map<uint64_t, perfetto::protos::TransactionState> mQueuedTransactions
             GUARDED_BY(mTraceLock);
     LocklessStack<perfetto::protos::TransactionState> mTransactionQueue;
@@ -201,17 +124,19 @@ private:
     std::vector<uint32_t /* layerId */> mPendingDestroyedLayers; // only accessed by main thread
     int64_t mLastUpdatedVsyncId = -1;
 
-    void writeRingBufferToPerfetto(TransactionTracing::Mode mode);
     perfetto::protos::TransactionTraceFile createTraceFileProto() const;
     void loop();
     void addEntry(const std::vector<CommittedUpdates>& committedTransactions,
                   const std::vector<uint32_t>& removedLayers) EXCLUDES(mTraceLock);
     int32_t getLayerIdLocked(const sp<IBinder>& layerHandle) REQUIRES(mTraceLock);
     void tryPushToTracingThread() EXCLUDES(mMainThreadLock);
-    std::optional<perfetto::protos::TransactionTraceEntry> createStartingStateProtoLocked()
+    void addStartingStateToProtoLocked(perfetto::protos::TransactionTraceFile& proto)
             REQUIRES(mTraceLock);
     void updateStartingStateLocked(const perfetto::protos::TransactionTraceEntry& entry)
             REQUIRES(mTraceLock);
+    // TEST
+    // Return buffer contents as trace file proto
+    perfetto::protos::TransactionTraceFile writeToProto() EXCLUDES(mMainThreadLock);
 };
 
 class TransactionTraceWriter : public Singleton<TransactionTraceWriter> {