Fix

Author: LalitMaganti

src/trace_processor/core/plugin/plugin.cc

@@ -54,16 +54,16 @@ std::unique_ptr<Destructible> PluginBase::CreateStorage(
 }
 void PluginBase::RegisterImporters(TraceProcessorContext*, Destructible*) {}
 void PluginBase::RegisterDataframes(TraceProcessorContext*,
-                                      Destructible*,
-                                      std::vector<PluginDataframe>&) {}
+                                    Destructible*,
+                                    std::vector<PluginDataframe>&) {}
 void PluginBase::RegisterStaticTableFunctions(
     TraceProcessorContext*,
     Destructible*,
     std::vector<std::unique_ptr<StaticTableFunction>>&) {}
-void PluginBase::RegisterSqliteModules(
-    TraceProcessorContext*,
-    Destructible*,
-    std::vector<SqliteModuleRegistration>&) {}
+void PluginBase::RegisterSqliteModules(TraceProcessorContext*,
+                                       Destructible*,
+                                       std::vector<SqliteModuleRegistration>&) {
+}
 std::string PluginBase::GetAfterEofSql() {
   return {};
 }

src/trace_processor/core/plugin/plugin.h

@@ -66,9 +66,8 @@ SqliteModuleRegistration MakeSqliteModule(std::string name,
   reg.name = std::move(name);
   reg.module = &Module::kModule;
   reg.context = ctx;
-  reg.is_state_manager =
-      std::is_base_of_v<sqlite::ModuleStateManagerBase,
-                         typename Module::Context>;
+  reg.is_state_manager = std::is_base_of_v<sqlite::ModuleStateManagerBase,
+                                           typename Module::Context>;
   return reg;
 }
 
@@ -84,9 +83,8 @@ SqliteModuleRegistration MakeSqliteModule(
   reg.destructor = [](void* p) {
     delete static_cast<typename Module::Context*>(p);
   };
-  reg.is_state_manager =
-      std::is_base_of_v<sqlite::ModuleStateManagerBase,
-                         typename Module::Context>;
+  reg.is_state_manager = std::is_base_of_v<sqlite::ModuleStateManagerBase,
+                                           typename Module::Context>;
   return reg;
 }
 
@@ -145,18 +143,15 @@ class PluginBase {
 // 1. Compile-time: forces #include of dep headers -> forces GN dep
 // 2. Link-time: if dep's .cc isn't compiled, GN dep missing -> build fails
 // 3. Runtime: topological sort verifies all deps are registered
-template <typename Self,
-          typename Storage = void,
-          typename... Deps>
+template <typename Self, typename Storage = void, typename... Deps>
 class Plugin : public PluginBase {
  public:
   static constexpr const void* kPluginId = PluginTag<Self>::Id();
   static constexpr std::array<const void*, sizeof...(Deps)> kDepIds = {
       PluginTag<Deps>::Id()...};
 
   // Override these in the concrete plugin class.
-  virtual std::unique_ptr<Storage> CreatePluginStorage(
-      TraceProcessorContext*) {
+  virtual std::unique_ptr<Storage> CreatePluginStorage(TraceProcessorContext*) {
     return nullptr;
   }
   virtual void RegisterImporters(TraceProcessorContext*, Storage*) {}
@@ -167,26 +162,23 @@ class Plugin : public PluginBase {
       TraceProcessorContext*,
       Storage*,
       std::vector<std::unique_ptr<StaticTableFunction>>&) {}
-  virtual void RegisterSqliteModules(
-      TraceProcessorContext*,
-      Storage*,
-      std::vector<SqliteModuleRegistration>&) {}
+  virtual void RegisterSqliteModules(TraceProcessorContext*,
+                                     Storage*,
+                                     std::vector<SqliteModuleRegistration>&) {}
 
  private:
   std::unique_ptr<Destructible> CreateStorage(
       TraceProcessorContext* ctx) final {
     return static_cast<Self*>(this)->CreatePluginStorage(ctx);
   }
-  void RegisterImporters(TraceProcessorContext* ctx,
-                         Destructible* s) final {
-    static_cast<Self*>(this)->RegisterImporters(
-        ctx, static_cast<Storage*>(s));
+  void RegisterImporters(TraceProcessorContext* ctx, Destructible* s) final {
+    static_cast<Self*>(this)->RegisterImporters(ctx, static_cast<Storage*>(s));
   }
   void RegisterDataframes(TraceProcessorContext* ctx,
                           Destructible* s,
                           std::vector<PluginDataframe>& tables) final {
-    static_cast<Self*>(this)->RegisterDataframes(
-        ctx, static_cast<Storage*>(s), tables);
+    static_cast<Self*>(this)->RegisterDataframes(ctx, static_cast<Storage*>(s),
+                                                 tables);
   }
   void RegisterStaticTableFunctions(
       TraceProcessorContext* ctx,
@@ -218,9 +210,8 @@ class Plugin<Self, void, Deps...> : public PluginBase {
   virtual void RegisterStaticTableFunctions(
       TraceProcessorContext*,
       std::vector<std::unique_ptr<StaticTableFunction>>&) {}
-  virtual void RegisterSqliteModules(
-      TraceProcessorContext*,
-      std::vector<SqliteModuleRegistration>&) {}
+  virtual void RegisterSqliteModules(TraceProcessorContext*,
+                                     std::vector<SqliteModuleRegistration>&) {}
 
  private:
   void RegisterImporters(TraceProcessorContext* ctx, Destructible*) final {

src/trace_processor/perfetto_sql/engine/perfetto_sql_engine.h

@@ -145,12 +145,11 @@ class PerfettoSqlEngine {
   }
 
   // Registers a virtual table module from a plugin's SqliteModuleRegistration.
-  void RegisterSqliteModuleForPlugin(
-      const char* name,
-      const sqlite3_module* module,
-      void* ctx,
-      void (*destructor)(void*),
-      bool is_state_manager) {
+  void RegisterSqliteModuleForPlugin(const char* name,
+                                     const sqlite3_module* module,
+                                     void* ctx,
+                                     void (*destructor)(void*),
+                                     bool is_state_manager) {
     if (is_state_manager) {
       virtual_module_state_managers_.push_back(
           static_cast<sqlite::ModuleStateManagerBase*>(ctx));

src/trace_processor/trace_processor_impl.h

@@ -173,9 +173,8 @@ class TraceProcessorImpl : public TraceProcessor,
                              const Config& config,
                              PerfettoSqlEngine* engine);
 
-  static void IncludeAfterEofPrelude(
-      PerfettoSqlEngine*,
-      const std::vector<PluginEntry>& plugins);
+  static void IncludeAfterEofPrelude(PerfettoSqlEngine*,
+                                     const std::vector<PluginEntry>& plugins);
 
   const Config config_;