Cherry pick 183b6b9 (gaaclarke:setup-gpu-disabled-cleaned)

gaaclarke · jochen.holzer@web.de · commit da35206cfd15 · 2021-02-26T14:05:18.000+01:00
Started initializing the gpu disable syncswitch based on the app state. (flutter#24503)
diff --git a/shell/common/shell.cc b/shell/common/shell.cc
@@ -40,21 +40,169 @@ constexpr char kSystemChannel[] = "flutter/system";
 constexpr char kTypeKey[] = "type";
 constexpr char kFontChange[] = "fontsChange";
 
+<<<<<<< HEAD
+=======
+namespace {
+
+std::unique_ptr<Engine> CreateEngine(
+    Engine::Delegate& delegate,
+    const PointerDataDispatcherMaker& dispatcher_maker,
+    DartVM& vm,
+    fml::RefPtr<const DartSnapshot> isolate_snapshot,
+    TaskRunners task_runners,
+    const PlatformData& platform_data,
+    Settings settings,
+    std::unique_ptr<Animator> animator,
+    fml::WeakPtr<IOManager> io_manager,
+    fml::RefPtr<SkiaUnrefQueue> unref_queue,
+    fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
+    std::shared_ptr<VolatilePathTracker> volatile_path_tracker) {
+  return std::make_unique<Engine>(delegate,             //
+                                  dispatcher_maker,     //
+                                  vm,                   //
+                                  isolate_snapshot,     //
+                                  task_runners,         //
+                                  platform_data,        //
+                                  settings,             //
+                                  std::move(animator),  //
+                                  io_manager,           //
+                                  unref_queue,          //
+                                  snapshot_delegate,    //
+                                  volatile_path_tracker);
+}
+
+void Tokenize(const std::string& input,
+              std::vector<std::string>* results,
+              char delimiter) {
+  std::istringstream ss(input);
+  std::string token;
+  while (std::getline(ss, token, delimiter)) {
+    results->push_back(token);
+  }
+}
+
+// Though there can be multiple shells, some settings apply to all components in
+// the process. These have to be setup before the shell or any of its
+// sub-components can be initialized. In a perfect world, this would be empty.
+// TODO(chinmaygarde): The unfortunate side effect of this call is that settings
+// that cause shell initialization failures will still lead to some of their
+// settings being applied.
+void PerformInitializationTasks(Settings& settings) {
+  {
+    fml::LogSettings log_settings;
+    log_settings.min_log_level =
+        settings.verbose_logging ? fml::LOG_INFO : fml::LOG_ERROR;
+    fml::SetLogSettings(log_settings);
+  }
+
+  static std::once_flag gShellSettingsInitialization = {};
+  std::call_once(gShellSettingsInitialization, [&settings] {
+    if (settings.engine_start_timestamp.count() == 0) {
+      settings.engine_start_timestamp =
+          std::chrono::microseconds(Dart_TimelineGetMicros());
+    }
+
+    tonic::SetLogHandler(
+        [](const char* message) { FML_LOG(ERROR) << message; });
+
+    if (settings.trace_skia) {
+      InitSkiaEventTracer(settings.trace_skia);
+    }
+
+    if (!settings.trace_allowlist.empty()) {
+      std::vector<std::string> prefixes;
+      Tokenize(settings.trace_allowlist, &prefixes, ',');
+      fml::tracing::TraceSetAllowlist(prefixes);
+    }
+
+    if (!settings.skia_deterministic_rendering_on_cpu) {
+      SkGraphics::Init();
+    } else {
+      FML_DLOG(INFO) << "Skia deterministic rendering is enabled.";
+    }
+
+    if (settings.icu_initialization_required) {
+      if (settings.icu_data_path.size() != 0) {
+        fml::icu::InitializeICU(settings.icu_data_path);
+      } else if (settings.icu_mapper) {
+        fml::icu::InitializeICUFromMapping(settings.icu_mapper());
+      } else {
+        FML_DLOG(WARNING) << "Skipping ICU initialization in the shell.";
+      }
+    }
+  });
+
+  PersistentCache::SetCacheSkSL(settings.cache_sksl);
+}
+
+}  // namespace
+
+std::unique_ptr<Shell> Shell::Create(
+    const PlatformData& platform_data,
+    TaskRunners task_runners,
+    Settings settings,
+    const Shell::CreateCallback<PlatformView>& on_create_platform_view,
+    const Shell::CreateCallback<Rasterizer>& on_create_rasterizer,
+    bool is_gpu_disabled) {
+  // This must come first as it initializes tracing.
+  PerformInitializationTasks(settings);
+
+  TRACE_EVENT0("flutter", "Shell::Create");
+
+  // Always use the `vm_snapshot` and `isolate_snapshot` provided by the
+  // settings to launch the VM.  If the VM is already running, the snapshot
+  // arguments are ignored.
+  auto vm_snapshot = DartSnapshot::VMSnapshotFromSettings(settings);
+  auto isolate_snapshot = DartSnapshot::IsolateSnapshotFromSettings(settings);
+  auto vm = DartVMRef::Create(settings, vm_snapshot, isolate_snapshot);
+  FML_CHECK(vm) << "Must be able to initialize the VM.";
+
+  // If the settings did not specify an `isolate_snapshot`, fall back to the
+  // one the VM was launched with.
+  if (!isolate_snapshot) {
+    isolate_snapshot = vm->GetVMData()->GetIsolateSnapshot();
+  }
+  return CreateWithSnapshot(std::move(platform_data),            //
+                            std::move(task_runners),             //
+                            std::move(settings),                 //
+                            std::move(vm),                       //
+                            std::move(isolate_snapshot),         //
+                            std::move(on_create_platform_view),  //
+                            std::move(on_create_rasterizer),     //
+                            CreateEngine, is_gpu_disabled);
+}
+
+>>>>>>> 183b6b9dc... Started initializing the gpu disable syncswitch based on the app state. (#24503)
 std::unique_ptr<Shell> Shell::CreateShellOnPlatformThread(
     DartVMRef vm,
     TaskRunners task_runners,
     const PlatformData platform_data,
     Settings settings,
     fml::RefPtr<const DartSnapshot> isolate_snapshot,
     const Shell::CreateCallback<PlatformView>& on_create_platform_view,
+<<<<<<< HEAD
     const Shell::CreateCallback<Rasterizer>& on_create_rasterizer) {
+=======
+    const Shell::CreateCallback<Rasterizer>& on_create_rasterizer,
+    const Shell::EngineCreateCallback& on_create_engine,
+    bool is_gpu_disabled) {
+>>>>>>> 183b6b9dc... Started initializing the gpu disable syncswitch based on the app state. (#24503)
   if (!task_runners.IsValid()) {
     FML_LOG(ERROR) << "Task runners to run the shell were invalid.";
     return nullptr;
   }
 
+<<<<<<< HEAD
   auto shell =
       std::unique_ptr<Shell>(new Shell(std::move(vm), task_runners, settings));
+=======
+  auto shell = std::unique_ptr<Shell>(
+      new Shell(std::move(vm), task_runners, settings,
+                std::make_shared<VolatilePathTracker>(
+                    task_runners.GetUITaskRunner(),
+                    !settings.skia_deterministic_rendering_on_cpu),
+                is_gpu_disabled));
+>>>>>>> 183b6b9dc... Started initializing the gpu disable syncswitch based on the app state. (#24503)
 
   // Create the rasterizer on the raster thread.
   std::promise<std::unique_ptr<Rasterizer>> rasterizer_promise;
@@ -283,7 +431,13 @@ std::unique_ptr<Shell> Shell::Create(
     fml::RefPtr<const DartSnapshot> isolate_snapshot,
     const Shell::CreateCallback<PlatformView>& on_create_platform_view,
     const Shell::CreateCallback<Rasterizer>& on_create_rasterizer,
+<<<<<<< HEAD
     DartVMRef vm) {
+=======
+    const Shell::EngineCreateCallback& on_create_engine,
+    bool is_gpu_disabled) {
+  // This must come first as it initializes tracing.
+>>>>>>> 183b6b9dc... Started initializing the gpu disable syncswitch based on the app state. (#24503)
   PerformInitializationTasks(settings);
   PersistentCache::SetCacheSkSL(settings.cache_sksl);
 
@@ -298,6 +452,7 @@ std::unique_ptr<Shell> Shell::Create(
   std::unique_ptr<Shell> shell;
   fml::TaskRunner::RunNowOrPostTask(
       task_runners.GetPlatformTaskRunner(),
+<<<<<<< HEAD
       fml::MakeCopyable([&latch,                                          //
                          vm = std::move(vm),                              //
                          &shell,                                          //
@@ -318,15 +473,53 @@ std::unique_ptr<Shell> Shell::Create(
         );
         latch.Signal();
       }));
+=======
+      fml::MakeCopyable(
+          [&latch,                                                        //
+           &shell,                                                        //
+           task_runners = std::move(task_runners),                        //
+           platform_data = std::move(platform_data),                      //
+           settings = std::move(settings),                                //
+           vm = std::move(vm),                                            //
+           isolate_snapshot = std::move(isolate_snapshot),                //
+           on_create_platform_view = std::move(on_create_platform_view),  //
+           on_create_rasterizer = std::move(on_create_rasterizer),        //
+           on_create_engine = std::move(on_create_engine),
+           is_gpu_disabled]() mutable {
+            shell = CreateShellOnPlatformThread(
+                std::move(vm),                       //
+                std::move(task_runners),             //
+                std::move(platform_data),            //
+                std::move(settings),                 //
+                std::move(isolate_snapshot),         //
+                std::move(on_create_platform_view),  //
+                std::move(on_create_rasterizer),     //
+                std::move(on_create_engine), is_gpu_disabled);
+            latch.Signal();
+          }));
+>>>>>>> 183b6b9dc... Started initializing the gpu disable syncswitch based on the app state. (#24503)
   latch.Wait();
   return shell;
 }
 
+<<<<<<< HEAD
 Shell::Shell(DartVMRef vm, TaskRunners task_runners, Settings settings)
     : task_runners_(std::move(task_runners)),
       settings_(std::move(settings)),
       vm_(std::move(vm)),
       is_gpu_disabled_sync_switch_(new fml::SyncSwitch()),
+=======
+Shell::Shell(DartVMRef vm,
+             TaskRunners task_runners,
+             Settings settings,
+             std::shared_ptr<VolatilePathTracker> volatile_path_tracker,
+             bool is_gpu_disabled)
+    : task_runners_(std::move(task_runners)),
+      settings_(std::move(settings)),
+      vm_(std::move(vm)),
+      is_gpu_disabled_sync_switch_(new fml::SyncSwitch(is_gpu_disabled)),
+      volatile_path_tracker_(std::move(volatile_path_tracker)),
+>>>>>>> 183b6b9dc... Started initializing the gpu disable syncswitch based on the app state. (#24503)
       weak_factory_gpu_(nullptr),
       weak_factory_(this) {
   FML_CHECK(vm_) << "Must have access to VM to create a shell.";
@@ -435,6 +628,59 @@ Shell::~Shell() {
   platform_latch.Wait();
 }
 
+<<<<<<< HEAD
+=======
+std::unique_ptr<Shell> Shell::Spawn(
+    RunConfiguration run_configuration,
+    const CreateCallback<PlatformView>& on_create_platform_view,
+    const CreateCallback<Rasterizer>& on_create_rasterizer) const {
+  FML_DCHECK(task_runners_.IsValid());
+  auto shell_maker = [&](bool is_gpu_disabled) {
+    std::unique_ptr<Shell> result(CreateWithSnapshot(
+        PlatformData{}, task_runners_, GetSettings(), vm_,
+        vm_->GetVMData()->GetIsolateSnapshot(), on_create_platform_view,
+        on_create_rasterizer,
+        [engine = this->engine_.get()](
+            Engine::Delegate& delegate,
+            const PointerDataDispatcherMaker& dispatcher_maker, DartVM& vm,
+            fml::RefPtr<const DartSnapshot> isolate_snapshot,
+            TaskRunners task_runners, const PlatformData& platform_data,
+            Settings settings, std::unique_ptr<Animator> animator,
+            fml::WeakPtr<IOManager> io_manager,
+            fml::RefPtr<SkiaUnrefQueue> unref_queue,
+            fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
+            std::shared_ptr<VolatilePathTracker> volatile_path_tracker) {
+          return engine->Spawn(/*delegate=*/delegate,
+                               /*dispatcher_maker=*/dispatcher_maker,
+                               /*settings=*/settings,
+                               /*animator=*/std::move(animator));
+        },
+        is_gpu_disabled));
+    return result;
+  };
+  std::unique_ptr<Shell> result;
+  GetIsGpuDisabledSyncSwitch()->Execute(
+      fml::SyncSwitch::Handlers()
+          .SetIfFalse([&] { result = shell_maker(false); })
+          .SetIfTrue([&] { result = shell_maker(true); }));
+  result->shared_resource_context_ = io_manager_->GetSharedResourceContext();
+  result->RunEngine(std::move(run_configuration));
+
+  task_runners_.GetRasterTaskRunner()->PostTask(
+      [rasterizer = rasterizer_->GetWeakPtr(),
+       spawn_rasterizer = result->rasterizer_->GetWeakPtr()]() {
+        if (rasterizer) {
+          rasterizer->BlockThreadMerging();
+        }
+        if (spawn_rasterizer) {
+          spawn_rasterizer->BlockThreadMerging();
+        }
+      });
+
+  return result;
+}
+
+>>>>>>> 183b6b9dc... Started initializing the gpu disable syncswitch based on the app state. (#24503)
 void Shell::NotifyLowMemoryWarning() const {
   auto trace_id = fml::tracing::TraceNonce();
   TRACE_EVENT_ASYNC_BEGIN0("flutter", "Shell::NotifyLowMemoryWarning",
diff --git a/shell/common/shell.h b/shell/common/shell.h
@@ -113,6 +113,8 @@ class Shell final : public PlatformView::Delegate,
   ///                                      valid rasterizer. This will be called
   ///                                      on the render task runner before this
   ///                                      method returns.
+  /// @param[in]  is_gpu_disabled          The default value for the switch that
+  ///                                      turns off the GPU.
   ///
   /// @return     A full initialized shell if the settings and callbacks are
   ///             valid. The root isolate has been created but not yet launched.
@@ -126,7 +128,8 @@ class Shell final : public PlatformView::Delegate,
       TaskRunners task_runners,
       Settings settings,
       const CreateCallback<PlatformView>& on_create_platform_view,
-      const CreateCallback<Rasterizer>& on_create_rasterizer);
+      const CreateCallback<Rasterizer>& on_create_rasterizer,
+      bool is_gpu_disabled = false);
 
   //----------------------------------------------------------------------------
   /// @brief      Creates a shell instance using the provided settings. The
@@ -428,7 +431,17 @@ class Shell final : public PlatformView::Delegate,
   // How many frames have been timed since last report.
   size_t UnreportedFramesCount() const;
 
+<<<<<<< HEAD
   Shell(DartVMRef vm, TaskRunners task_runners, Settings settings);
+=======
+  sk_sp<GrDirectContext> shared_resource_context_;
+
+  Shell(DartVMRef vm,
+        TaskRunners task_runners,
+        Settings settings,
+        std::shared_ptr<VolatilePathTracker> volatile_path_tracker,
+        bool is_gpu_disabled);
+>>>>>>> 183b6b9dc... Started initializing the gpu disable syncswitch based on the app state. (#24503)
 
   static std::unique_ptr<Shell> CreateShellOnPlatformThread(
       DartVMRef vm,
@@ -437,7 +450,23 @@ class Shell final : public PlatformView::Delegate,
       Settings settings,
       fml::RefPtr<const DartSnapshot> isolate_snapshot,
       const Shell::CreateCallback<PlatformView>& on_create_platform_view,
+<<<<<<< HEAD
       const Shell::CreateCallback<Rasterizer>& on_create_rasterizer);
+=======
+      const Shell::CreateCallback<Rasterizer>& on_create_rasterizer,
+      const EngineCreateCallback& on_create_engine,
+      bool is_gpu_disabled);
+  static std::unique_ptr<Shell> CreateWithSnapshot(
+      const PlatformData& platform_data,
+      TaskRunners task_runners,
+      Settings settings,
+      DartVMRef vm,
+      fml::RefPtr<const DartSnapshot> isolate_snapshot,
+      const CreateCallback<PlatformView>& on_create_platform_view,
+      const CreateCallback<Rasterizer>& on_create_rasterizer,
+      const EngineCreateCallback& on_create_engine,
+      bool is_gpu_disabled);
+>>>>>>> 183b6b9dc... Started initializing the gpu disable syncswitch based on the app state. (#24503)
 
   bool Setup(std::unique_ptr<PlatformView> platform_view,
              std::unique_ptr<Engine> engine,
diff --git a/shell/common/shell_test.cc b/shell/common/shell_test.cc
@@ -308,7 +308,8 @@ std::unique_ptr<Shell> ShellTest::CreateShell(
     TaskRunners task_runners,
     bool simulate_vsync,
     std::shared_ptr<ShellTestExternalViewEmbedder>
-        shell_test_external_view_embedder) {
+        shell_test_external_view_embedder,
+    bool is_gpu_disabled) {
   const auto vsync_clock = std::make_shared<ShellTestVsyncClock>();
   CreateVsyncWaiter create_vsync_waiter = [&]() {
     if (simulate_vsync) {
@@ -329,7 +330,8 @@ std::unique_ptr<Shell> ShellTest::CreateShell(
             ShellTestPlatformView::BackendType::kDefaultBackend,
             shell_test_external_view_embedder);
       },
-      [](Shell& shell) { return std::make_unique<Rasterizer>(shell); });
+      [](Shell& shell) { return std::make_unique<Rasterizer>(shell); },
+      is_gpu_disabled);
 }
 void ShellTest::DestroyShell(std::unique_ptr<Shell> shell) {
   DestroyShell(std::move(shell), GetTaskRunnersForFixture());
diff --git a/shell/common/shell_test.h b/shell/common/shell_test.h
@@ -38,7 +38,8 @@ class ShellTest : public FixtureTest {
       TaskRunners task_runners,
       bool simulate_vsync = false,
       std::shared_ptr<ShellTestExternalViewEmbedder>
-          shell_test_external_view_embedder = nullptr);
+          shell_test_external_view_embedder = nullptr,
+      bool is_gpu_disabled = false);
   void DestroyShell(std::unique_ptr<Shell> shell);
   void DestroyShell(std::unique_ptr<Shell> shell, TaskRunners task_runners);
   TaskRunners GetTaskRunnersForFixture();
diff --git a/shell/common/shell_unittests.cc b/shell/common/shell_unittests.cc
diff --git a/shell/platform/darwin/ios/framework/Source/FlutterEngine.mm b/shell/platform/darwin/ios/framework/Source/FlutterEngine.mm
