text: // Copyright 2013 The Flutter Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  
  #ifndef FLUTTER_RUNTIME_DART_VM_LIFECYCLE_H_
  #define FLUTTER_RUNTIME_DART_VM_LIFECYCLE_H_
  
  #include <memory>
  
  #include "flutter/fml/macros.h"
  #include "flutter/lib/ui/isolate_name_server/isolate_name_server.h"
  #include "flutter/runtime/dart_vm.h"
  #include "flutter/runtime/service_protocol.h"
  
  namespace blink {
  
  // A strong reference to the Dart VM. There can only be one VM running in the
  // process at any given time. A reference to the VM may only be obtained via the
  // |Create| method. In case there is already a running instance of the VM in the
  // process, a strong reference to that VM is obtained and the arguments to the
  // |Create| call ignored. If there is no VM already running in the process, a VM
  // is initialized in a thread safe manner and returned to the caller. The VM
  // will shutdown only when all callers relinquish their references (by
  // collecting their instances of this class).
  //
  // DartVMRef instances may be created on any thread.
  class DartVMRef {
   public:
    FML_WARN_UNUSED_RESULT
    static DartVMRef Create(Settings settings,
                            fml::RefPtr<DartSnapshot> vm_snapshot = nullptr,
                            fml::RefPtr<DartSnapshot> isolate_snapshot = nullptr,
                            fml::RefPtr<DartSnapshot> shared_snapshot = nullptr);
  
    DartVMRef(DartVMRef&&);
  
    ~DartVMRef();
  
    // This is an inherently racy way to check if a VM instance is running and
    // should not be used outside of unit-tests where there is a known threading
    // model.
    static bool IsInstanceRunning();
  
    static std::shared_ptr<const DartVMData> GetVMData();
  
    static std::shared_ptr<ServiceProtocol> GetServiceProtocol();
  
    static std::shared_ptr<IsolateNameServer> GetIsolateNameServer();
  
    operator bool() const { return static_cast<bool>(vm_); }
  
    DartVM* get() {
      FML_DCHECK(vm_);
      return vm_.get();
    }
  
    DartVM* operator->() {
      FML_DCHECK(vm_);
      return vm_.get();
    }
  
    DartVM* operator&() {
      FML_DCHECK(vm_);
      return vm_.get();
    }
  
   private:
    friend class DartIsolate;
  
    std::shared_ptr<DartVM> vm_;
  
    DartVMRef(std::shared_ptr<DartVM> vm);
  
    // Only used by Dart Isolate to register itself with the VM.
    static DartVM* GetRunningVM();
  
    FML_DISALLOW_COPY_AND_ASSIGN(DartVMRef);
  };
  
  }  // namespace blink
  
  #endif  // FLUTTER_RUNTIME_DART_VM_LIFECYCLE_H_
  