diff --git a/services/surfaceflinger/Tracing/TransactionProtoParser.cpp b/services/surfaceflinger/Tracing/TransactionProtoParser.cpp
index 2dc89b5..b1e3d63 100644
--- a/services/surfaceflinger/Tracing/TransactionProtoParser.cpp
+++ b/services/surfaceflinger/Tracing/TransactionProtoParser.cpp
@@ -51,8 +51,8 @@
     ~FakeExternalTexture() = default;
 };
 
-perfetto::protos::TransactionState TransactionProtoParser::toProto(const TransactionState& t) {
-    perfetto::protos::TransactionState proto;
+proto::TransactionState TransactionProtoParser::toProto(const TransactionState& t) {
+    proto::TransactionState proto;
     proto.set_pid(t.originPid);
     proto.set_uid(t.originUid);
     proto.set_vsync_id(t.frameTimelineInfo.vsyncId);
@@ -79,21 +79,21 @@
     return proto;
 }
 
-perfetto::protos::TransactionState TransactionProtoParser::toProto(
+proto::TransactionState TransactionProtoParser::toProto(
         const std::map<uint32_t /* layerId */, TracingLayerState>& states) {
-    perfetto::protos::TransactionState proto;
+    proto::TransactionState proto;
     proto.mutable_layer_changes()->Reserve(static_cast<int32_t>(states.size()));
     for (auto& [layerId, state] : states) {
-        perfetto::protos::LayerState layerProto = toProto(state);
+        proto::LayerState layerProto = toProto(state);
         layerProto.set_has_sideband_stream(state.hasSidebandStream);
         proto.mutable_layer_changes()->Add(std::move(layerProto));
     }
     return proto;
 }
 
-perfetto::protos::LayerState TransactionProtoParser::toProto(
+proto::LayerState TransactionProtoParser::toProto(
         const ResolvedComposerState& resolvedComposerState) {
-    perfetto::protos::LayerState proto;
+    proto::LayerState proto;
     auto& layer = resolvedComposerState.state;
     proto.set_layer_id(resolvedComposerState.layerId);
     proto.set_what(layer.what);
@@ -114,7 +114,7 @@
         proto.set_mask(layer.mask);
     }
     if (layer.what & layer_state_t::eMatrixChanged) {
-        perfetto::protos::LayerState_Matrix22* matrixProto = proto.mutable_matrix();
+        proto::LayerState_Matrix22* matrixProto = proto.mutable_matrix();
         matrixProto->set_dsdx(layer.matrix.dsdx);
         matrixProto->set_dsdy(layer.matrix.dsdy);
         matrixProto->set_dtdx(layer.matrix.dtdx);
@@ -132,7 +132,7 @@
     }
 
     if (layer.what & layer_state_t::eColorChanged) {
-        perfetto::protos::LayerState_Color3* colorProto = proto.mutable_color();
+        proto::LayerState_Color3* colorProto = proto.mutable_color();
         colorProto->set_r(layer.color.r);
         colorProto->set_g(layer.color.g);
         colorProto->set_b(layer.color.b);
@@ -150,14 +150,13 @@
         LayerProtoHelper::writeToProto(layer.crop, proto.mutable_crop());
     }
     if (layer.what & layer_state_t::eBufferChanged) {
-        perfetto::protos::LayerState_BufferData* bufferProto = proto.mutable_buffer_data();
+        proto::LayerState_BufferData* bufferProto = proto.mutable_buffer_data();
         if (resolvedComposerState.externalTexture) {
             bufferProto->set_buffer_id(resolvedComposerState.externalTexture->getId());
             bufferProto->set_width(resolvedComposerState.externalTexture->getWidth());
             bufferProto->set_height(resolvedComposerState.externalTexture->getHeight());
-            bufferProto->set_pixel_format(
-                    static_cast<perfetto::protos::LayerState_BufferData_PixelFormat>(
-                            resolvedComposerState.externalTexture->getPixelFormat()));
+            bufferProto->set_pixel_format(static_cast<proto::LayerState_BufferData_PixelFormat>(
+                    resolvedComposerState.externalTexture->getPixelFormat()));
             bufferProto->set_usage(resolvedComposerState.externalTexture->getUsage());
         }
         bufferProto->set_frame_number(layer.bufferData->frameNumber);
@@ -192,8 +191,7 @@
     if (layer.what & layer_state_t::eInputInfoChanged) {
         if (layer.windowInfoHandle) {
             const gui::WindowInfo* inputInfo = layer.windowInfoHandle->getInfo();
-            perfetto::protos::LayerState_WindowInfo* windowInfoProto =
-                    proto.mutable_window_info_handle();
+            proto::LayerState_WindowInfo* windowInfoProto = proto.mutable_window_info_handle();
             windowInfoProto->set_layout_params_flags(inputInfo->layoutParamsFlags.get());
             windowInfoProto->set_layout_params_type(
                     static_cast<int32_t>(inputInfo->layoutParamsType));
@@ -206,7 +204,7 @@
             windowInfoProto->set_has_wallpaper(inputInfo->inputConfig.test(
                     gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER));
             windowInfoProto->set_global_scale_factor(inputInfo->globalScaleFactor);
-            perfetto::protos::Transform* transformProto = windowInfoProto->mutable_transform();
+            proto::Transform* transformProto = windowInfoProto->mutable_transform();
             transformProto->set_dsdx(inputInfo->transform.dsdx());
             transformProto->set_dtdx(inputInfo->transform.dtdx());
             transformProto->set_dtdy(inputInfo->transform.dtdy());
@@ -221,7 +219,7 @@
     if (layer.what & layer_state_t::eBackgroundColorChanged) {
         proto.set_bg_color_alpha(layer.bgColor.a);
         proto.set_bg_color_dataspace(static_cast<int32_t>(layer.bgColorDataspace));
-        perfetto::protos::LayerState_Color3* colorProto = proto.mutable_color();
+        proto::LayerState_Color3* colorProto = proto.mutable_color();
         colorProto->set_r(layer.bgColor.r);
         colorProto->set_g(layer.bgColor.g);
         colorProto->set_b(layer.bgColor.b);
@@ -257,13 +255,13 @@
     }
     if (layer.what & layer_state_t::eDropInputModeChanged) {
         proto.set_drop_input_mode(
-                static_cast<perfetto::protos::LayerState_DropInputMode>(layer.dropInputMode));
+                static_cast<proto::LayerState_DropInputMode>(layer.dropInputMode));
     }
     return proto;
 }
 
-perfetto::protos::DisplayState TransactionProtoParser::toProto(const DisplayState& display) {
-    perfetto::protos::DisplayState proto;
+proto::DisplayState TransactionProtoParser::toProto(const DisplayState& display) {
+    proto::DisplayState proto;
     proto.set_what(display.what);
     proto.set_id(mMapper->getDisplayId(display.token));
 
@@ -287,8 +285,8 @@
     return proto;
 }
 
-perfetto::protos::LayerCreationArgs TransactionProtoParser::toProto(const LayerCreationArgs& args) {
-    perfetto::protos::LayerCreationArgs proto;
+proto::LayerCreationArgs TransactionProtoParser::toProto(const LayerCreationArgs& args) {
+    proto::LayerCreationArgs proto;
     proto.set_layer_id(args.sequence);
     proto.set_name(args.name);
     proto.set_flags(args.flags);
@@ -299,8 +297,7 @@
     return proto;
 }
 
-TransactionState TransactionProtoParser::fromProto(
-        const perfetto::protos::TransactionState& proto) {
+TransactionState TransactionProtoParser::fromProto(const proto::TransactionState& proto) {
     TransactionState t;
     t.originPid = proto.pid();
     t.originUid = proto.uid();
@@ -326,7 +323,7 @@
     return t;
 }
 
-void TransactionProtoParser::fromProto(const perfetto::protos::LayerCreationArgs& proto,
+void TransactionProtoParser::fromProto(const proto::LayerCreationArgs& proto,
                                        LayerCreationArgs& outArgs) {
     outArgs.sequence = proto.layer_id();
 
@@ -338,7 +335,7 @@
     outArgs.layerStackToMirror.id = proto.layer_stack_to_mirror();
 }
 
-void TransactionProtoParser::mergeFromProto(const perfetto::protos::LayerState& proto,
+void TransactionProtoParser::mergeFromProto(const proto::LayerState& proto,
                                             TracingLayerState& outState) {
     ResolvedComposerState resolvedComposerState;
     fromProto(proto, resolvedComposerState);
@@ -363,7 +360,7 @@
     }
 }
 
-void TransactionProtoParser::fromProto(const perfetto::protos::LayerState& proto,
+void TransactionProtoParser::fromProto(const proto::LayerState& proto,
                                        ResolvedComposerState& resolvedComposerState) {
     auto& layer = resolvedComposerState.state;
     resolvedComposerState.layerId = proto.layer_id();
@@ -384,7 +381,7 @@
         layer.mask = proto.mask();
     }
     if (proto.what() & layer_state_t::eMatrixChanged) {
-        const perfetto::protos::LayerState_Matrix22& matrixProto = proto.matrix();
+        const proto::LayerState_Matrix22& matrixProto = proto.matrix();
         layer.matrix.dsdx = matrixProto.dsdx();
         layer.matrix.dsdy = matrixProto.dsdy();
         layer.matrix.dtdx = matrixProto.dtdx();
@@ -402,7 +399,7 @@
     }
 
     if (proto.what() & layer_state_t::eColorChanged) {
-        const perfetto::protos::LayerState_Color3& colorProto = proto.color();
+        const proto::LayerState_Color3& colorProto = proto.color();
         layer.color.r = colorProto.r();
         layer.color.g = colorProto.g();
         layer.color.b = colorProto.b();
@@ -420,7 +417,7 @@
         LayerProtoHelper::readFromProto(proto.crop(), layer.crop);
     }
     if (proto.what() & layer_state_t::eBufferChanged) {
-        const perfetto::protos::LayerState_BufferData& bufferProto = proto.buffer_data();
+        const proto::LayerState_BufferData& bufferProto = proto.buffer_data();
         layer.bufferData =
                 std::make_shared<fake::BufferData>(bufferProto.buffer_id(), bufferProto.width(),
                                                    bufferProto.height(), bufferProto.pixel_format(),
@@ -463,7 +460,7 @@
 
     if ((proto.what() & layer_state_t::eInputInfoChanged) && proto.has_window_info_handle()) {
         gui::WindowInfo inputInfo;
-        const perfetto::protos::LayerState_WindowInfo& windowInfoProto = proto.window_info_handle();
+        const proto::LayerState_WindowInfo& windowInfoProto = proto.window_info_handle();
 
         inputInfo.layoutParamsFlags =
                 static_cast<gui::WindowInfo::Flag>(windowInfoProto.layout_params_flags());
@@ -475,7 +472,7 @@
                 ftl::Flags<gui::WindowInfo::InputConfig>(windowInfoProto.input_config());
         inputInfo.surfaceInset = windowInfoProto.surface_inset();
         inputInfo.globalScaleFactor = windowInfoProto.global_scale_factor();
-        const perfetto::protos::Transform& transformProto = windowInfoProto.transform();
+        const proto::Transform& transformProto = windowInfoProto.transform();
         inputInfo.transform.set(transformProto.dsdx(), transformProto.dtdx(), transformProto.dtdy(),
                                 transformProto.dsdy());
         inputInfo.transform.set(transformProto.tx(), transformProto.ty());
@@ -488,7 +485,7 @@
     if (proto.what() & layer_state_t::eBackgroundColorChanged) {
         layer.bgColor.a = proto.bg_color_alpha();
         layer.bgColorDataspace = static_cast<ui::Dataspace>(proto.bg_color_dataspace());
-        const perfetto::protos::LayerState_Color3& colorProto = proto.color();
+        const proto::LayerState_Color3& colorProto = proto.color();
         layer.bgColor.r = colorProto.r();
         layer.bgColor.g = colorProto.g();
         layer.bgColor.b = colorProto.b();
@@ -528,7 +525,7 @@
     }
 }
 
-DisplayState TransactionProtoParser::fromProto(const perfetto::protos::DisplayState& proto) {
+DisplayState TransactionProtoParser::fromProto(const proto::DisplayState& proto) {
     DisplayState display;
     display.what = proto.what();
     display.token = mMapper->getDisplayHandle(proto.id());
@@ -553,7 +550,7 @@
     return display;
 }
 
-void asProto(perfetto::protos::Transform* proto, const ui::Transform& transform) {
+void asProto(proto::Transform* proto, const ui::Transform& transform) {
     proto->set_dsdx(transform.dsdx());
     proto->set_dtdx(transform.dtdx());
     proto->set_dtdy(transform.dtdy());
@@ -562,9 +559,9 @@
     proto->set_ty(transform.ty());
 }
 
-perfetto::protos::DisplayInfo TransactionProtoParser::toProto(
-        const frontend::DisplayInfo& displayInfo, uint32_t layerStack) {
-    perfetto::protos::DisplayInfo proto;
+proto::DisplayInfo TransactionProtoParser::toProto(const frontend::DisplayInfo& displayInfo,
+                                                   uint32_t layerStack) {
+    proto::DisplayInfo proto;
     proto.set_layer_stack(layerStack);
     proto.set_display_id(displayInfo.info.displayId);
     proto.set_logical_width(displayInfo.info.logicalWidth);
@@ -580,13 +577,12 @@
     return proto;
 }
 
-void fromProto2(ui::Transform& outTransform, const perfetto::protos::Transform& proto) {
+void fromProto2(ui::Transform& outTransform, const proto::Transform& proto) {
     outTransform.set(proto.dsdx(), proto.dtdx(), proto.dtdy(), proto.dsdy());
     outTransform.set(proto.tx(), proto.ty());
 }
 
-frontend::DisplayInfo TransactionProtoParser::fromProto(
-        const perfetto::protos::DisplayInfo& proto) {
+frontend::DisplayInfo TransactionProtoParser::fromProto(const proto::DisplayInfo& proto) {
     frontend::DisplayInfo displayInfo;
     displayInfo.info.displayId = proto.display_id();
     displayInfo.info.logicalWidth = proto.logical_width();
@@ -603,10 +599,10 @@
 }
 
 void TransactionProtoParser::fromProto(
-        const google::protobuf::RepeatedPtrField<perfetto::protos::DisplayInfo>& proto,
+        const google::protobuf::RepeatedPtrField<proto::DisplayInfo>& proto,
         frontend::DisplayInfos& outDisplayInfos) {
     outDisplayInfos.clear();
-    for (const perfetto::protos::DisplayInfo& displayInfo : proto) {
+    for (const proto::DisplayInfo& displayInfo : proto) {
         outDisplayInfos.emplace_or_replace(ui::LayerStack::fromValue(displayInfo.layer_stack()),
                                            fromProto(displayInfo));
     }
diff --git a/services/surfaceflinger/Tracing/TransactionProtoParser.h b/services/surfaceflinger/Tracing/TransactionProtoParser.h
index b3ab71c..457c3be 100644
--- a/services/surfaceflinger/Tracing/TransactionProtoParser.h
+++ b/services/surfaceflinger/Tracing/TransactionProtoParser.h
@@ -44,25 +44,25 @@
     TransactionProtoParser(std::unique_ptr<FlingerDataMapper> provider)
           : mMapper(std::move(provider)) {}
 
-    perfetto::protos::TransactionState toProto(const TransactionState&);
-    perfetto::protos::TransactionState toProto(
-            const std::map<uint32_t /* layerId */, TracingLayerState>&);
-    perfetto::protos::LayerCreationArgs toProto(const LayerCreationArgs& args);
-    perfetto::protos::LayerState toProto(const ResolvedComposerState&);
-    static perfetto::protos::DisplayInfo toProto(const frontend::DisplayInfo&, uint32_t layerStack);
+    proto::TransactionState toProto(const TransactionState&);
+    proto::TransactionState toProto(const std::map<uint32_t /* layerId */, TracingLayerState>&);
+    proto::LayerCreationArgs toProto(const LayerCreationArgs& args);
+    proto::LayerState toProto(const ResolvedComposerState&);
+    static proto::DisplayInfo toProto(const frontend::DisplayInfo&, uint32_t layerStack);
 
-    TransactionState fromProto(const perfetto::protos::TransactionState&);
-    void mergeFromProto(const perfetto::protos::LayerState&, TracingLayerState& outState);
-    void fromProto(const perfetto::protos::LayerCreationArgs&, LayerCreationArgs& outArgs);
+    TransactionState fromProto(const proto::TransactionState&);
+    void mergeFromProto(const proto::LayerState&, TracingLayerState& outState);
+    void fromProto(const proto::LayerCreationArgs&, LayerCreationArgs& outArgs);
     std::unique_ptr<FlingerDataMapper> mMapper;
-    static frontend::DisplayInfo fromProto(const perfetto::protos::DisplayInfo&);
-    static void fromProto(const google::protobuf::RepeatedPtrField<perfetto::protos::DisplayInfo>&,
+    static frontend::DisplayInfo fromProto(const proto::DisplayInfo&);
+    static void fromProto(const google::protobuf::RepeatedPtrField<proto::DisplayInfo>&,
                           frontend::DisplayInfos& outDisplayInfos);
 
 private:
-    perfetto::protos::DisplayState toProto(const DisplayState&);
-    void fromProto(const perfetto::protos::LayerState&, ResolvedComposerState& out);
-    DisplayState fromProto(const perfetto::protos::DisplayState&);
+    proto::DisplayState toProto(const DisplayState&);
+    void fromProto(const proto::LayerState&, ResolvedComposerState& out);
+    DisplayState fromProto(const proto::DisplayState&);
+
 };
 
 } // namespace android::surfaceflinger
diff --git a/services/surfaceflinger/Tracing/TransactionTracing.cpp b/services/surfaceflinger/Tracing/TransactionTracing.cpp
index 8aacbca..bc69191 100644
--- a/services/surfaceflinger/Tracing/TransactionTracing.cpp
+++ b/services/surfaceflinger/Tracing/TransactionTracing.cpp
@@ -59,7 +59,7 @@
 
 status_t TransactionTracing::writeToFile(const std::string& filename) {
     std::scoped_lock lock(mTraceLock);
-    perfetto::protos::TransactionTraceFile fileProto = createTraceFileProto();
+    proto::TransactionTraceFile fileProto = createTraceFileProto();
     addStartingStateToProtoLocked(fileProto);
     return mBuffer.writeToFile(fileProto, filename);
 }
@@ -70,11 +70,10 @@
     mBuffer.setSize(mBufferSizeInBytes);
 }
 
-perfetto::protos::TransactionTraceFile TransactionTracing::createTraceFileProto() const {
-    perfetto::protos::TransactionTraceFile proto;
-    proto.set_magic_number(
-            uint64_t(perfetto::protos::TransactionTraceFile_MagicNumber_MAGIC_NUMBER_H) << 32 |
-            perfetto::protos::TransactionTraceFile_MagicNumber_MAGIC_NUMBER_L);
+proto::TransactionTraceFile TransactionTracing::createTraceFileProto() const {
+    proto::TransactionTraceFile proto;
+    proto.set_magic_number(uint64_t(proto::TransactionTraceFile_MagicNumber_MAGIC_NUMBER_H) << 32 |
+                           proto::TransactionTraceFile_MagicNumber_MAGIC_NUMBER_L);
     auto timeOffsetNs = static_cast<std::uint64_t>(systemTime(SYSTEM_TIME_REALTIME) -
                                                    systemTime(SYSTEM_TIME_MONOTONIC));
     proto.set_real_to_elapsed_time_offset_nanos(timeOffsetNs);
@@ -90,8 +89,7 @@
 }
 
 void TransactionTracing::addQueuedTransaction(const TransactionState& transaction) {
-    perfetto::protos::TransactionState* state =
-            new perfetto::protos::TransactionState(mProtoParser.toProto(transaction));
+    proto::TransactionState* state = new proto::TransactionState(mProtoParser.toProto(transaction));
     mTransactionQueue.push(state);
 }
 
@@ -154,7 +152,7 @@
     ATRACE_CALL();
     std::scoped_lock lock(mTraceLock);
     std::vector<std::string> removedEntries;
-    perfetto::protos::TransactionTraceEntry entryProto;
+    proto::TransactionTraceEntry entryProto;
 
     while (auto incomingTransaction = mTransactionQueue.pop()) {
         auto transaction = *incomingTransaction;
@@ -213,7 +211,7 @@
                               std::make_move_iterator(entries.end()));
     }
 
-    perfetto::protos::TransactionTraceEntry removedEntryProto;
+    proto::TransactionTraceEntry removedEntryProto;
     for (const std::string& removedEntry : removedEntries) {
         removedEntryProto.ParseFromString(removedEntry);
         updateStartingStateLocked(removedEntryProto);
@@ -238,7 +236,7 @@
     base::ScopedLockAssertion assumeLocked(mTraceLock);
     mTransactionsAddedToBufferCv.wait_for(lock, std::chrono::milliseconds(100),
                                           [&]() REQUIRES(mTraceLock) {
-                                              perfetto::protos::TransactionTraceEntry entry;
+                                              proto::TransactionTraceEntry entry;
                                               if (mBuffer.used() > 0) {
                                                   entry.ParseFromString(mBuffer.back());
                                               }
@@ -270,19 +268,19 @@
 }
 
 void TransactionTracing::updateStartingStateLocked(
-        const perfetto::protos::TransactionTraceEntry& removedEntry) {
+        const proto::TransactionTraceEntry& removedEntry) {
     mStartingTimestamp = removedEntry.elapsed_realtime_nanos();
     // Keep track of layer starting state so we can reconstruct the layer state as we purge
     // transactions from the buffer.
-    for (const perfetto::protos::LayerCreationArgs& addedLayer : removedEntry.added_layers()) {
+    for (const proto::LayerCreationArgs& addedLayer : removedEntry.added_layers()) {
         TracingLayerState& startingState = mStartingStates[addedLayer.layer_id()];
         startingState.layerId = addedLayer.layer_id();
         mProtoParser.fromProto(addedLayer, startingState.args);
     }
 
     // Merge layer states to starting transaction state.
-    for (const perfetto::protos::TransactionState& transaction : removedEntry.transactions()) {
-        for (const perfetto::protos::LayerState& layerState : transaction.layer_changes()) {
+    for (const proto::TransactionState& transaction : removedEntry.transactions()) {
+        for (const proto::LayerState& layerState : transaction.layer_changes()) {
             auto it = mStartingStates.find(layerState.layer_id());
             if (it == mStartingStates.end()) {
                 // TODO(b/238781169) make this log fatal when we switch over to using new fe
@@ -309,13 +307,12 @@
     }
 }
 
-void TransactionTracing::addStartingStateToProtoLocked(
-        perfetto::protos::TransactionTraceFile& proto) {
+void TransactionTracing::addStartingStateToProtoLocked(proto::TransactionTraceFile& proto) {
     if (mStartingStates.size() == 0) {
         return;
     }
 
-    perfetto::protos::TransactionTraceEntry* entryProto = proto.add_entry();
+    proto::TransactionTraceEntry* entryProto = proto.add_entry();
     entryProto->set_elapsed_realtime_nanos(mStartingTimestamp);
     entryProto->set_vsync_id(0);
 
@@ -324,7 +321,7 @@
         entryProto->mutable_added_layers()->Add(mProtoParser.toProto(state.args));
     }
 
-    perfetto::protos::TransactionState transactionProto = mProtoParser.toProto(mStartingStates);
+    proto::TransactionState transactionProto = mProtoParser.toProto(mStartingStates);
     transactionProto.set_vsync_id(0);
     transactionProto.set_post_time(mStartingTimestamp);
     entryProto->mutable_transactions()->Add(std::move(transactionProto));
@@ -341,9 +338,9 @@
     }
 }
 
-perfetto::protos::TransactionTraceFile TransactionTracing::writeToProto() {
+proto::TransactionTraceFile TransactionTracing::writeToProto() {
     std::scoped_lock<std::mutex> lock(mTraceLock);
-    perfetto::protos::TransactionTraceFile proto = createTraceFileProto();
+    proto::TransactionTraceFile proto = createTraceFileProto();
     addStartingStateToProtoLocked(proto);
     mBuffer.writeToProto(proto);
     return proto;
diff --git a/services/surfaceflinger/Tracing/TransactionTracing.h b/services/surfaceflinger/Tracing/TransactionTracing.h
index 09fcd8a..422b5f3 100644
--- a/services/surfaceflinger/Tracing/TransactionTracing.h
+++ b/services/surfaceflinger/Tracing/TransactionTracing.h
@@ -85,16 +85,14 @@
     }
 
     mutable std::mutex mTraceLock;
-    TransactionRingBuffer<perfetto::protos::TransactionTraceFile,
-                          perfetto::protos::TransactionTraceEntry>
-            mBuffer GUARDED_BY(mTraceLock);
+    TransactionRingBuffer<proto::TransactionTraceFile, proto::TransactionTraceEntry> mBuffer
+            GUARDED_BY(mTraceLock);
     size_t mBufferSizeInBytes GUARDED_BY(mTraceLock) = CONTINUOUS_TRACING_BUFFER_SIZE;
-    std::unordered_map<uint64_t, perfetto::protos::TransactionState> mQueuedTransactions
+    std::unordered_map<uint64_t, proto::TransactionState> mQueuedTransactions
             GUARDED_BY(mTraceLock);
-    LocklessStack<perfetto::protos::TransactionState> mTransactionQueue;
+    LocklessStack<proto::TransactionState> mTransactionQueue;
     nsecs_t mStartingTimestamp GUARDED_BY(mTraceLock);
-    std::unordered_map<int, perfetto::protos::LayerCreationArgs> mCreatedLayers
-            GUARDED_BY(mTraceLock);
+    std::unordered_map<int, proto::LayerCreationArgs> mCreatedLayers GUARDED_BY(mTraceLock);
     std::map<uint32_t /* layerId */, TracingLayerState> mStartingStates GUARDED_BY(mTraceLock);
     frontend::DisplayInfos mStartingDisplayInfos GUARDED_BY(mTraceLock);
 
@@ -124,19 +122,17 @@
     std::vector<uint32_t /* layerId */> mPendingDestroyedLayers; // only accessed by main thread
     int64_t mLastUpdatedVsyncId = -1;
 
-    perfetto::protos::TransactionTraceFile createTraceFileProto() const;
+    proto::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);
-    void addStartingStateToProtoLocked(perfetto::protos::TransactionTraceFile& proto)
-            REQUIRES(mTraceLock);
-    void updateStartingStateLocked(const perfetto::protos::TransactionTraceEntry& entry)
-            REQUIRES(mTraceLock);
+    void addStartingStateToProtoLocked(proto::TransactionTraceFile& proto) REQUIRES(mTraceLock);
+    void updateStartingStateLocked(const proto::TransactionTraceEntry& entry) REQUIRES(mTraceLock);
     // TEST
     // Return buffer contents as trace file proto
-    perfetto::protos::TransactionTraceFile writeToProto() EXCLUDES(mMainThreadLock);
+    proto::TransactionTraceFile writeToProto() EXCLUDES(mMainThreadLock);
 };
 
 class TransactionTraceWriter : public Singleton<TransactionTraceWriter> {
diff --git a/services/surfaceflinger/Tracing/tools/LayerTraceGenerator.cpp b/services/surfaceflinger/Tracing/tools/LayerTraceGenerator.cpp
index 9471e95..321b8ba 100644
--- a/services/surfaceflinger/Tracing/tools/LayerTraceGenerator.cpp
+++ b/services/surfaceflinger/Tracing/tools/LayerTraceGenerator.cpp
@@ -40,8 +40,8 @@
 namespace android {
 using namespace ftl::flag_operators;
 
-bool LayerTraceGenerator::generate(const perfetto::protos::TransactionTraceFile& traceFile,
-                                   const char*, bool onlyLastEntry) {
+bool LayerTraceGenerator::generate(const proto::TransactionTraceFile& traceFile,
+                                   const char* outputLayersTracePath, bool onlyLastEntry) {
     if (traceFile.entry_size() == 0) {
         ALOGD("Trace file is empty");
         return false;
diff --git a/services/surfaceflinger/Tracing/tools/LayerTraceGenerator.h b/services/surfaceflinger/Tracing/tools/LayerTraceGenerator.h
index a1e5fc8..e41d1e6 100644
--- a/services/surfaceflinger/Tracing/tools/LayerTraceGenerator.h
+++ b/services/surfaceflinger/Tracing/tools/LayerTraceGenerator.h
@@ -21,7 +21,7 @@
 namespace android {
 class LayerTraceGenerator {
 public:
-    bool generate(const perfetto::protos::TransactionTraceFile&, const char* outputLayersTracePath,
+    bool generate(const proto::TransactionTraceFile&, const char* outputLayersTracePath,
                   bool onlyLastEntry);
 };
-} // namespace android
+} // namespace android
\ No newline at end of file
diff --git a/services/surfaceflinger/Tracing/tools/main.cpp b/services/surfaceflinger/Tracing/tools/main.cpp
index 0ff8f98..5ca87e4 100644
--- a/services/surfaceflinger/Tracing/tools/main.cpp
+++ b/services/surfaceflinger/Tracing/tools/main.cpp
@@ -41,7 +41,7 @@
         return -1;
     }
 
-    perfetto::protos::TransactionTraceFile transactionTraceFile;
+    proto::TransactionTraceFile transactionTraceFile;
     if (!transactionTraceFile.ParseFromIstream(&input)) {
         std::cout << "Error: Failed to parse " << transactionTracePath;
         return -1;