// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "device/vr/openxr/openxr_api_wrapper.h"

#include <stdint.h>

#include <algorithm>
#include <array>
#include <cmath>
#include <type_traits>

#include "base/check.h"
#include "base/containers/contains.h"
#include "base/debug/dump_without_crashing.h"
#include "base/feature_list.h"
#include "base/functional/callback_helpers.h"
#include "base/notreached.h"
#include "base/numerics/angle_conversions.h"
#include "base/task/single_thread_task_runner.h"
#include "base/trace_event/trace_event.h"
#include "base/trace_event/typed_macros.h"
#include "components/viz/common/gpu/context_provider.h"
#include "device/vr/openxr/openxr_extension_helper.h"
#include "device/vr/openxr/openxr_graphics_binding.h"
#include "device/vr/openxr/openxr_input_helper.h"
#include "device/vr/openxr/openxr_layers.h"
#include "device/vr/openxr/openxr_stage_bounds_provider.h"
#include "device/vr/openxr/openxr_util.h"
#include "device/vr/openxr/openxr_view_configuration.h"
#include "device/vr/public/cpp/features.h"
#include "device/vr/public/mojom/xr_session.mojom.h"
#include "device/vr/test/test_hook.h"
#include "gpu/GLES2/gl2extchromium.h"
#include "gpu/command_buffer/client/shared_image_interface.h"
#include "gpu/command_buffer/common/shared_image_usage.h"
#include "third_party/abseil-cpp/absl/container/flat_hash_map.h"
#include "third_party/blink/public/common/features_generated.h"
#include "third_party/openxr/src/include/openxr/openxr.h"
#include "ui/gfx/geometry/point3_f.h"
#include "ui/gfx/geometry/quaternion.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/geometry/transform.h"

#if BUILDFLAG(IS_WIN)
#include <dxgi1_2.h>
#endif

