Add pipeline_state_observer interface

common/settings.cc

@@ -51,6 +51,8 @@ std::string Settings::ToString() const {
   stream << "icu_data_path: " << icu_data_path << std::endl;
   stream << "assets_dir: " << assets_dir << std::endl;
   stream << "assets_path: " << assets_path << std::endl;
+  stream << "pipeline_state_observer set: " << !!pipeline_state_observer
+         << std::endl;
   return stream.str();
 }
 

common/settings.h

@@ -15,6 +15,7 @@
 #include "flutter/fml/closure.h"
 #include "flutter/fml/mapping.h"
 #include "flutter/fml/unique_fd.h"
+#include "flutter/shell/common/pipeline.h"
 
 namespace flutter {
 
@@ -149,6 +150,12 @@ struct Settings {
       fml::UniqueFD::traits_type::InvalidValue();
   std::string assets_path;
 
+  // An optional callback that allows the embedder to observe when pipeline
+  // items change state.  For example, it could be used to have access to
+  // pipeline item metrics in a region of code that has access to platform
+  // specific APIs.  Must be thread safe.
+  PipelineStateObserver pipeline_state_observer;
+
   std::string ToString() const;
 };
 

shell/common/animator.cc

@@ -5,6 +5,7 @@
 #include "flutter/shell/common/animator.h"
 
 #include "flutter/fml/trace_event.h"
+#include "flutter/shell/common/pipeline.h"
 #include "third_party/dart/runtime/include/dart_tools_api.h"
 
 namespace flutter {
@@ -21,13 +22,16 @@ constexpr fml::TimeDelta kNotifyIdleTaskWaitTime =
 
 Animator::Animator(Delegate& delegate,
                    TaskRunners task_runners,
-                   std::unique_ptr<VsyncWaiter> waiter)
+                   std::unique_ptr<VsyncWaiter> waiter,
+                   PipelineStateObserver pipeline_state_observer)
     : delegate_(delegate),
       task_runners_(std::move(task_runners)),
       waiter_(std::move(waiter)),
       last_begin_frame_time_(),
       dart_frame_deadline_(0),
-      layer_tree_pipeline_(fml::MakeRefCounted<LayerTreePipeline>(2)),
+      layer_tree_pipeline_(fml::MakeRefCounted<LayerTreePipeline>(
+          2,
+          std::move(pipeline_state_observer))),
       pending_frame_semaphore_(1),
       frame_number_(1),
       paused_(false),

shell/common/animator.h

@@ -34,7 +34,8 @@ class Animator final {
 
   Animator(Delegate& delegate,
            TaskRunners task_runners,
-           std::unique_ptr<VsyncWaiter> waiter);
+           std::unique_ptr<VsyncWaiter> waiter,
+           PipelineStateObserver pipeline_state_observer);
 
   ~Animator();
 

shell/common/pipeline.h

@@ -5,15 +5,16 @@
 #ifndef FLUTTER_SHELL_COMMON_PIPELINE_H_
 #define FLUTTER_SHELL_COMMON_PIPELINE_H_
 
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <queue>
+
 #include "flutter/fml/macros.h"
 #include "flutter/fml/memory/ref_counted.h"
 #include "flutter/fml/synchronization/semaphore.h"
 #include "flutter/fml/trace_event.h"
 
-#include <memory>
-#include <mutex>
-#include <queue>
-
 namespace flutter {
 
 enum class PipelineConsumeResult {
@@ -22,6 +23,26 @@ enum class PipelineConsumeResult {
   MoreAvailable,
 };
 
+enum class PipelineItemStateChange {
+  // Indicates that a new pipeline item has started.
+  kBegin,
+  // Indicates that the pipeline item has advanced to its next phase.  In
+  // practice this will only happen once, and means that the pipeline item has
+  // finished its UI thread work, and that GPU thread work is about to begin.
+  kStep,
+  // Indicates that the pipeline item is done.
+  kEnd,
+  // Indicates that the pipeline item was dropped.
+  kAbort,
+};
+
+// Called when pipeline items change states.  See
+// |Settings::pipeline_state_observer| for further details.
+using PipelineStateObserver =
+    std::function<void(intptr_t pipeline_id,
+                       size_t pipeline_item,
+                       PipelineItemStateChange state_change)>;
+
 size_t GetNextPipelineTraceID();
 
 template <class R>
@@ -86,7 +107,10 @@ class Pipeline : public fml::RefCountedThreadSafe<Pipeline<R>> {
     FML_DISALLOW_COPY_AND_ASSIGN(ProducerContinuation);
   };
 
-  explicit Pipeline(uint32_t depth) : empty_(depth), available_(0) {}
+  Pipeline(uint32_t depth, PipelineStateObserver pipeline_state_observer)
+      : empty_(depth),
+        available_(0),
+        pipeline_state_observer_(std::move(pipeline_state_observer)) {}
 
   ~Pipeline() = default;
 
@@ -97,10 +121,17 @@ class Pipeline : public fml::RefCountedThreadSafe<Pipeline<R>> {
       return {};
     }
 
+    size_t trace_id = GetNextPipelineTraceID();
+    if (pipeline_state_observer_) {
+      pipeline_state_observer_(PipelineId(), trace_id,
+                               PipelineItemStateChange::kBegin);
+    }
+
     return ProducerContinuation{
         std::bind(&Pipeline::ProducerCommit, this, std::placeholders::_1,
                   std::placeholders::_2),  // continuation
-        GetNextPipelineTraceID()};         // trace id
+        trace_id                           // trace id
+    };
   }
 
   using Consumer = std::function<void(ResourcePtr)>;
@@ -135,7 +166,10 @@ class Pipeline : public fml::RefCountedThreadSafe<Pipeline<R>> {
 
     TRACE_FLOW_END("flutter", "PipelineItem", trace_id);
     TRACE_EVENT_ASYNC_END0("flutter", "PipelineItem", trace_id);
-
+    if (pipeline_state_observer_) {
+      pipeline_state_observer_(PipelineId(), trace_id,
+                               PipelineItemStateChange::kEnd);
+    }
     return items_count > 0 ? PipelineConsumeResult::MoreAvailable
                            : PipelineConsumeResult::Done;
   }
@@ -145,18 +179,33 @@ class Pipeline : public fml::RefCountedThreadSafe<Pipeline<R>> {
   fml::Semaphore available_;
   std::mutex queue_mutex_;
   std::queue<std::pair<ResourcePtr, size_t>> queue_;
+  PipelineStateObserver pipeline_state_observer_;
 
   void ProducerCommit(ResourcePtr resource, size_t trace_id) {
+    bool had_resource = !!resource;
+
     {
       std::lock_guard<std::mutex> lock(queue_mutex_);
       queue_.emplace(std::move(resource), trace_id);
     }
 
     // Ensure the queue mutex is not held as that would be a pessimization.
     available_.Signal();
+
+    if (pipeline_state_observer_) {
+      if (had_resource) {
+        pipeline_state_observer_(PipelineId(), trace_id,
+                                 PipelineItemStateChange::kStep);
+      } else {
+        pipeline_state_observer_(PipelineId(), trace_id,
+                                 PipelineItemStateChange::kAbort);
+      }
+    }
   }
 
-  FML_DISALLOW_COPY_AND_ASSIGN(Pipeline);
+  intptr_t PipelineId() const { return intptr_t(this); }
+
+  FML_DISALLOW_COPY_ASSIGN_AND_MOVE(Pipeline);
 };
 
 }  // namespace flutter

shell/common/shell.cc

@@ -118,15 +118,18 @@ std::unique_ptr<Shell> Shell::CreateShellOnPlatformThread(
                          shared_snapshot = std::move(shared_snapshot),      //
                          vsync_waiter = std::move(vsync_waiter),            //
                          snapshot_delegate = std::move(snapshot_delegate),  //
-                         io_manager = io_manager->GetWeakPtr()              //
+                         io_manager = io_manager->GetWeakPtr(),             //
+                         pipeline_state_observer =                          //
+                             std::move(settings.pipeline_state_observer)    //
   ]() mutable {
         TRACE_EVENT0("flutter", "ShellSetupUISubsystem");
         const auto& task_runners = shell->GetTaskRunners();
 
         // The animator is owned by the UI thread but it gets its vsync pulses
         // from the platform.
-        auto animator = std::make_unique<Animator>(*shell, task_runners,
-                                                   std::move(vsync_waiter));
+        auto animator = std::make_unique<Animator>(
+            *shell, task_runners, std::move(vsync_waiter),
+            std::move(pipeline_state_observer));
 
         engine = std::make_unique<Engine>(*shell,                        //
                                           *shell->GetDartVM(),           //