namespace device {

namespace {

// We can get into a state where frames are not requested, such as when the
// visibility state is hidden. Since OpenXR events are polled at the beginning
// of a frame, polling would not occur in this state. To ensure events are
// occasionally polled, a timer loop run every kTimeBetweenPollingEvents to poll
// events if significant time has elapsed since the last time events were
// polled.
constexpr base::TimeDelta kTimeBetweenPollingEvents = base::Seconds(1);

const char* GetXrSessionStateName(XrSessionState state) {
  switch (state) {
    case XR_SESSION_STATE_UNKNOWN:
      return "Unknown";
    case XR_SESSION_STATE_IDLE:
      return "Idle";
    case XR_SESSION_STATE_READY:
      return "Ready";
    case XR_SESSION_STATE_SYNCHRONIZED:
      return "Synchronized";
    case XR_SESSION_STATE_VISIBLE:
      return "Visible";
    case XR_SESSION_STATE_FOCUSED:
      return "Focused";
    case XR_SESSION_STATE_STOPPING:
      return "Stopping";
    case XR_SESSION_STATE_LOSS_PENDING:
      return "Loss_Pending";
    case XR_SESSION_STATE_EXITING:
      return "Exiting";
    case XR_SESSION_STATE_MAX_ENUM:
      return "Max_Enum";
  }

  NOTREACHED();
}

// The default height to use in meters, based off the average standing height
// of an adult. Used as a fallback, in the event the floor cannot be located.
constexpr float kDefaultHeightEstimate = -1.6;

}  // namespace

std::unique_ptr<OpenXrApiWrapper> OpenXrApiWrapper::Create(
    XrInstance instance,
    OpenXrGraphicsBinding* graphics_binding) {
  std::unique_ptr<OpenXrApiWrapper> openxr =
      std::make_unique<OpenXrApiWrapper>();

  if (!openxr->Initialize(instance, graphics_binding)) {
    return nullptr;
  }

  return openxr;
}

// static
XrResult OpenXrApiWrapper::GetSystem(XrInstance instance, XrSystemId* system) {
  XrSystemGetInfo system_info = {XR_TYPE_SYSTEM_GET_INFO};
  system_info.formFactor = XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY;
  return xrGetSystem(instance, &system_info, system);
}

// static
std::vector<XrEnvironmentBlendMode> OpenXrApiWrapper::GetSupportedBlendModes(
    XrInstance instance,
    XrSystemId system) {
  // Query the list of supported environment blend modes for the current system.
  uint32_t blend_mode_count;
  const XrViewConfigurationType kSupportedViewConfiguration =
      XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO;
  if (XR_FAILED(xrEnumerateEnvironmentBlendModes(instance, system,
                                                 kSupportedViewConfiguration, 0,
                                                 &blend_mode_count, nullptr))) {
    return {};  // empty vector
  }

  std::vector<XrEnvironmentBlendMode> environment_blend_modes(blend_mode_count);
  if (XR_FAILED(xrEnumerateEnvironmentBlendModes(
          instance, system, kSupportedViewConfiguration, blend_mode_count,
          &blend_mode_count, environment_blend_modes.data()))) {
    return {};  // empty vector
  }

  return environment_blend_modes;
}

// static
bool OpenXrApiWrapper::NeedsSeparateActivity() {
  return test_hook_ == nullptr;
}

OpenXrApiWrapper::OpenXrApiWrapper() = default;

OpenXrApiWrapper::~OpenXrApiWrapper() {
  Uninitialize();
}

void OpenXrApiWrapper::Reset() {
  SetXrSessionState(XR_SESSION_STATE_UNKNOWN);
  depth_sensor_.reset();
  light_estimator_.reset();
  scene_understanding_manager_.reset();
  unbounded_space_provider_.reset();
  visibility_mask_handler_.reset();
  unbounded_space_ = XR_NULL_HANDLE;
  local_space_ = XR_NULL_HANDLE;
  stage_space_ = XR_NULL_HANDLE;
  view_space_ = XR_NULL_HANDLE;
  session_ = XR_NULL_HANDLE;
  blend_mode_ = XR_ENVIRONMENT_BLEND_MODE_MAX_ENUM;
  stage_bounds_ = {};
  bounds_provider_.reset();
  system_ = XR_NULL_SYSTEM_ID;
  instance_ = XR_NULL_HANDLE;
  enabled_features_.clear();
  graphics_binding_ = nullptr;

  primary_view_config_ = OpenXrViewConfiguration();
  secondary_view_configs_.clear();

  frame_state_ = {};
  input_helper_.reset();

  session_options_.reset();
  on_session_started_callback_.Reset();
  on_session_ended_callback_.Reset();
  visibility_changed_callback_.Reset();
}

bool OpenXrApiWrapper::Initialize(XrInstance instance,
                                  OpenXrGraphicsBinding* graphics_binding) {
  Reset();

  if (!graphics_binding) {
    return false;
  }

  graphics_binding_ = graphics_binding;
  session_running_ = false;
  pending_frame_ = false;

  DCHECK(instance != XR_NULL_HANDLE);
  instance_ = instance;

  DCHECK(HasInstance());

  if (XR_FAILED(InitializeSystem())) {
    return false;
  }

  if (!graphics_binding_->Initialize(instance_, system_)) {
    return false;
  }

  DCHECK(IsInitialized());

  if (test_hook_) {
    // Allow our mock implementation of OpenXr to be controlled by tests.
    // The mock implementation of xrCreateInstance returns a pointer to the
    // service test hook (g_test_helper) as the instance.
    service_test_hook_ = reinterpret_cast<ServiceTestHook*>(instance_);
    service_test_hook_->SetTestHook(test_hook_);

    test_hook_->AttachCurrentThread();
  }

  return true;
}

bool OpenXrApiWrapper::IsInitialized() const {
  return HasInstance() && HasSystem();
}

XrResult OpenXrApiWrapper::ShutdownSession() {
  if (!HasSession()) {
    return XR_SUCCESS;
  }

  XrResult result = xrEndSession(session_);
  Uninitialize();
  return result;
}

void OpenXrApiWrapper::Uninitialize() {
  // The instance is owned by the OpenXRDevice, so don't destroy it here.

  // Destroying an session in OpenXr also destroys all child objects of that
  // instance (including the swapchain, and spaces objects),
  // so they don't need to be manually destroyed.
  if (HasSession()) {
    graphics_binding_->OnSessionDestroyed(
        context_provider_ ? context_provider_->SharedImageInterface()
                          : nullptr);
    xrDestroySession(session_);
  }

  if (test_hook_)
    test_hook_->DetachCurrentThread();

  if (on_session_ended_callback_) {
    on_session_ended_callback_.Run(ExitXrPresentReason::kOpenXrUninitialize);
  }

  // If we haven't reported that the session started yet, we need to report
  // that it failed, so that the browser doesn't think there's still a pending
  // session request, and can try again (though it may not recover).
  if (on_session_started_callback_) {
    std::move(on_session_started_callback_)
        .Run(std::move(session_options_), XR_ERROR_INITIALIZATION_FAILED);
  }

  Reset();
  session_running_ = false;
  pending_frame_ = false;
}

bool OpenXrApiWrapper::HasInstance() const {
  return instance_ != XR_NULL_HANDLE;
}

bool OpenXrApiWrapper::HasSystem() const {
  return system_ != XR_NULL_SYSTEM_ID && primary_view_config_.Initialized();
}

bool OpenXrApiWrapper::HasBlendMode() const {
  return blend_mode_ != XR_ENVIRONMENT_BLEND_MODE_MAX_ENUM;
}

bool OpenXrApiWrapper::HasSession() const {
  return session_ != XR_NULL_HANDLE;
}

bool OpenXrApiWrapper::HasSpace(XrReferenceSpaceType type) const {
  if (unbounded_space_provider_ &&
      unbounded_space_provider_->GetType() == type) {
    return unbounded_space_ != XR_NULL_HANDLE;
  }

  switch (type) {
    case XR_REFERENCE_SPACE_TYPE_LOCAL:
      return local_space_ != XR_NULL_HANDLE;
    case XR_REFERENCE_SPACE_TYPE_VIEW:
      return view_space_ != XR_NULL_HANDLE;
    case XR_REFERENCE_SPACE_TYPE_STAGE:
      return stage_space_ != XR_NULL_HANDLE;
    case XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT:
      return local_floor_space_ != XR_NULL_HANDLE;
    default:
      NOTREACHED();
  }
}

bool OpenXrApiWrapper::HasFrameState() const {
  return frame_state_.type == XR_TYPE_FRAME_STATE;
}

bool OpenXrApiWrapper::IsFeatureEnabled(
    device::mojom::XRSessionFeature feature) const {
  return base::Contains(enabled_features_, feature);
}

XrResult OpenXrApiWrapper::InitializeViewConfig(
    XrViewConfigurationType type,
    OpenXrViewConfiguration& view_config) {
  std::vector<XrViewConfigurationView> view_properties;
  RETURN_IF_XR_FAILED(GetPropertiesForViewConfig(type, view_properties));
  view_config.Initialize(type, std::move(view_properties),
                         graphics_binding_->GetMaxTextureSize());

  return XR_SUCCESS;
}

XrResult OpenXrApiWrapper::GetPropertiesForViewConfig(
    XrViewConfigurationType type,
    std::vector<XrViewConfigurationView>& view_properties) const {
  uint32_t view_count;
  RETURN_IF_XR_FAILED(xrEnumerateViewConfigurationViews(
      instance_, system_, type, 0, &view_count, nullptr));

  view_properties.resize(view_count, {XR_TYPE_VIEW_CONFIGURATION_VIEW});
  RETURN_IF_XR_FAILED(
      xrEnumerateViewConfigurationViews(instance_, system_, type, view_count,
                                        &view_count, view_properties.data()));

  return XR_SUCCESS;
}

XrResult OpenXrApiWrapper::InitializeSystem() {
  DCHECK(HasInstance());
  DCHECK(!HasSystem());

  RETURN_IF_XR_FAILED(GetSystem(instance_, &system_));

  RETURN_IF_XR_FAILED(
      InitializeViewConfig(kPrimaryViewConfiguration, primary_view_config_));
  DCHECK_EQ(primary_view_config_.Properties().size(), kNumPrimaryViews);
  // The primary view configuration is the only one initially active
  primary_view_config_.SetActive(true);

  // Get the list of secondary view configurations that both we and the OpenXR
  // runtime support.
  uint32_t view_config_count;
  RETURN_IF_XR_FAILED(xrEnumerateViewConfigurations(
      instance_, system_, 0, &view_config_count, nullptr));

  std::vector<XrViewConfigurationType> view_config_types(view_config_count);
  RETURN_IF_XR_FAILED(xrEnumerateViewConfigurations(
      instance_, system_, view_config_count, &view_config_count,
      view_config_types.data()));

  for (const auto& view_config_type : kSecondaryViewConfigurations) {
    if (base::Contains(view_config_types, view_config_type)) {
      OpenXrViewConfiguration view_config;
      RETURN_IF_XR_FAILED(InitializeViewConfig(view_config_type, view_config));
      secondary_view_configs_.emplace(view_config_type, std::move(view_config));
    }
  }

  return XR_SUCCESS;
}

device::mojom::XREnvironmentBlendMode OpenXrApiWrapper::GetMojoBlendMode(
    XrEnvironmentBlendMode xr_blend_mode) {
  switch (xr_blend_mode) {
    case XR_ENVIRONMENT_BLEND_MODE_OPAQUE:
      return device::mojom::XREnvironmentBlendMode::kOpaque;
    case XR_ENVIRONMENT_BLEND_MODE_ADDITIVE:
      return device::mojom::XREnvironmentBlendMode::kAdditive;
    case XR_ENVIRONMENT_BLEND_MODE_ALPHA_BLEND:
      return device::mojom::XREnvironmentBlendMode::kAlphaBlend;
    case XR_ENVIRONMENT_BLEND_MODE_MAX_ENUM:
      NOTREACHED();
  };
  return device::mojom::XREnvironmentBlendMode::kOpaque;
}

device::mojom::XREnvironmentBlendMode
OpenXrApiWrapper::PickEnvironmentBlendModeForSession(
    device::mojom::XRSessionMode session_mode) {
  DCHECK(HasInstance());
  std::vector<XrEnvironmentBlendMode> supported_blend_modes =
      GetSupportedBlendModes(instance_, system_);

  DCHECK(supported_blend_modes.size() > 0);

  blend_mode_ = supported_blend_modes[0];

  switch (session_mode) {
    case device::mojom::XRSessionMode::kImmersiveVr:
      if (base::Contains(supported_blend_modes,
                         XR_ENVIRONMENT_BLEND_MODE_OPAQUE))
        blend_mode_ = XR_ENVIRONMENT_BLEND_MODE_OPAQUE;
      break;
    case device::mojom::XRSessionMode::kImmersiveAr:
      // Prefer Alpha Blend when both Alpha Blend and Additive modes are
      // supported. This only concerns video see through devices with an
      // Additive compatibility mode
      if (base::Contains(supported_blend_modes,
                         XR_ENVIRONMENT_BLEND_MODE_ALPHA_BLEND)) {
        blend_mode_ = XR_ENVIRONMENT_BLEND_MODE_ALPHA_BLEND;
      } else if (base::Contains(supported_blend_modes,
                                XR_ENVIRONMENT_BLEND_MODE_ADDITIVE)) {
        blend_mode_ = XR_ENVIRONMENT_BLEND_MODE_ADDITIVE;
      }
      break;
    case device::mojom::XRSessionMode::kInline:
      NOTREACHED();
  }

  return GetMojoBlendMode(blend_mode_);
}

OpenXrPlaneManager* OpenXrApiWrapper::GetPlaneManager() {
  return scene_understanding_manager_ &&
                 IsFeatureEnabled(mojom::XRSessionFeature::PLANE_DETECTION)
             ? scene_understanding_manager_->GetPlaneManager()
             : nullptr;
}

OpenXrAnchorManager* OpenXrApiWrapper::GetAnchorManager() {
  return scene_understanding_manager_
             ? scene_understanding_manager_->GetAnchorManager()
             : nullptr;
}

OpenXrHitTestManager* OpenXrApiWrapper::GetHitTestManager() {
  return scene_understanding_manager_
             ? scene_understanding_manager_->GetHitTestManager()
             : nullptr;
}

OpenXrLightEstimator* OpenXrApiWrapper::GetLightEstimator() {
  return light_estimator_.get();
}

OpenXrDepthSensor* OpenXrApiWrapper::GetDepthSensor() {
  return depth_sensor_.get();
}

XrResult OpenXrApiWrapper::EnableSupportedFeatures(
    const OpenXrExtensionHelper& extension_helper) {
  CHECK(session_options_);
  enabled_features_.clear();

  // First do some preliminary filtering to build a list of features we can
  // theoretically support based on the requested mode and enabled extensions.
  // This prevents building objects that just need to be torn down because e.g.
  // we were missing any extensions that we can use to support a required
  // feature.
  auto mode = session_options_->mode;
  auto enable_function = [&extension_helper,
                          mode](device::mojom::XRSessionFeature feature) {
    return IsFeatureSupportedForMode(feature, mode) &&
           extension_helper.IsFeatureSupported(feature);
  };

  if (!std::ranges::all_of(session_options_->required_features,
                           enable_function)) {
    DVLOG(1) << __func__ << ": Not all required features could be supported.";
    for (const auto& feature : session_options_->required_features) {
      if (!enable_function(feature)) {
        DVLOG(1) << __func__ << ": " << feature << " Could not be supported";
      }
    }
    return XR_ERROR_INITIALIZATION_FAILED;
  }

  std::unordered_set<mojom::XRSessionFeature> requested_features;
  requested_features.insert(session_options_->required_features.begin(),
                            session_options_->required_features.end());
  std::ranges::copy_if(
      session_options_->optional_features,
      std::inserter(requested_features, requested_features.begin()),
      enable_function);

  for (const auto& feature : requested_features) {
    bool is_enabled = false;
    bool is_required =
        base::Contains(session_options_->required_features, feature);

    switch (feature) {
      case mojom::XRSessionFeature::REF_SPACE_LOCAL_FLOOR:
        // Nothing else should be creating the local floor space, but if it does
        // already exist, we can use it as-is. Some errors were seen during
        // development where this was true.
        if (!HasSpace(XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT)) {
          CreateSpace(XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT,
                      &local_floor_space_);
        } else {
          DLOG(ERROR) << __func__ << ": Already had local floor space";
        }
        is_enabled = HasSpace(XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT);
        break;

      case mojom::XRSessionFeature::REF_SPACE_BOUNDED_FLOOR:
        // Stage space may have already been created by other features.
        if (!HasSpace(XR_REFERENCE_SPACE_TYPE_STAGE)) {
          CreateSpace(XR_REFERENCE_SPACE_TYPE_STAGE, &stage_space_);
        }
        bounds_provider_ = extension_helper.CreateStageBoundsProvider(session_);
        UpdateStageBounds();
        is_enabled =
            HasSpace(XR_REFERENCE_SPACE_TYPE_STAGE) && bounds_provider_;
        break;

      case mojom::XRSessionFeature::REF_SPACE_UNBOUNDED:
        unbounded_space_provider_ =
            extension_helper.CreateUnboundedSpaceProvider();
        if (unbounded_space_provider_) {
          if (XR_FAILED(unbounded_space_provider_->CreateSpace(
                  session_, &unbounded_space_))) {
            unbounded_space_provider_ = nullptr;
          }
        }
        is_enabled = unbounded_space_ != XR_NULL_HANDLE;
        break;

      case mojom::XRSessionFeature::PLANE_DETECTION:
        if (scene_understanding_manager_ == nullptr) {
          scene_understanding_manager_ =
              extension_helper.CreateSceneUnderstandingManager(
                  this, local_space_, session_options_->required_features,
                  session_options_->optional_features);
        }
        is_enabled = scene_understanding_manager_ != nullptr &&
                     scene_understanding_manager_->GetPlaneManager() != nullptr;
        break;

      case mojom::XRSessionFeature::HIT_TEST:
        if (scene_understanding_manager_ == nullptr) {
          scene_understanding_manager_ =
              extension_helper.CreateSceneUnderstandingManager(
                  this, local_space_, session_options_->required_features,
                  session_options_->optional_features);
        }
        is_enabled =
            scene_understanding_manager_ != nullptr &&
            scene_understanding_manager_->GetHitTestManager() != nullptr;
        break;

      case mojom::XRSessionFeature::LIGHT_ESTIMATION:
        light_estimator_ =
            extension_helper.CreateLightEstimator(session_, local_space_);
        is_enabled = light_estimator_ != nullptr;
        break;

      case mojom::XRSessionFeature::ANCHORS:
        // Anchors are managed by the scene understanding manager.
        if (scene_understanding_manager_ == nullptr) {
          scene_understanding_manager_ =
              extension_helper.CreateSceneUnderstandingManager(
                  this, local_space_, session_options_->required_features,
                  session_options_->optional_features);
        }
        is_enabled =
            scene_understanding_manager_ != nullptr &&
            scene_understanding_manager_->GetAnchorManager() != nullptr;
        break;

      case mojom::XRSessionFeature::DEPTH:
        if (session_options_->depth_options) {
          depth_sensor_ = extension_helper.CreateDepthSensor(
              session_, local_space_, *session_options_->depth_options);
        }
        is_enabled = depth_sensor_ != nullptr;
        break;

      case mojom::XRSessionFeature::HAND_INPUT:
        is_enabled = input_helper_ && input_helper_->IsHandTrackingEnabled();
        break;

      case mojom::XRSessionFeature::SECONDARY_VIEWS:
      case mojom::XRSessionFeature::WEBGPU:
        // SECONDARY_VIEWS and WEBGPU support can't be checked beyond just the
        // mode/extension check. If we passed that, then it's enabled.
        is_enabled = true;
        break;

      case mojom::XRSessionFeature::REF_SPACE_VIEWER:
      case mojom::XRSessionFeature::REF_SPACE_LOCAL:
        // Supported by the core spec with no special additional features
        is_enabled = true;
        break;

      case mojom::XRSessionFeature::LAYERS:
        // Enabled if the extension check is good and the graphics binding
        // also supports it.
        is_enabled = graphics_binding_->SupportsLayers();
        break;

      case mojom::XRSessionFeature::FRONT_FACING:
      case mojom::XRSessionFeature::IMAGE_TRACKING:
      case mojom::XRSessionFeature::CAMERA_ACCESS:
      case mojom::XRSessionFeature::DOM_OVERLAY:
        // Not supported by OpenXR at all, shouldn't have even been asked for.
        DLOG(ERROR) << __func__
                    << " Received request for unsupported feature: " << feature;
        break;
    }

    DVLOG(1) << __func__ << " feature=" << feature
             << " is_enabled=" << is_enabled << " is_required=" << is_required;
    if (is_enabled) {
      enabled_features_.insert(feature);
    } else if (is_required) {  // Not enabled but required
      return XR_ERROR_INITIALIZATION_FAILED;
    }
  }

  return XR_SUCCESS;
}

bool OpenXrApiWrapper::UpdateAndGetSessionEnded() {
  // Early return if we already know that the session doesn't exist.
  if (!IsInitialized()) {
    return true;
  }

  // Ensure we have the latest state from the OpenXR runtime.
  if (XR_FAILED(ProcessEvents())) {
    DCHECK(!session_running_);
  }

  // This object is initialized at creation and uninitialized when the OpenXR
  // session has ended. Once uninitialized, this object is never re-initialized.
  // If a new session is requested by WebXR, a new object is created.
  return !IsInitialized();
}

// Callers of this function must check the XrResult return value and destroy
// this OpenXrApiWrapper object on failure to clean up any intermediate
// objects that may have been created before the failure.
XrResult OpenXrApiWrapper::InitSession(
    mojom::XRRuntimeSessionOptionsPtr options,
    const OpenXrExtensionHelper& extension_helper,
    SessionStartedCallback on_session_started_callback,
    SessionEndedCallback on_session_ended_callback,
    VisibilityChangedCallback visibility_changed_callback) {
  DCHECK(IsInitialized());
  DCHECK(options);

  extension_helper_ = &extension_helper;

  session_options_ = std::move(options);
  on_session_started_callback_ = std::move(on_session_started_callback);
  on_session_ended_callback_ = std::move(on_session_ended_callback);
  visibility_changed_callback_ = std::move(visibility_changed_callback);

  // The input system uses the system name to help disambiguate certain sets of
  // controllers, but we also log the system name/vendor id on debug builds.
  XrSystemProperties system_properties = {XR_TYPE_SYSTEM_PROPERTIES};
  RETURN_IF_XR_FAILED(
      xrGetSystemProperties(instance_, system_, &system_properties));
  DVLOG(1) << __func__ << " : Vendor Id: " << system_properties.vendorId
           << " : System Name: " << system_properties.systemName;

  RETURN_IF_XR_FAILED(CreateSession());
  RETURN_IF_XR_FAILED(
      CreateSpace(XR_REFERENCE_SPACE_TYPE_LOCAL, &local_space_));
  RETURN_IF_XR_FAILED(CreateSpace(XR_REFERENCE_SPACE_TYPE_VIEW, &view_space_));

  // We need to mark whether or not the graphics binding is backing a WebGPU
  // session prior to any swap chain images being activated because the
  // associated shared images need to be created with WebGPU-specific flags.
  const bool webgpu_session =
      base::Contains(session_options_->required_features,
                     device::mojom::XRSessionFeature::WEBGPU) ||
      base::Contains(session_options_->optional_features,
                     device::mojom::XRSessionFeature::WEBGPU);
  graphics_binding_->OnSessionCreated(local_space_, webgpu_session);

  // Now the primary layer should be available.
  bool swapchain_size_updated = RecomputeSwapchainSizeAndViewports();
  DCHECK(swapchain_size_updated);

  // Swapchain must be created after size is updated.
  RETURN_IF_XR_FAILED(CreateSwapchain());

  bool enable_hand_tracking =
      base::Contains(session_options_->required_features,
                     device::mojom::XRSessionFeature::HAND_INPUT) ||
      base::Contains(session_options_->optional_features,
                     device::mojom::XRSessionFeature::HAND_INPUT);

  RETURN_IF_XR_FAILED(OpenXRInputHelper::CreateOpenXRInputHelper(
      instance_, system_properties.systemName, extension_helper, session_,
      local_space_, enable_hand_tracking, &input_helper_));

  // Make sure all of the objects we initialized are there.
  DCHECK(HasSession());
  DCHECK(graphics_binding_->HasBaseLayerColorSwapchain());
  DCHECK(HasSpace(XR_REFERENCE_SPACE_TYPE_LOCAL));
  DCHECK(HasSpace(XR_REFERENCE_SPACE_TYPE_VIEW));
  DCHECK(input_helper_);

  XrResult result = EnableSupportedFeatures(extension_helper);

  if (XR_FAILED(result)) {
    std::move(on_session_started_callback_)
        .Run(std::move(session_options_), result);
    return result;
  }

  if (OpenXrVisibilityMaskHandler::IsSupported(
          *extension_helper.ExtensionEnumeration()) &&
      base::FeatureList::IsEnabled(blink::features::kWebXRVisibilityMask)) {
    visibility_mask_handler_ = std::make_unique<OpenXrVisibilityMaskHandler>(
        extension_helper, session_);
  }

  EnsureEventPolling();

  return XR_SUCCESS;
}

XrResult OpenXrApiWrapper::CreateSession() {
  DCHECK(!HasSession());
  DCHECK(IsInitialized());

  XrSessionCreateInfo session_create_info = {XR_TYPE_SESSION_CREATE_INFO};
  session_create_info.next = graphics_binding_->GetSessionCreateInfo();
  session_create_info.systemId = system_;

  return xrCreateSession(instance_, &session_create_info, &session_);
}

XrResult OpenXrApiWrapper::CreateSwapchain() {
  DCHECK(IsInitialized());
  DCHECK(HasSession());

  RETURN_IF_XR_FAILED(graphics_binding_->CreateBaseLayerSwapchain(
      session_, GetRecommendedSwapchainSampleCount()));

  CreateSharedMailboxes();

  return XR_SUCCESS;
}

// Recomputes the size of the swapchain - the swapchain includes the primary
// views (left and right), as well as any active secondary views. Secondary
// views are only included when the OpenXR runtime reports that they're active.
// It's valid for a secondary view configuration to be enabled but not active.
// The viewports of all active views are also computed. The primary views are
// always at the beginning of the texture, followed by active secondary views.
// Unlike OpenXR which has separate swapchains for each view configuration,
// WebXR exposes a single framebuffer for all views, so we need to keep track of
// the viewports ourselves.
// Returns whether the swapchain size has changed.
bool OpenXrApiWrapper::RecomputeSwapchainSizeAndViewports() {
  uint32_t total_width = 0;
  uint32_t total_height = 0;
  for (const auto& view_properties : primary_view_config_.Properties()) {
    total_width += view_properties.Width();
    total_height = std::max(total_height, view_properties.Height());
  }
  primary_view_config_.SetViewport(0, 0, total_width, total_height);

  if (IsFeatureEnabled(mojom::XRSessionFeature::SECONDARY_VIEWS)) {
    for (auto& secondary_view_config : secondary_view_configs_) {
      OpenXrViewConfiguration& view_config = secondary_view_config.second;
      if (view_config.Active()) {
        uint32_t view_width = 0;
        uint32_t view_height = 0;
        for (const auto& view_properties : view_config.Properties()) {
          view_width += view_properties.Width();
          view_height = std::max(view_height, view_properties.Height());
        }
        view_config.SetViewport(total_width, 0, view_width, view_height);
        total_width += view_width;
        total_height = std::max(total_height, view_height);
      }
    }
  }

  auto swapchain_image_size =
      graphics_binding_->GetProjectionLayerSwapchainImageSize();
  if (swapchain_image_size.width() != static_cast<int>(total_width) ||
      swapchain_image_size.height() != static_cast<int>(total_height)) {
    graphics_binding_->SetProjectionLayerSwapchainImageSize(
        gfx::Size(total_width, total_height));
    return true;
  }

  return false;
}

XrSpace OpenXrApiWrapper::GetReferenceSpace(
    device::mojom::XRReferenceSpaceType type) const {
  switch (type) {
    case device::mojom::XRReferenceSpaceType::kLocal:
      return local_space_;
    case device::mojom::XRReferenceSpaceType::kViewer:
      return view_space_;
    case device::mojom::XRReferenceSpaceType::kBoundedFloor:
      return stage_space_;
    case device::mojom::XRReferenceSpaceType::kUnbounded:
      return unbounded_space_;
    case device::mojom::XRReferenceSpaceType::kLocalFloor:
      return local_floor_space_;
  }

  NOTREACHED();
}

std::optional<XrLocation>
OpenXrApiWrapper::GetXrLocationFromNativeOriginInformation(
    const mojom::XRNativeOriginInformation& native_origin,
    const gfx::Transform& native_origin_from_object) {
  switch (native_origin.which()) {
    case mojom::XRNativeOriginInformation::Tag::kReferenceSpaceType:
      return XrLocation{
          GfxTransformToXrPose(native_origin_from_object),
          GetReferenceSpace(native_origin.get_reference_space_type())};
    case mojom::XRNativeOriginInformation::Tag::kAnchorId:
      if (auto* anchor_manager = GetAnchorManager(); anchor_manager) {
        return anchor_manager->GetXrLocationFromAnchor(
            native_origin.get_anchor_id(), native_origin_from_object);
      }
      return std::nullopt;
    case mojom::XRNativeOriginInformation::Tag::kPlaneId:
      if (auto* plane_manager = GetPlaneManager(); plane_manager) {
        return plane_manager->GetXrLocationFromPlane(
            native_origin.get_plane_id(), native_origin_from_object);
      }
      return std::nullopt;
    case mojom::XRNativeOriginInformation::Tag::kHandJointSpaceInfo:
      if (session_state_ != XR_SESSION_STATE_FOCUSED) {
        return std::nullopt;
      }
      return input_helper_->GetXrLocationFromHandJoint(
          local_space_, *native_origin.get_hand_joint_space_info(),
          native_origin_from_object);
    case mojom::XRNativeOriginInformation::Tag::kInputSourceSpaceInfo:
      if (session_state_ != XR_SESSION_STATE_FOCUSED) {
        return std::nullopt;
      }
      return input_helper_->GetXrLocationFromInputSource(
          *native_origin.get_input_source_space_info(),
          native_origin_from_object);
    case mojom::XRNativeOriginInformation::Tag::kImageIndex:
      NOTREACHED();
  }
}

// Based on the capabilities of the system and runtime, determine whether
// to use shared images to draw into OpenXR swap chain buffers.
bool OpenXrApiWrapper::ShouldCreateSharedImages() const {
  if (!HasSession()) {
    return false;
  }

  // TODO(crbug.com/40917171): Investigate moving the remaining Windows-
  // only checks out of this class and into the GraphicsBinding.
#if BUILDFLAG(IS_WIN)
  if (!graphics_binding_->IsWebGPUSession()) {
    // ANGLE's render_to_texture extension on Windows fails to render correctly
    // for EGL images. Until that is fixed, we need to disable shared images if
    // CanEnableAntiAliasing is true. This can be ignored for WebGPU sessions,
    // which rely on different antialiasing mechanisms.
    if (CanEnableAntiAliasing()) {
      return false;
    }

    // Since WebGL renders upside down, sharing images means the XR runtime
    // needs to be able to consume upside down images and flip them internally.
    // If it is unable to (fovMutable == XR_FALSE), we must gracefully fallback
    // to copying textures. This can be ignored for WebGPU sessions, which
    // render right-side-up.
    XrViewConfigurationProperties view_configuration_props = {
        XR_TYPE_VIEW_CONFIGURATION_PROPERTIES};
    if (XR_FAILED(xrGetViewConfigurationProperties(
            instance_, system_, primary_view_config_.Type(),
            &view_configuration_props)) ||
        (view_configuration_props.fovMutable == XR_FALSE)) {
      return false;
    }
  }
#endif

  return graphics_binding_->CanUseSharedImages();
}

void OpenXrApiWrapper::OnContextProviderCreated(
    scoped_refptr<viz::ContextProvider> context_provider) {
  // TODO(crbug.com/40917165): Move `context_provider_` to
  // `OpenXrGraphicsBinding`.
  // We need to store the context provider because the shared mailboxes are
  // re-created when secondary view configurations become active or non active.
  context_provider_ = std::move(context_provider);

  // Recreate shared mailboxes for the swapchain if necessary.
  CreateSharedMailboxes();
}

void OpenXrApiWrapper::OnContextProviderLost() {
  graphics_binding_->OnContextProviderLost();
  context_provider_ = nullptr;
}

void OpenXrApiWrapper::CreateSharedMailboxes() {
  if (!context_provider_ || !ShouldCreateSharedImages()) {
    return;
  }

  gpu::SharedImageInterface* shared_image_interface =
      context_provider_->SharedImageInterface();
  // Create the MailboxHolders for each texture in the swap chain
  graphics_binding_->CreateBaseLayerSharedImages(shared_image_interface);
}

XrResult OpenXrApiWrapper::CreateSpace(XrReferenceSpaceType type,
                                       XrSpace* space) {
  DCHECK(HasSession());
  DCHECK(!HasSpace(type));

  XrReferenceSpaceCreateInfo space_create_info = {
      XR_TYPE_REFERENCE_SPACE_CREATE_INFO};
  space_create_info.referenceSpaceType = type;
  space_create_info.poseInReferenceSpace = PoseIdentity();

  XrResult result = xrCreateReferenceSpace(session_, &space_create_info, space);

  // Prior to OpenXR 1.1, local floor space could fail if we hadn't enabled it
  // or the platform didn't support it, so we have to emulate it.
  if (XR_FAILED(result) && type == XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT) {
    if (!HasSpace(XR_REFERENCE_SPACE_TYPE_LOCAL)) {
      return result;
    }

    result = CreateEmulatedLocalFloorSpace(space);
  }

  return result;
}

XrResult OpenXrApiWrapper::CreateEmulatedLocalFloorSpace(XrSpace* space) {
  CHECK(HasSession());
  CHECK(HasSpace(XR_REFERENCE_SPACE_TYPE_LOCAL));

  if (!HasSpace(XR_REFERENCE_SPACE_TYPE_STAGE)) {
    // We can estimate if we don't have a stage space, but it's better if we do.
    CreateSpace(XR_REFERENCE_SPACE_TYPE_STAGE, &stage_space_);
  }

  std::optional<gfx::Transform> maybe_local_from_stage = GetLocalFromStage();

  if (!maybe_local_from_stage) {
    DVLOG(3) << __func__ << ": GetLocalFromStage failed, estimating height";
    maybe_local_from_stage =
        gfx::Transform::MakeTranslation(0.0, kDefaultHeightEstimate);

    // Generally, we expect creating the stage to succeed. If we have one, and
    // we failed to get a transform, it's likely that we just need to wait until
    // the first frame so that we can locate the transform between local and
    // stage space. If we *don't* have one, but later get one, we'd expect to
    // get an event that would prompt us to re-create the space as well.
    try_recreate_local_floor_ = HasSpace(XR_REFERENCE_SPACE_TYPE_STAGE);
  }

  XrReferenceSpaceCreateInfo space_create_info = {
      XR_TYPE_REFERENCE_SPACE_CREATE_INFO};
  space_create_info.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_LOCAL;
  space_create_info.poseInReferenceSpace =
      GfxTransformToXrPose(*maybe_local_from_stage);
  RETURN_IF_XR_FAILED(
      xrCreateReferenceSpace(session_, &space_create_info, space));
  emulated_local_floor_ = true;

  return XR_SUCCESS;
}

XrResult OpenXrApiWrapper::UpdateLocalFloorSpace() {
  DVLOG(3) << __func__;
  // Local floor space only needs to be updated if it's emulated or specifically
  // flagged as needing an update.
  if (!emulated_local_floor_ && !try_recreate_local_floor_) {
    return XR_SUCCESS;
  }

  if (HasSpace(XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT)) {
    RETURN_IF_XR_FAILED(xrDestroySpace(local_floor_space_));
    local_floor_space_ = XR_NULL_HANDLE;
    emulated_local_floor_ = false;
  }

  try_recreate_local_floor_ = false;
  return CreateSpace(XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT,
                     &local_floor_space_);
}

XrResult OpenXrApiWrapper::BeginSession() {
  DCHECK(HasSession());
  DCHECK(on_session_started_callback_);

  XrSessionBeginInfo session_begin_info = {XR_TYPE_SESSION_BEGIN_INFO};
  session_begin_info.primaryViewConfigurationType = primary_view_config_.Type();

  XrSecondaryViewConfigurationSessionBeginInfoMSFT secondary_view_config_info =
      {XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SESSION_BEGIN_INFO_MSFT};
  std::vector<XrViewConfigurationType> secondary_view_config_types;
  if (IsFeatureEnabled(mojom::XRSessionFeature::SECONDARY_VIEWS)) {
    secondary_view_config_types.reserve(secondary_view_configs_.size());
    for (const auto& secondary_view_config : secondary_view_configs_) {
      secondary_view_config_types.emplace_back(secondary_view_config.first);
    }
    secondary_view_config_info.viewConfigurationCount =
        secondary_view_config_types.size();
    secondary_view_config_info.enabledViewConfigurationTypes =
        secondary_view_config_types.data();
    session_begin_info.next = &secondary_view_config_info;
  }

  XrResult xr_result = xrBeginSession(session_, &session_begin_info);
  if (XR_SUCCEEDED(xr_result))
    session_running_ = true;

  std::move(on_session_started_callback_)
      .Run(std::move(session_options_), xr_result);

  return xr_result;
}

XrResult OpenXrApiWrapper::BeginFrame() {
  TRACE_EVENT0("xr", "BeginFrame");
  DCHECK(HasSession());
  DCHECK(graphics_binding_->HasBaseLayerColorSwapchain());

  if (!session_running_)
    return XR_ERROR_SESSION_NOT_RUNNING;

  XrFrameWaitInfo wait_frame_info = {XR_TYPE_FRAME_WAIT_INFO};
  XrFrameState frame_state = {XR_TYPE_FRAME_STATE};

  XrSecondaryViewConfigurationFrameStateMSFT secondary_view_frame_states = {
      XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_STATE_MSFT};
  std::vector<XrSecondaryViewConfigurationStateMSFT>
      secondary_view_config_states;
  if (IsFeatureEnabled(mojom::XRSessionFeature::SECONDARY_VIEWS)) {
    secondary_view_config_states.resize(
        secondary_view_configs_.size(),
        {XR_TYPE_SECONDARY_VIEW_CONFIGURATION_STATE_MSFT});
    secondary_view_frame_states.viewConfigurationCount =
        secondary_view_config_states.size();
    secondary_view_frame_states.viewConfigurationStates =
        secondary_view_config_states.data();
    frame_state.next = &secondary_view_frame_states;
  }

  TRACE_EVENT_BEGIN0("xr", "xrWaitFrame");
  RETURN_IF_XR_FAILED(xrWaitFrame(session_, &wait_frame_info, &frame_state));
  TRACE_EVENT_END0("xr", "xrWaitFrame");

  frame_state_ = frame_state;

  if (try_recreate_local_floor_) {
    UpdateLocalFloorSpace();
  }

  if (IsFeatureEnabled(mojom::XRSessionFeature::SECONDARY_VIEWS)) {
    RETURN_IF_XR_FAILED(
        UpdateSecondaryViewConfigStates(secondary_view_config_states));
  }

  XrFrameBeginInfo begin_frame_info = {XR_TYPE_FRAME_BEGIN_INFO};
  RETURN_IF_XR_FAILED(xrBeginFrame(session_, &begin_frame_info));
  pending_frame_ = true;

  RETURN_IF_XR_FAILED(graphics_binding_->ActivateSwapchainImages(
      context_provider_->SharedImageInterface()));

  RETURN_IF_XR_FAILED(UpdateViewConfigurations());

  return XR_SUCCESS;
}

XrResult OpenXrApiWrapper::UpdateViewConfigurations() {
  // While secondary views are only active when reported by the OpenXR runtime,
  // the primary view configuration must always be active.
  DCHECK(primary_view_config_.Active());
  DCHECK(!primary_view_config_.Viewport().IsEmpty());

  RETURN_IF_XR_FAILED(
      LocateViews(XR_REFERENCE_SPACE_TYPE_LOCAL, primary_view_config_));

  if (IsFeatureEnabled(mojom::XRSessionFeature::SECONDARY_VIEWS)) {
    for (auto& view_config : secondary_view_configs_) {
      OpenXrViewConfiguration& config = view_config.second;
      if (config.Active()) {
        RETURN_IF_XR_FAILED(LocateViews(XR_REFERENCE_SPACE_TYPE_LOCAL, config));
      }
    }
  }

  return XR_SUCCESS;
}

// Updates the states of secondary views, which can become active or inactive on
// each frame. If the state of any secondary views have changed, the size of the
// swapchain has also likely changed, so re-create the swapchain.
XrResult OpenXrApiWrapper::UpdateSecondaryViewConfigStates(
    const std::vector<XrSecondaryViewConfigurationStateMSFT>& states) {
  DCHECK(IsFeatureEnabled(mojom::XRSessionFeature::SECONDARY_VIEWS));

  bool state_changed = false;
  for (const XrSecondaryViewConfigurationStateMSFT& state : states) {
    DCHECK(
        base::Contains(secondary_view_configs_, state.viewConfigurationType));
    OpenXrViewConfiguration& view_config =
        secondary_view_configs_.at(state.viewConfigurationType);

    if (view_config.Active() != state.active) {
      state_changed = true;
      view_config.SetActive(state.active);
      if (view_config.Active()) {
        // When a secondary view configuration is activated, its properties
        // (such as recommended width/height) may have changed, so re-query the
        // properties.
        std::vector<XrViewConfigurationView> view_properties;
        RETURN_IF_XR_FAILED(GetPropertiesForViewConfig(
            state.viewConfigurationType, view_properties));
        view_config.SetProperties(std::move(view_properties),
                                  graphics_binding_->GetMaxTextureSize());
      }
    }
  }

  // If the state of any secondary views have changed, the size of the swapchain
  // has likely changed. If the swapchain size has changed, we need to re-create
  // the swapchain.
  if (state_changed && RecomputeSwapchainSizeAndViewports()) {
    graphics_binding_->DestroyBaseLayerSwapchain(
        context_provider_ ? context_provider_->SharedImageInterface()
                          : nullptr);
    RETURN_IF_XR_FAILED(CreateSwapchain());
  }

  return XR_SUCCESS;
}

XrResult OpenXrApiWrapper::EndFrame() {
  DCHECK(pending_frame_);
  DCHECK(HasBlendMode());
  DCHECK(HasSession());
  DCHECK(graphics_binding_->HasBaseLayerColorSwapchain());
  DCHECK(HasSpace(XR_REFERENCE_SPACE_TYPE_LOCAL));
  DCHECK(HasFrameState());

  // Get all the XrCompositionLayer* from the base layer or the
  // layers created by clients. All the projection layers will use
  // the same view configuration defined by primary_view_config_.
  std::unique_ptr<OpenXrLayers> layers =
      graphics_binding_->GetLayersForViewConfig(this, primary_view_config_);

  // Gather all the layers for active secondary views.
  if (IsFeatureEnabled(mojom::XRSessionFeature::SECONDARY_VIEWS)) {
    for (const auto& secondary_view_config : secondary_view_configs_) {
      const OpenXrViewConfiguration& view_config = secondary_view_config.second;
      if (view_config.Active()) {
        layers->AddSecondaryLayerForType(
            local_space_, view_config.Type(), blend_mode_,
            graphics_binding_->GetBaseLayerProjectionViews(view_config),
            graphics_binding_->GetFlipLayerLayout());
      }
    }
  }

  XrFrameEndInfo end_frame_info = {XR_TYPE_FRAME_END_INFO};
  end_frame_info.layerCount = layers->PrimaryLayerCount();
  end_frame_info.layers = layers->PrimaryLayerData();
  end_frame_info.displayTime = frame_state_.predictedDisplayTime;
  end_frame_info.environmentBlendMode = blend_mode_;

  XrSecondaryViewConfigurationFrameEndInfoMSFT secondary_view_end_frame_info = {
      XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_END_INFO_MSFT};
  if (layers->SecondaryConfigCount() > 0) {
    secondary_view_end_frame_info.viewConfigurationCount =
        layers->SecondaryConfigCount();
    secondary_view_end_frame_info.viewConfigurationLayersInfo =
        layers->SecondaryConfigData();

    end_frame_info.next = &secondary_view_end_frame_info;
  }

  RETURN_IF_XR_FAILED(graphics_binding_->ReleaseActiveSwapchainImages());

  TRACE_EVENT_BEGIN0("xr", "xrEndFrame");
  RETURN_IF_XR_FAILED(xrEndFrame(session_, &end_frame_info));
  TRACE_EVENT_END0("xr", "xrEndFrame");
  pending_frame_ = false;

  return XR_SUCCESS;
}

bool OpenXrApiWrapper::HasPendingFrame() const {
  return pending_frame_;
}

XrResult OpenXrApiWrapper::LocateViews(XrReferenceSpaceType space_type,
                                       OpenXrViewConfiguration& view_config) {
  DCHECK(HasSession());

  XrViewState view_state = {XR_TYPE_VIEW_STATE};
  XrViewLocateInfo view_locate_info = {XR_TYPE_VIEW_LOCATE_INFO};
  view_locate_info.viewConfigurationType = view_config.Type();
  view_locate_info.displayTime = frame_state_.predictedDisplayTime;

  switch (space_type) {
    case XR_REFERENCE_SPACE_TYPE_LOCAL:
      view_locate_info.space = local_space_;
      break;
    case XR_REFERENCE_SPACE_TYPE_VIEW:
      view_locate_info.space = view_space_;
      break;
    case XR_REFERENCE_SPACE_TYPE_STAGE:
    case XR_REFERENCE_SPACE_TYPE_UNBOUNDED_MSFT:
    case XR_REFERENCE_SPACE_TYPE_COMBINED_EYE_VARJO:
    case XR_REFERENCE_SPACE_TYPE_MAX_ENUM:
    case XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT:
    case XR_REFERENCE_SPACE_TYPE_LOCALIZATION_MAP_ML:
      NOTREACHED();
  }

  // Initialize the XrView objects' type field to XR_TYPE_VIEW. xrLocateViews
  // fails validation if this isn't set.
  std::vector<XrView> new_views(view_config.Views().size(), {XR_TYPE_VIEW});
  uint32_t view_count;
  RETURN_IF_XR_FAILED(xrLocateViews(session_, &view_locate_info, &view_state,
                                    new_views.size(), &view_count,
                                    new_views.data()));
  DCHECK_EQ(view_count, view_config.Views().size());

  // If the position or orientation is not valid, don't update the views so that
  // the previous valid views are used instead.
  if ((view_state.viewStateFlags & XR_VIEW_STATE_POSITION_VALID_BIT) &&
      (view_state.viewStateFlags & XR_VIEW_STATE_ORIENTATION_VALID_BIT)) {
    view_config.SetViews(std::move(new_views));
    received_initial_valid_primary_views_ = true;
  } else {
    DVLOG(3) << __func__ << " Could not locate views";
    // Highest available framerate as of this writing appears to be 144 fps,
    // this is thus 2 seconds that the views have not been locatable on that
    // device (and longer on most other devices). If we've gone that long
    // without being able to locate our views, then something is likely pretty
    // wrong, and we should end the session to make it obvious something is
    // wrong.
    constexpr uint64_t kMaxInvalidViewFrames = 288;
    if (!received_initial_valid_primary_views_ &&
        frames_before_initial_valid_primary_views_++ >= kMaxInvalidViewFrames) {
      LOG(ERROR) << "No valid views have been received in "
                 << kMaxInvalidViewFrames << " frames";
      ShutdownSession();
      return XR_ERROR_RUNTIME_FAILURE;
    }
  }

  return XR_SUCCESS;
}

// Returns the next predicted display time in nanoseconds.
XrTime OpenXrApiWrapper::GetPredictedDisplayTime() const {
  DCHECK(IsInitialized());
  DCHECK(HasFrameState());

  return frame_state_.predictedDisplayTime;
}

mojom::XRViewPtr OpenXrApiWrapper::CreateView(
    const OpenXrViewConfiguration& view_config,
    uint32_t view_index,
    mojom::XREye eye,
    uint32_t x_offset) const {
  const XrView& xr_view = view_config.Views()[view_index];

  mojom::XRViewPtr view = mojom::XRView::New();
  view->eye = eye;

  view->geometry = mojom::XRViewGeometry::New();
  view->geometry->mojo_from_view = XrPoseToGfxTransform(xr_view.pose);

  view->geometry->field_of_view = XrFovToMojomFov(xr_view.fov);

  view->viewport =
      gfx::Rect(x_offset, 0, view_config.Properties()[view_index].Width(),
                view_config.Properties()[view_index].Height());

  view->is_first_person_observer =
      view_config.Type() ==
      XR_VIEW_CONFIGURATION_TYPE_SECONDARY_MONO_FIRST_PERSON_OBSERVER_MSFT;

  if (visibility_mask_handler_) {
    visibility_mask_handler_->UpdateVisibilityMaskData(view_config.Type(),
                                                       view_index, view);
  }

  return view;
}

const std::unordered_set<mojom::XRSessionFeature>&
OpenXrApiWrapper::GetEnabledFeatures() const {
  return enabled_features_;
}

std::vector<mojom::XRViewPtr> OpenXrApiWrapper::GetViews() const {
  // Since WebXR expects all views to be defined in a single swapchain texture,
  // we need to compute where in the texture each view begins. Each view is
  // located horizontally one after another, starting with the primary views,
  // followed by the secondary views. x_offset keeps track of where the next
  // view begins.
  uint32_t x_offset = primary_view_config_.Viewport().x();

  std::vector<mojom::XRViewPtr> views;
  for (size_t i = 0; i < primary_view_config_.Views().size(); i++) {
    views.emplace_back(
        CreateView(primary_view_config_, i, GetEyeFromIndex(i), x_offset));
    x_offset += primary_view_config_.Properties()[i].Width();
  }

  if (IsFeatureEnabled(mojom::XRSessionFeature::SECONDARY_VIEWS)) {
    for (const auto& secondary_view_config : secondary_view_configs_) {
      const OpenXrViewConfiguration& view_config = secondary_view_config.second;
      if (view_config.Active()) {
        x_offset = view_config.Viewport().x();
        for (size_t i = 0; i < view_config.Views().size(); i++) {
          views.emplace_back(
              CreateView(view_config, i, mojom::XREye::kNone, x_offset));
          x_offset += view_config.Properties()[i].Width();
        }
      }
    }
  }

  return views;
}

std::vector<mojom::XRViewPtr> OpenXrApiWrapper::GetDefaultViews() const {
  DCHECK(IsInitialized());

  const std::vector<OpenXrViewProperties>& view_properties =
      primary_view_config_.Properties();
  CHECK_EQ(view_properties.size(), kNumPrimaryViews);

  std::vector<mojom::XRViewPtr> views(view_properties.size());
  uint32_t x_offset = 0;

  for (uint32_t i = 0; i < views.size(); i++) {
    views[i] = mojom::XRView::New();
    mojom::XRView* view = views[i].get();

    view->eye = GetEyeFromIndex(i);
    view->viewport = gfx::Rect(x_offset, 0, view_properties[i].Width(),
                               view_properties[i].Height());
    view->geometry = mojom::XRViewGeometry::New();
    view->geometry->field_of_view =
        mojom::VRFieldOfView::New(45.0f, 45.0f, 45.0f, 45.0f);

    x_offset += view_properties[i].Width();
  }

  return views;
}

float OpenXrApiWrapper::RecommendedViewportScale() const {
  float recommended_scale = 1.0f;
  for (const auto& property : primary_view_config_.Properties()) {
    recommended_scale =
        std::min(recommended_scale, property.RecommendedViewportScale());
  }
  return recommended_scale;
}

mojom::VRPosePtr OpenXrApiWrapper::GetViewerPose() const {
  TRACE_EVENT0("xr", "GetViewerPose");
  XrSpaceLocation local_from_viewer = {XR_TYPE_SPACE_LOCATION};
  if (XR_FAILED(xrLocateSpace(view_space_, local_space_,
                              frame_state_.predictedDisplayTime,
                              &local_from_viewer))) {
    // We failed to locate the space, so just return nullptr to indicate that
    // we don't have tracking.
    return nullptr;
  }

  const auto& pose_state = local_from_viewer.locationFlags;
  const bool orientation_valid =
      pose_state & XR_SPACE_LOCATION_ORIENTATION_VALID_BIT;
  const bool orientation_tracked =
      pose_state & XR_SPACE_LOCATION_ORIENTATION_TRACKED_BIT;
  const bool position_valid = pose_state & XR_SPACE_LOCATION_POSITION_VALID_BIT;
  const bool position_tracked =
      pose_state & XR_SPACE_LOCATION_POSITION_TRACKED_BIT;

  // emulated_position indicates when there is a fallback from a fully-tracked
  // (i.e. 6DOF) type case to some form of orientation-only type tracking
  // (i.e. 3DOF/IMU type sensors)
  // Thus we have to make sure orientation is tracked to send up a valid pose;
  // but we can send up a non tracked position, we just have to indicate that it
  // is emulated.
  const bool can_send_orientation = orientation_valid && orientation_tracked;
  const bool can_send_position = position_valid;

  // If we'd end up leaving both pose and orientation unset just return nullptr.
  if (!can_send_orientation && !can_send_position) {
    return nullptr;
  }

  mojom::VRPosePtr pose = mojom::VRPose::New();
  if (can_send_orientation) {
    pose->orientation = gfx::Quaternion(local_from_viewer.pose.orientation.x,
                                        local_from_viewer.pose.orientation.y,
                                        local_from_viewer.pose.orientation.z,
                                        local_from_viewer.pose.orientation.w);
  }

  if (can_send_position) {
    pose->position = gfx::Point3F(local_from_viewer.pose.position.x,
                                  local_from_viewer.pose.position.y,
                                  local_from_viewer.pose.position.z);
  }

  // Position is emulated if it isn't tracked.
  pose->emulated_position = !position_tracked;

  return pose;
}

std::vector<mojom::XRInputSourceStatePtr> OpenXrApiWrapper::GetInputState() {
  return input_helper_->GetInputState(GetPredictedDisplayTime());
}

void OpenXrApiWrapper::OnHideInputSources() {
  input_helper_->OnHideInputSources();
}

void OpenXrApiWrapper::PollFuture(
    XrFutureEXT future,
    base::OnceCallback<void(XrFutureEXT)> on_ready_callback) {
  pending_futures_.emplace(future, std::move(on_ready_callback));
}

void OpenXrApiWrapper::ProcessPendingFutures() {
  if (pending_futures_.empty()) {
    return;
  }

  auto it = pending_futures_.begin();
  while (it != pending_futures_.end()) {
    XrFuturePollInfoEXT poll_info = {XR_TYPE_FUTURE_POLL_INFO_EXT};
    poll_info.future = it->first;
    XrFuturePollResultEXT poll_result = {XR_TYPE_FUTURE_POLL_RESULT_EXT};
    XrResult result = extension_helper_->ExtensionMethods().xrPollFutureEXT(
        instance_, &poll_info, &poll_result);

    if (result == XR_SUCCESS &&
        poll_result.state == XR_FUTURE_STATE_READY_EXT) {
      std::move(it->second).Run(it->first);
      pending_futures_.erase(it++);
    } else if (XR_FAILED(result)) {
      std::move(it->second).Run(XR_NULL_FUTURE_EXT);
      pending_futures_.erase(it++);
    } else {
      it++;
    }
  }
}

void OpenXrApiWrapper::EnsureEventPolling() {
  // Events are usually processed at the beginning of a frame. When frames
  // aren't being requested, this timer loop ensures OpenXR events are
  // occasionally polled while OpenXR is active.
  if (IsInitialized()) {
    if (XR_FAILED(ProcessEvents())) {
      DCHECK(!session_running_);
    }

    // Verify that OpenXR is still active after processing events.
    if (IsInitialized()) {
      base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask(
          FROM_HERE,
          base::BindOnce(&OpenXrApiWrapper::EnsureEventPolling,
                         weak_ptr_factory_.GetWeakPtr()),
          kTimeBetweenPollingEvents);
    }
  }
}

XrResult OpenXrApiWrapper::ProcessEvents() {
  // If we have no instance, we cannot process events. In this case the session
  // has likely already been ended.
  if (!HasInstance()) {
    return XR_ERROR_INSTANCE_LOST;
  }

  ProcessPendingFutures();

  // If we've received an exit gesture from any of the input sources, end the
  // session.
  if (input_helper_ && input_helper_->ReceivedExitGesture()) {
    return ShutdownSession();
  }

  XrEventDataBuffer event_data{XR_TYPE_EVENT_DATA_BUFFER};
  XrResult xr_result = xrPollEvent(instance_, &event_data);

  while (XR_SUCCEEDED(xr_result) && xr_result != XR_EVENT_UNAVAILABLE) {
    if (event_data.type == XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED) {
      XrEventDataSessionStateChanged* session_state_changed =
          reinterpret_cast<XrEventDataSessionStateChanged*>(&event_data);
      // We only have will only have one session and we should make sure the
      // session that is having state_changed event is ours.
      DCHECK(session_state_changed->session == session_);
      SetXrSessionState(session_state_changed->state);
      switch (session_state_changed->state) {
        case XR_SESSION_STATE_READY:
          xr_result = BeginSession();
          break;
        case XR_SESSION_STATE_STOPPING:
          return ShutdownSession();
        case XR_SESSION_STATE_SYNCHRONIZED:
          visibility_changed_callback_.Run(
              device::mojom::XRVisibilityState::HIDDEN);
          break;
        case XR_SESSION_STATE_VISIBLE:
          visibility_changed_callback_.Run(
              device::mojom::XRVisibilityState::VISIBLE_BLURRED);
          break;
        case XR_SESSION_STATE_FOCUSED:
          visibility_changed_callback_.Run(
              device::mojom::XRVisibilityState::VISIBLE);
          break;
        case XR_SESSION_STATE_EXITING:
          Uninitialize();
          return xr_result;
        default:
          break;
      }
    } else if (event_data.type == XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING) {
      DCHECK(session_ != XR_NULL_HANDLE);
      // TODO(https://crbug.com/1335240): Properly handle Instance Loss Pending.
      LOG(ERROR) << "Received Instance Loss Event";
      TRACE_EVENT_INSTANT0("xr", "InstanceLossPendingEvent",
                           TRACE_EVENT_SCOPE_THREAD);
      Uninitialize();
      return XR_ERROR_INSTANCE_LOST;
    } else if (event_data.type ==
               XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING) {
      XrEventDataReferenceSpaceChangePending* reference_space_change_pending =
          reinterpret_cast<XrEventDataReferenceSpaceChangePending*>(
              &event_data);
      DCHECK(reference_space_change_pending->session == session_);
      // TODO(crbug.com/40653515)
      // Currently WMR only throw reference space change event for stage.
      // Other runtimes may decide to do it differently.
      if (reference_space_change_pending->referenceSpaceType ==
          XR_REFERENCE_SPACE_TYPE_STAGE) {
        UpdateStageBounds();
        UpdateLocalFloorSpace();
      } else if (reference_space_change_pending->referenceSpaceType ==
                     XR_REFERENCE_SPACE_TYPE_LOCAL ||
                 reference_space_change_pending->referenceSpaceType ==
                     XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT) {
        UpdateLocalFloorSpace();
      } else if (unbounded_space_provider_ &&
                 reference_space_change_pending->referenceSpaceType ==
                     unbounded_space_provider_->GetType()) {
        // TODO(crbug.com/40653515): Properly handle unbounded reference
        // space change events.
      }
    } else if (event_data.type ==
               XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED) {
      XrEventDataInteractionProfileChanged* interaction_profile_changed =
          reinterpret_cast<XrEventDataInteractionProfileChanged*>(&event_data);
      DCHECK_EQ(interaction_profile_changed->session, session_);
      xr_result = input_helper_->OnInteractionProfileChanged();
    } else if (event_data.type ==
               XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT) {
      if (scene_understanding_manager_) {
        scene_understanding_manager_->OnDiscoveryRecommended(
            reinterpret_cast<const XrEventDataSpatialDiscoveryRecommendedEXT*>(
                &event_data));
      }
    } else if (event_data.type ==
               XR_TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR) {
      auto* mask_changed_event =
          reinterpret_cast<XrEventDataVisibilityMaskChangedKHR*>(&event_data);
      if (mask_changed_event->session != session_) {
        continue;
      }
      if (visibility_mask_handler_) {
        visibility_mask_handler_->OnVisibilityMaskChanged(*mask_changed_event);
      }
    } else {
      DVLOG(1) << __func__ << " Unhandled event type: " << event_data.type;
      TRACE_EVENT_INSTANT1("xr", "UnandledXrEvent", TRACE_EVENT_SCOPE_THREAD,
                           "type", event_data.type);
    }

    if (XR_FAILED(xr_result)) {
      TRACE_EVENT_INSTANT2("xr", "EventProcessingFailed",
                           TRACE_EVENT_SCOPE_THREAD, "type", event_data.type,
                           "xr_result", xr_result);
      Uninitialize();
      return xr_result;
    }

    event_data.type = XR_TYPE_EVENT_DATA_BUFFER;
    xr_result = xrPollEvent(instance_, &event_data);
  }

  // This catches the error where we failed to poll events only.
  if (XR_FAILED(xr_result)) {
    TRACE_EVENT_INSTANT1("xr", "EventPollingFailed", TRACE_EVENT_SCOPE_THREAD,
                         "xr_result", xr_result);
    Uninitialize();
  }
  return xr_result;
}

uint32_t OpenXrApiWrapper::GetRecommendedSwapchainSampleCount() const {
  DCHECK(IsInitialized());

  // TODO(crbug.com/444681345) : Add the recommended sample count for the mono
  // layout.
  return std::ranges::min_element(
             primary_view_config_.Properties(), {},
             [](const OpenXrViewProperties& view) {
               return view.RecommendedSwapchainSampleCount();
             })
      ->RecommendedSwapchainSampleCount();
}

bool OpenXrApiWrapper::CanEnableAntiAliasing() const {
  return primary_view_config_.CanEnableAntiAliasing();
}

// stage bounds is fixed unless we received event
// XrEventDataReferenceSpaceChangePending
void OpenXrApiWrapper::UpdateStageBounds() {
  DCHECK(HasSession());

  // We don't check for any feature enablement here because we'll have only
  // created the bounds_provider_ if the relevant features were enabled.
  if (bounds_provider_) {
    stage_bounds_ = bounds_provider_->GetStageBounds();
  }
}

bool OpenXrApiWrapper::GetStageParameters(
    std::vector<gfx::Point3F>& stage_bounds,
    gfx::Transform& local_from_stage) {
  DCHECK(HasSession());

  // We should only supply stage parameters if we are supposed to provide
  // information about the bounded reference spaces.
  if (!IsFeatureEnabled(mojom::XRSessionFeature::REF_SPACE_BOUNDED_FLOOR)) {
    return false;
  }

  if (!HasSpace(XR_REFERENCE_SPACE_TYPE_LOCAL) ||
      !HasSpace(XR_REFERENCE_SPACE_TYPE_STAGE)) {
    return false;
  }

  std::optional<gfx::Transform> maybe_local_from_stage = GetLocalFromStage();
  if (!maybe_local_from_stage) {
    return false;
  }

  stage_bounds = stage_bounds_;
  local_from_stage = maybe_local_from_stage.value();

  return true;
}

std::optional<gfx::Transform> OpenXrApiWrapper::GetLocalFromFloor() {
  if (!IsFeatureEnabled(
          device::mojom::XRSessionFeature::REF_SPACE_LOCAL_FLOOR)) {
    return std::nullopt;
  }

  if (!HasSpace(XR_REFERENCE_SPACE_TYPE_LOCAL)) {
    return std::nullopt;
  }

  // Even if we're emulating the local floor space, it should exist.
  if (!HasSpace(XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT)) {
    return std::nullopt;
  }

  return GetBaseSpaceFromSpace(mojom::XRReferenceSpaceType::kLocal,
                               mojom::XRReferenceSpaceType::kLocalFloor);
}

std::optional<gfx::Transform> OpenXrApiWrapper::GetLocalFromStage() {
  if (!HasSpace(XR_REFERENCE_SPACE_TYPE_LOCAL)) {
    return std::nullopt;
  }

  if (!HasSpace(XR_REFERENCE_SPACE_TYPE_STAGE)) {
    return std::nullopt;
  }

  return GetBaseSpaceFromSpace(mojom::XRReferenceSpaceType::kLocal,
                               mojom::XRReferenceSpaceType::kBoundedFloor);
}

std::optional<gfx::Transform> OpenXrApiWrapper::GetBaseSpaceFromSpace(
    mojom::XRReferenceSpaceType base_space_type,
    mojom::XRReferenceSpaceType space_type) {
  TRACE_EVENT2("xr", "GetBaseSpaceFromSpace", "base_space", base_space_type,
               "space", space_type);
  auto base_space = GetReferenceSpace(base_space_type);
  auto space = GetReferenceSpace(space_type);
  XrSpaceLocation base_space_from_space_location = {XR_TYPE_SPACE_LOCATION};
  if (XR_FAILED(xrLocateSpace(space, base_space,
                              frame_state_.predictedDisplayTime,
                              &base_space_from_space_location)) ||
      !IsPoseValid(base_space_from_space_location.locationFlags)) {
    return std::nullopt;
  }

  // Convert the orientation and translation given by runtime into a
  // transformation matrix.
  gfx::DecomposedTransform base_space_from_space_decomp;
  base_space_from_space_decomp.quaternion =
      gfx::Quaternion(base_space_from_space_location.pose.orientation.x,
                      base_space_from_space_location.pose.orientation.y,
                      base_space_from_space_location.pose.orientation.z,
                      base_space_from_space_location.pose.orientation.w);
  base_space_from_space_decomp.translate[0] =
      base_space_from_space_location.pose.position.x;
  base_space_from_space_decomp.translate[1] =
      base_space_from_space_location.pose.position.y;
  base_space_from_space_decomp.translate[2] =
      base_space_from_space_location.pose.position.z;

  gfx::Transform base_space_from_space =
      gfx::Transform::Compose(base_space_from_space_decomp);

  // TODO(crbug.com/41495208): Check for crash dumps.
  std::array<float, 16> transform_data;
  base_space_from_space.GetColMajorF(transform_data);
  bool contains_nan = std::ranges::any_of(
      transform_data, [](const float f) { return std::isnan(f); });

  if (contains_nan) {
    // It's unclear if this could be tripping on every frame, but reporting once
    // per day per user (the default throttling) should be sufficient for future
    // investigation.
    base::debug::DumpWithoutCrashing();
    return std::nullopt;
  }
  return base_space_from_space;
}

void OpenXrApiWrapper::SetXrSessionState(XrSessionState new_state) {
  if (session_state_ == new_state)
    return;

  const char* old_state_name = GetXrSessionStateName(session_state_);
  const char* new_state_name = GetXrSessionStateName(new_state);
  DVLOG(1) << __func__ << " Transitioning from: " << old_state_name
           << " to: " << new_state_name;

  if (session_state_ != XR_SESSION_STATE_UNKNOWN) {
    TRACE_EVENT_NESTABLE_ASYNC_END1("xr", "XRSessionState", this, "state",
                                    old_state_name);
  }

  if (new_state != XR_SESSION_STATE_UNKNOWN) {
    TRACE_EVENT_NESTABLE_ASYNC_BEGIN1("xr", "XRSessionState", this, "state",
                                      new_state_name);
  }

  session_state_ = new_state;
}

VRTestHook* OpenXrApiWrapper::test_hook_ = nullptr;
ServiceTestHook* OpenXrApiWrapper::service_test_hook_ = nullptr;
void OpenXrApiWrapper::SetTestHook(VRTestHook* hook) {
  // This may be called from any thread - tests are responsible for
  // maintaining thread safety, typically by not changing the test hook
  // while presenting.
  test_hook_ = hook;
  if (service_test_hook_) {
    service_test_hook_->SetTestHook(test_hook_);
  }
}

}  // namespace device