win-Debug/gen/media/capture/mojom/image_capture.mojom-blink.h

// media/capture/mojom/image_capture.mojom-blink.h is auto generated by mojom_bindings_generator.py, do not edit

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

#ifndef MEDIA_CAPTURE_MOJOM_IMAGE_CAPTURE_MOJOM_BLINK_H_
#define MEDIA_CAPTURE_MOJOM_IMAGE_CAPTURE_MOJOM_BLINK_H_

#include <stdint.h>

#include <limits>
#include <optional>
#include <type_traits>
#include <utility>

#include "base/types/cxx23_to_underlying.h"
#include "mojo/public/cpp/bindings/clone_traits.h"
#include "mojo/public/cpp/bindings/equals_traits.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"
#include "mojo/public/cpp/bindings/struct_ptr.h"
#include "mojo/public/cpp/bindings/struct_traits.h"
#include "mojo/public/cpp/bindings/union_traits.h"

#include "third_party/perfetto/include/perfetto/tracing/traced_value_forward.h"

#include "media/capture/mojom/image_capture.mojom-features.h"
#include "media/capture/mojom/image_capture.mojom-shared.h"
#include "media/capture/mojom/image_capture.mojom-blink-forward.h"

#include "mojo/public/cpp/bindings/lib/wtf_clone_equals_util.h"
#include "mojo/public/cpp/bindings/lib/wtf_hash_util.h"
#include "third_party/blink/renderer/platform/wtf/hash_functions.h"
#include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"

#include "mojo/public/cpp/bindings/lib/control_message_handler.h"
#include "mojo/public/cpp/bindings/lib/message_size_estimator.h"
#include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h"



#ifdef KYTHE_IS_RUNNING
#pragma kythe_inline_metadata "Metadata comment"
#endif


namespace media::mojom::blink {

class ImageCaptureProxy;

template <typename ImplRefTraits>
class ImageCaptureStub;

class ImageCaptureRequestValidator;
class ImageCaptureResponseValidator;


// @generated_from: media.mojom.ImageCapture
class ImageCapture
    : public ImageCaptureInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();

  static const char Name_[];
  static IPCStableHashFunction MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = ImageCaptureInterfaceBase;
  using Proxy_ = ImageCaptureProxy;

  template <typename ImplRefTraits>
  using Stub_ = ImageCaptureStub<ImplRefTraits>;

  using RequestValidator_ = ImageCaptureRequestValidator;
  using ResponseValidator_ = ImageCaptureResponseValidator;
  enum MethodMinVersions : uint32_t {
    kGetPhotoStateMinVersion = 0,
    kSetPhotoOptionsMinVersion = 0,
    kTakePhotoMinVersion = 0,
  };

// crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK
// with not having this data in traces there.
#if !BUILDFLAG(IS_FUCHSIA)
  struct GetPhotoState_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetPhotoOptions_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct TakePhoto_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~ImageCapture() = default;


  using GetPhotoStateCallback = base::OnceCallback<void(PhotoStatePtr)>;
  
// @generated_from: media.mojom.ImageCapture.GetPhotoState
  virtual void GetPhotoState(const WTF::String& source_id, GetPhotoStateCallback callback) = 0;


  using SetPhotoOptionsCallback = base::OnceCallback<void(bool)>;
  
// @generated_from: media.mojom.ImageCapture.SetPhotoOptions
  virtual void SetPhotoOptions(const WTF::String& source_id, PhotoSettingsPtr settings, SetPhotoOptionsCallback callback) = 0;


  using TakePhotoCallback = base::OnceCallback<void(BlobPtr)>;
  
// @generated_from: media.mojom.ImageCapture.TakePhoto
  virtual void TakePhoto(const WTF::String& source_id, TakePhotoCallback callback) = 0;
};



// @generated_from: media.mojom.ImageCapture
class  ImageCaptureProxy
    : public ImageCapture {
 public:
  using InterfaceType = ImageCapture;

  explicit ImageCaptureProxy(mojo::MessageReceiverWithResponder* receiver);
  
// @generated_from: media.mojom.ImageCapture.GetPhotoState
  void GetPhotoState(const WTF::String& source_id, GetPhotoStateCallback callback) final;
  
// @generated_from: media.mojom.ImageCapture.SetPhotoOptions
  void SetPhotoOptions(const WTF::String& source_id, PhotoSettingsPtr settings, SetPhotoOptionsCallback callback) final;
  
// @generated_from: media.mojom.ImageCapture.TakePhoto
  void TakePhoto(const WTF::String& source_id, TakePhotoCallback callback) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};
class  ImageCaptureStubDispatch {
 public:
  static bool Accept(ImageCapture* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      ImageCapture* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

template <typename ImplRefTraits =
              mojo::RawPtrImplRefTraits<ImageCapture>>
class ImageCaptureStub
    : public mojo::MessageReceiverWithResponderStatus {
 public:
  using ImplPointerType = typename ImplRefTraits::PointerType;

  ImageCaptureStub() = default;
  ~ImageCaptureStub() override = default;

  void set_sink(ImplPointerType sink) { sink_ = std::move(sink); }
  ImplPointerType& sink() { return sink_; }

  bool Accept(mojo::Message* message) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return ImageCaptureStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return ImageCaptureStubDispatch::AcceptWithResponder(
        ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
  }

 private:
  ImplPointerType sink_;
};
class  ImageCaptureRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  ImageCaptureResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};





// @generated_from: media.mojom.Range
class  Range {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<Range, T>::value>;
  using DataView = RangeDataView;
  using Data_ = internal::Range_Data;

  template <typename... Args>
  static RangePtr New(Args&&... args) {
    return RangePtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static RangePtr From(const U& u) {
    return mojo::TypeConverter<RangePtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, Range>::Convert(*this);
  }


  Range();

  Range(
      double max,
      double min,
      double current,
      double step);


  ~Range();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = RangePtr>
  RangePtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, Range::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, Range::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, Range::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  size_t Hash(size_t seed) const;
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        Range::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        Range::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::Range_UnserializedMessageContext<
            UserType, Range::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<Range::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return Range::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::Range_UnserializedMessageContext<
            UserType, Range::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<Range::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: media.mojom.Range.max
  double max;
  
// @generated_from: media.mojom.Range.min
  double min;
  
// @generated_from: media.mojom.Range.current
  double current;
  
// @generated_from: media.mojom.Range.step
  double step;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, Range::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, Range::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, Range::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, Range::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}






// @generated_from: media.mojom.Point2D
class  Point2D {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<Point2D, T>::value>;
  using DataView = Point2DDataView;
  using Data_ = internal::Point2D_Data;

  template <typename... Args>
  static Point2DPtr New(Args&&... args) {
    return Point2DPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static Point2DPtr From(const U& u) {
    return mojo::TypeConverter<Point2DPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, Point2D>::Convert(*this);
  }


  Point2D();

  Point2D(
      double x,
      double y);


  ~Point2D();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = Point2DPtr>
  Point2DPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, Point2D::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, Point2D::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, Point2D::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  size_t Hash(size_t seed) const;
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        Point2D::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        Point2D::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::Point2D_UnserializedMessageContext<
            UserType, Point2D::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<Point2D::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return Point2D::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::Point2D_UnserializedMessageContext<
            UserType, Point2D::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<Point2D::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: media.mojom.Point2D.x
  double x;
  
// @generated_from: media.mojom.Point2D.y
  double y;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, Point2D::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, Point2D::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, Point2D::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, Point2D::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}










// @generated_from: media.mojom.PhotoState
class  PhotoState {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<PhotoState, T>::value>;
  using DataView = PhotoStateDataView;
  using Data_ = internal::PhotoState_Data;

  template <typename... Args>
  static PhotoStatePtr New(Args&&... args) {
    return PhotoStatePtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static PhotoStatePtr From(const U& u) {
    return mojo::TypeConverter<PhotoStatePtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, PhotoState>::Convert(*this);
  }


  PhotoState();

  PhotoState(
      WTF::Vector<MeteringMode> supported_white_balance_modes,
      MeteringMode current_white_balance_mode,
      WTF::Vector<MeteringMode> supported_exposure_modes,
      MeteringMode current_exposure_mode,
      WTF::Vector<MeteringMode> supported_focus_modes,
      MeteringMode current_focus_mode,
      WTF::Vector<Point2DPtr> points_of_interest,
      RangePtr exposure_compensation,
      RangePtr exposure_time,
      RangePtr color_temperature,
      RangePtr iso,
      RangePtr brightness,
      RangePtr contrast,
      RangePtr saturation,
      RangePtr sharpness,
      RangePtr focus_distance,
      RangePtr pan,
      RangePtr tilt,
      RangePtr zoom,
      bool supports_torch,
      bool torch,
      RedEyeReduction red_eye_reduction,
      RangePtr height,
      RangePtr width,
      WTF::Vector<FillLightMode> fill_light_mode);

  PhotoState(
      WTF::Vector<MeteringMode> supported_white_balance_modes,
      MeteringMode current_white_balance_mode,
      WTF::Vector<MeteringMode> supported_exposure_modes,
      MeteringMode current_exposure_mode,
      WTF::Vector<MeteringMode> supported_focus_modes,
      MeteringMode current_focus_mode,
      WTF::Vector<Point2DPtr> points_of_interest,
      RangePtr exposure_compensation,
      RangePtr exposure_time,
      RangePtr color_temperature,
      RangePtr iso,
      RangePtr brightness,
      RangePtr contrast,
      RangePtr saturation,
      RangePtr sharpness,
      RangePtr focus_distance,
      RangePtr pan,
      RangePtr tilt,
      RangePtr zoom,
      bool supports_torch,
      bool torch,
      RedEyeReduction red_eye_reduction,
      RangePtr height,
      RangePtr width,
      WTF::Vector<FillLightMode> fill_light_mode,
      std::optional<WTF::Vector<BackgroundBlurMode>> supported_background_blur_modes,
      BackgroundBlurMode background_blur_mode);

  PhotoState(
      WTF::Vector<MeteringMode> supported_white_balance_modes,
      MeteringMode current_white_balance_mode,
      WTF::Vector<MeteringMode> supported_exposure_modes,
      MeteringMode current_exposure_mode,
      WTF::Vector<MeteringMode> supported_focus_modes,
      MeteringMode current_focus_mode,
      WTF::Vector<Point2DPtr> points_of_interest,
      RangePtr exposure_compensation,
      RangePtr exposure_time,
      RangePtr color_temperature,
      RangePtr iso,
      RangePtr brightness,
      RangePtr contrast,
      RangePtr saturation,
      RangePtr sharpness,
      RangePtr focus_distance,
      RangePtr pan,
      RangePtr tilt,
      RangePtr zoom,
      bool supports_torch,
      bool torch,
      RedEyeReduction red_eye_reduction,
      RangePtr height,
      RangePtr width,
      WTF::Vector<FillLightMode> fill_light_mode,
      std::optional<WTF::Vector<BackgroundBlurMode>> supported_background_blur_modes,
      BackgroundBlurMode background_blur_mode,
      std::optional<WTF::Vector<MeteringMode>> supported_face_framing_modes,
      MeteringMode current_face_framing_mode);

  PhotoState(
      WTF::Vector<MeteringMode> supported_white_balance_modes,
      MeteringMode current_white_balance_mode,
      WTF::Vector<MeteringMode> supported_exposure_modes,
      MeteringMode current_exposure_mode,
      WTF::Vector<MeteringMode> supported_focus_modes,
      MeteringMode current_focus_mode,
      WTF::Vector<Point2DPtr> points_of_interest,
      RangePtr exposure_compensation,
      RangePtr exposure_time,
      RangePtr color_temperature,
      RangePtr iso,
      RangePtr brightness,
      RangePtr contrast,
      RangePtr saturation,
      RangePtr sharpness,
      RangePtr focus_distance,
      RangePtr pan,
      RangePtr tilt,
      RangePtr zoom,
      bool supports_torch,
      bool torch,
      RedEyeReduction red_eye_reduction,
      RangePtr height,
      RangePtr width,
      WTF::Vector<FillLightMode> fill_light_mode,
      std::optional<WTF::Vector<BackgroundBlurMode>> supported_background_blur_modes,
      BackgroundBlurMode background_blur_mode,
      std::optional<WTF::Vector<MeteringMode>> supported_face_framing_modes,
      MeteringMode current_face_framing_mode,
      std::optional<WTF::Vector<EyeGazeCorrectionMode>> supported_eye_gaze_correction_modes,
      EyeGazeCorrectionMode current_eye_gaze_correction_mode);

PhotoState(const PhotoState&) = delete;
PhotoState& operator=(const PhotoState&) = delete;

  ~PhotoState();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = PhotoStatePtr>
  PhotoStatePtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, PhotoState::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, PhotoState::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, PhotoState::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        PhotoState::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        PhotoState::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::PhotoState_UnserializedMessageContext<
            UserType, PhotoState::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<PhotoState::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return PhotoState::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::PhotoState_UnserializedMessageContext<
            UserType, PhotoState::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<PhotoState::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: media.mojom.PhotoState.supported_white_balance_modes
  WTF::Vector<MeteringMode> supported_white_balance_modes;
  
// @generated_from: media.mojom.PhotoState.current_white_balance_mode
  MeteringMode current_white_balance_mode;
  
// @generated_from: media.mojom.PhotoState.supported_exposure_modes
  WTF::Vector<MeteringMode> supported_exposure_modes;
  
// @generated_from: media.mojom.PhotoState.current_exposure_mode
  MeteringMode current_exposure_mode;
  
// @generated_from: media.mojom.PhotoState.supported_focus_modes
  WTF::Vector<MeteringMode> supported_focus_modes;
  
// @generated_from: media.mojom.PhotoState.current_focus_mode
  MeteringMode current_focus_mode;
  
// @generated_from: media.mojom.PhotoState.points_of_interest
  WTF::Vector<Point2DPtr> points_of_interest;
  
// @generated_from: media.mojom.PhotoState.exposure_compensation
  RangePtr exposure_compensation;
  
// @generated_from: media.mojom.PhotoState.exposure_time
  RangePtr exposure_time;
  
// @generated_from: media.mojom.PhotoState.color_temperature
  RangePtr color_temperature;
  
// @generated_from: media.mojom.PhotoState.iso
  RangePtr iso;
  
// @generated_from: media.mojom.PhotoState.brightness
  RangePtr brightness;
  
// @generated_from: media.mojom.PhotoState.contrast
  RangePtr contrast;
  
// @generated_from: media.mojom.PhotoState.saturation
  RangePtr saturation;
  
// @generated_from: media.mojom.PhotoState.sharpness
  RangePtr sharpness;
  
// @generated_from: media.mojom.PhotoState.focus_distance
  RangePtr focus_distance;
  
// @generated_from: media.mojom.PhotoState.pan
  RangePtr pan;
  
// @generated_from: media.mojom.PhotoState.tilt
  RangePtr tilt;
  
// @generated_from: media.mojom.PhotoState.zoom
  RangePtr zoom;
  
// @generated_from: media.mojom.PhotoState.supports_torch
  bool supports_torch;
  
// @generated_from: media.mojom.PhotoState.torch
  bool torch;
  
// @generated_from: media.mojom.PhotoState.red_eye_reduction
  RedEyeReduction red_eye_reduction;
  
// @generated_from: media.mojom.PhotoState.height
  RangePtr height;
  
// @generated_from: media.mojom.PhotoState.width
  RangePtr width;
  
// @generated_from: media.mojom.PhotoState.fill_light_mode
  WTF::Vector<FillLightMode> fill_light_mode;
  
// @generated_from: media.mojom.PhotoState.supported_background_blur_modes
  std::optional<WTF::Vector<BackgroundBlurMode>> supported_background_blur_modes;
  
// @generated_from: media.mojom.PhotoState.background_blur_mode
  BackgroundBlurMode background_blur_mode;
  
// @generated_from: media.mojom.PhotoState.supported_face_framing_modes
  std::optional<WTF::Vector<MeteringMode>> supported_face_framing_modes;
  
// @generated_from: media.mojom.PhotoState.current_face_framing_mode
  MeteringMode current_face_framing_mode;
  
// @generated_from: media.mojom.PhotoState.supported_eye_gaze_correction_modes
  std::optional<WTF::Vector<EyeGazeCorrectionMode>> supported_eye_gaze_correction_modes;
  
// @generated_from: media.mojom.PhotoState.current_eye_gaze_correction_mode
  EyeGazeCorrectionMode current_eye_gaze_correction_mode;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, PhotoState::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, PhotoState::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, PhotoState::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, PhotoState::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}






// @generated_from: media.mojom.PhotoSettings
class  PhotoSettings {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<PhotoSettings, T>::value>;
  using DataView = PhotoSettingsDataView;
  using Data_ = internal::PhotoSettings_Data;

  template <typename... Args>
  static PhotoSettingsPtr New(Args&&... args) {
    return PhotoSettingsPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static PhotoSettingsPtr From(const U& u) {
    return mojo::TypeConverter<PhotoSettingsPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, PhotoSettings>::Convert(*this);
  }


  PhotoSettings();

  PhotoSettings(
      bool has_white_balance_mode,
      MeteringMode white_balance_mode,
      bool has_exposure_mode,
      MeteringMode exposure_mode,
      bool has_focus_mode,
      MeteringMode focus_mode,
      WTF::Vector<Point2DPtr> points_of_interest,
      bool has_exposure_compensation,
      double exposure_compensation,
      bool has_exposure_time,
      double exposure_time,
      bool has_color_temperature,
      double color_temperature,
      bool has_iso,
      double iso,
      bool has_brightness,
      double brightness,
      bool has_contrast,
      double contrast,
      bool has_saturation,
      double saturation,
      bool has_sharpness,
      double sharpness,
      bool has_focus_distance,
      double focus_distance,
      bool has_pan,
      double pan,
      bool has_tilt,
      double tilt,
      bool has_zoom,
      double zoom,
      bool has_torch,
      bool torch,
      bool has_fill_light_mode,
      FillLightMode fill_light_mode,
      bool has_width,
      double width,
      bool has_height,
      double height,
      bool has_red_eye_reduction,
      bool red_eye_reduction);

  PhotoSettings(
      bool has_white_balance_mode,
      MeteringMode white_balance_mode,
      bool has_exposure_mode,
      MeteringMode exposure_mode,
      bool has_focus_mode,
      MeteringMode focus_mode,
      WTF::Vector<Point2DPtr> points_of_interest,
      bool has_exposure_compensation,
      double exposure_compensation,
      bool has_exposure_time,
      double exposure_time,
      bool has_color_temperature,
      double color_temperature,
      bool has_iso,
      double iso,
      bool has_brightness,
      double brightness,
      bool has_contrast,
      double contrast,
      bool has_saturation,
      double saturation,
      bool has_sharpness,
      double sharpness,
      bool has_focus_distance,
      double focus_distance,
      bool has_pan,
      double pan,
      bool has_tilt,
      double tilt,
      bool has_zoom,
      double zoom,
      bool has_torch,
      bool torch,
      bool has_fill_light_mode,
      FillLightMode fill_light_mode,
      bool has_width,
      double width,
      bool has_height,
      double height,
      bool has_red_eye_reduction,
      bool red_eye_reduction,
      bool has_background_blur_mode,
      BackgroundBlurMode background_blur_mode);

  PhotoSettings(
      bool has_white_balance_mode,
      MeteringMode white_balance_mode,
      bool has_exposure_mode,
      MeteringMode exposure_mode,
      bool has_focus_mode,
      MeteringMode focus_mode,
      WTF::Vector<Point2DPtr> points_of_interest,
      bool has_exposure_compensation,
      double exposure_compensation,
      bool has_exposure_time,
      double exposure_time,
      bool has_color_temperature,
      double color_temperature,
      bool has_iso,
      double iso,
      bool has_brightness,
      double brightness,
      bool has_contrast,
      double contrast,
      bool has_saturation,
      double saturation,
      bool has_sharpness,
      double sharpness,
      bool has_focus_distance,
      double focus_distance,
      bool has_pan,
      double pan,
      bool has_tilt,
      double tilt,
      bool has_zoom,
      double zoom,
      bool has_torch,
      bool torch,
      bool has_fill_light_mode,
      FillLightMode fill_light_mode,
      bool has_width,
      double width,
      bool has_height,
      double height,
      bool has_red_eye_reduction,
      bool red_eye_reduction,
      bool has_background_blur_mode,
      BackgroundBlurMode background_blur_mode,
      bool has_face_framing_mode,
      MeteringMode face_framing_mode);

  PhotoSettings(
      bool has_white_balance_mode,
      MeteringMode white_balance_mode,
      bool has_exposure_mode,
      MeteringMode exposure_mode,
      bool has_focus_mode,
      MeteringMode focus_mode,
      WTF::Vector<Point2DPtr> points_of_interest,
      bool has_exposure_compensation,
      double exposure_compensation,
      bool has_exposure_time,
      double exposure_time,
      bool has_color_temperature,
      double color_temperature,
      bool has_iso,
      double iso,
      bool has_brightness,
      double brightness,
      bool has_contrast,
      double contrast,
      bool has_saturation,
      double saturation,
      bool has_sharpness,
      double sharpness,
      bool has_focus_distance,
      double focus_distance,
      bool has_pan,
      double pan,
      bool has_tilt,
      double tilt,
      bool has_zoom,
      double zoom,
      bool has_torch,
      bool torch,
      bool has_fill_light_mode,
      FillLightMode fill_light_mode,
      bool has_width,
      double width,
      bool has_height,
      double height,
      bool has_red_eye_reduction,
      bool red_eye_reduction,
      bool has_background_blur_mode,
      BackgroundBlurMode background_blur_mode,
      bool has_face_framing_mode,
      MeteringMode face_framing_mode,
      std::optional<EyeGazeCorrectionMode> eye_gaze_correction_mode);

PhotoSettings(const PhotoSettings&) = delete;
PhotoSettings& operator=(const PhotoSettings&) = delete;

  ~PhotoSettings();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = PhotoSettingsPtr>
  PhotoSettingsPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, PhotoSettings::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, PhotoSettings::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, PhotoSettings::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        PhotoSettings::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        PhotoSettings::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::PhotoSettings_UnserializedMessageContext<
            UserType, PhotoSettings::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<PhotoSettings::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return PhotoSettings::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::PhotoSettings_UnserializedMessageContext<
            UserType, PhotoSettings::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<PhotoSettings::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: media.mojom.PhotoSettings.has_white_balance_mode
  bool has_white_balance_mode;
  
// @generated_from: media.mojom.PhotoSettings.white_balance_mode
  MeteringMode white_balance_mode;
  
// @generated_from: media.mojom.PhotoSettings.has_exposure_mode
  bool has_exposure_mode;
  
// @generated_from: media.mojom.PhotoSettings.exposure_mode
  MeteringMode exposure_mode;
  
// @generated_from: media.mojom.PhotoSettings.has_focus_mode
  bool has_focus_mode;
  
// @generated_from: media.mojom.PhotoSettings.focus_mode
  MeteringMode focus_mode;
  
// @generated_from: media.mojom.PhotoSettings.points_of_interest
  WTF::Vector<Point2DPtr> points_of_interest;
  
// @generated_from: media.mojom.PhotoSettings.has_exposure_compensation
  bool has_exposure_compensation;
  
// @generated_from: media.mojom.PhotoSettings.exposure_compensation
  double exposure_compensation;
  
// @generated_from: media.mojom.PhotoSettings.has_exposure_time
  bool has_exposure_time;
  
// @generated_from: media.mojom.PhotoSettings.exposure_time
  double exposure_time;
  
// @generated_from: media.mojom.PhotoSettings.has_color_temperature
  bool has_color_temperature;
  
// @generated_from: media.mojom.PhotoSettings.color_temperature
  double color_temperature;
  
// @generated_from: media.mojom.PhotoSettings.has_iso
  bool has_iso;
  
// @generated_from: media.mojom.PhotoSettings.iso
  double iso;
  
// @generated_from: media.mojom.PhotoSettings.has_brightness
  bool has_brightness;
  
// @generated_from: media.mojom.PhotoSettings.brightness
  double brightness;
  
// @generated_from: media.mojom.PhotoSettings.has_contrast
  bool has_contrast;
  
// @generated_from: media.mojom.PhotoSettings.contrast
  double contrast;
  
// @generated_from: media.mojom.PhotoSettings.has_saturation
  bool has_saturation;
  
// @generated_from: media.mojom.PhotoSettings.saturation
  double saturation;
  
// @generated_from: media.mojom.PhotoSettings.has_sharpness
  bool has_sharpness;
  
// @generated_from: media.mojom.PhotoSettings.sharpness
  double sharpness;
  
// @generated_from: media.mojom.PhotoSettings.has_focus_distance
  bool has_focus_distance;
  
// @generated_from: media.mojom.PhotoSettings.focus_distance
  double focus_distance;
  
// @generated_from: media.mojom.PhotoSettings.has_pan
  bool has_pan;
  
// @generated_from: media.mojom.PhotoSettings.pan
  double pan;
  
// @generated_from: media.mojom.PhotoSettings.has_tilt
  bool has_tilt;
  
// @generated_from: media.mojom.PhotoSettings.tilt
  double tilt;
  
// @generated_from: media.mojom.PhotoSettings.has_zoom
  bool has_zoom;
  
// @generated_from: media.mojom.PhotoSettings.zoom
  double zoom;
  
// @generated_from: media.mojom.PhotoSettings.has_torch
  bool has_torch;
  
// @generated_from: media.mojom.PhotoSettings.torch
  bool torch;
  
// @generated_from: media.mojom.PhotoSettings.has_fill_light_mode
  bool has_fill_light_mode;
  
// @generated_from: media.mojom.PhotoSettings.fill_light_mode
  FillLightMode fill_light_mode;
  
// @generated_from: media.mojom.PhotoSettings.has_width
  bool has_width;
  
// @generated_from: media.mojom.PhotoSettings.width
  double width;
  
// @generated_from: media.mojom.PhotoSettings.has_height
  bool has_height;
  
// @generated_from: media.mojom.PhotoSettings.height
  double height;
  
// @generated_from: media.mojom.PhotoSettings.has_red_eye_reduction
  bool has_red_eye_reduction;
  
// @generated_from: media.mojom.PhotoSettings.red_eye_reduction
  bool red_eye_reduction;
  
// @generated_from: media.mojom.PhotoSettings.has_background_blur_mode
  bool has_background_blur_mode;
  
// @generated_from: media.mojom.PhotoSettings.background_blur_mode
  BackgroundBlurMode background_blur_mode;
  
// @generated_from: media.mojom.PhotoSettings.has_face_framing_mode
  bool has_face_framing_mode;
  
// @generated_from: media.mojom.PhotoSettings.face_framing_mode
  MeteringMode face_framing_mode;
  
// @generated_from: media.mojom.PhotoSettings.eye_gaze_correction_mode
  std::optional<EyeGazeCorrectionMode> eye_gaze_correction_mode;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, PhotoSettings::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, PhotoSettings::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, PhotoSettings::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, PhotoSettings::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





// @generated_from: media.mojom.Blob
class  Blob {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<Blob, T>::value>;
  using DataView = BlobDataView;
  using Data_ = internal::Blob_Data;

  template <typename... Args>
  static BlobPtr New(Args&&... args) {
    return BlobPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static BlobPtr From(const U& u) {
    return mojo::TypeConverter<BlobPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, Blob>::Convert(*this);
  }


  Blob();

  Blob(
      const WTF::String& mime_type,
      WTF::Vector<uint8_t> data);


  ~Blob();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = BlobPtr>
  BlobPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, Blob::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, Blob::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, Blob::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        Blob::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        Blob::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::Blob_UnserializedMessageContext<
            UserType, Blob::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<Blob::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return Blob::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::Blob_UnserializedMessageContext<
            UserType, Blob::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<Blob::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: media.mojom.Blob.mime_type
  WTF::String mime_type;
  
// @generated_from: media.mojom.Blob.data
  WTF::Vector<uint8_t> data;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, Blob::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, Blob::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, Blob::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, Blob::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}

template <typename StructPtrType>
RangePtr Range::Clone() const {
  return New(
      mojo::Clone(max),
      mojo::Clone(min),
      mojo::Clone(current),
      mojo::Clone(step)
  );
}

template <typename T, Range::EnableIfSame<T>*>
bool Range::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->max, other_struct.max))
    return false;
  if (!mojo::Equals(this->min, other_struct.min))
    return false;
  if (!mojo::Equals(this->current, other_struct.current))
    return false;
  if (!mojo::Equals(this->step, other_struct.step))
    return false;
  return true;
}

template <typename T, Range::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.max < rhs.max)
    return true;
  if (rhs.max < lhs.max)
    return false;
  if (lhs.min < rhs.min)
    return true;
  if (rhs.min < lhs.min)
    return false;
  if (lhs.current < rhs.current)
    return true;
  if (rhs.current < lhs.current)
    return false;
  if (lhs.step < rhs.step)
    return true;
  if (rhs.step < lhs.step)
    return false;
  return false;
}
template <typename StructPtrType>
PhotoStatePtr PhotoState::Clone() const {
  return New(
      mojo::Clone(supported_white_balance_modes),
      mojo::Clone(current_white_balance_mode),
      mojo::Clone(supported_exposure_modes),
      mojo::Clone(current_exposure_mode),
      mojo::Clone(supported_focus_modes),
      mojo::Clone(current_focus_mode),
      mojo::Clone(points_of_interest),
      mojo::Clone(exposure_compensation),
      mojo::Clone(exposure_time),
      mojo::Clone(color_temperature),
      mojo::Clone(iso),
      mojo::Clone(brightness),
      mojo::Clone(contrast),
      mojo::Clone(saturation),
      mojo::Clone(sharpness),
      mojo::Clone(focus_distance),
      mojo::Clone(pan),
      mojo::Clone(tilt),
      mojo::Clone(zoom),
      mojo::Clone(supports_torch),
      mojo::Clone(torch),
      mojo::Clone(red_eye_reduction),
      mojo::Clone(height),
      mojo::Clone(width),
      mojo::Clone(fill_light_mode),
      mojo::Clone(supported_background_blur_modes),
      mojo::Clone(background_blur_mode),
      mojo::Clone(supported_face_framing_modes),
      mojo::Clone(current_face_framing_mode),
      mojo::Clone(supported_eye_gaze_correction_modes),
      mojo::Clone(current_eye_gaze_correction_mode)
  );
}

template <typename T, PhotoState::EnableIfSame<T>*>
bool PhotoState::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->supported_white_balance_modes, other_struct.supported_white_balance_modes))
    return false;
  if (!mojo::Equals(this->current_white_balance_mode, other_struct.current_white_balance_mode))
    return false;
  if (!mojo::Equals(this->supported_exposure_modes, other_struct.supported_exposure_modes))
    return false;
  if (!mojo::Equals(this->current_exposure_mode, other_struct.current_exposure_mode))
    return false;
  if (!mojo::Equals(this->supported_focus_modes, other_struct.supported_focus_modes))
    return false;
  if (!mojo::Equals(this->current_focus_mode, other_struct.current_focus_mode))
    return false;
  if (!mojo::Equals(this->points_of_interest, other_struct.points_of_interest))
    return false;
  if (!mojo::Equals(this->exposure_compensation, other_struct.exposure_compensation))
    return false;
  if (!mojo::Equals(this->exposure_time, other_struct.exposure_time))
    return false;
  if (!mojo::Equals(this->color_temperature, other_struct.color_temperature))
    return false;
  if (!mojo::Equals(this->iso, other_struct.iso))
    return false;
  if (!mojo::Equals(this->brightness, other_struct.brightness))
    return false;
  if (!mojo::Equals(this->contrast, other_struct.contrast))
    return false;
  if (!mojo::Equals(this->saturation, other_struct.saturation))
    return false;
  if (!mojo::Equals(this->sharpness, other_struct.sharpness))
    return false;
  if (!mojo::Equals(this->focus_distance, other_struct.focus_distance))
    return false;
  if (!mojo::Equals(this->pan, other_struct.pan))
    return false;
  if (!mojo::Equals(this->tilt, other_struct.tilt))
    return false;
  if (!mojo::Equals(this->zoom, other_struct.zoom))
    return false;
  if (!mojo::Equals(this->supports_torch, other_struct.supports_torch))
    return false;
  if (!mojo::Equals(this->torch, other_struct.torch))
    return false;
  if (!mojo::Equals(this->red_eye_reduction, other_struct.red_eye_reduction))
    return false;
  if (!mojo::Equals(this->height, other_struct.height))
    return false;
  if (!mojo::Equals(this->width, other_struct.width))
    return false;
  if (!mojo::Equals(this->fill_light_mode, other_struct.fill_light_mode))
    return false;
  if (!mojo::Equals(this->supported_background_blur_modes, other_struct.supported_background_blur_modes))
    return false;
  if (!mojo::Equals(this->background_blur_mode, other_struct.background_blur_mode))
    return false;
  if (!mojo::Equals(this->supported_face_framing_modes, other_struct.supported_face_framing_modes))
    return false;
  if (!mojo::Equals(this->current_face_framing_mode, other_struct.current_face_framing_mode))
    return false;
  if (!mojo::Equals(this->supported_eye_gaze_correction_modes, other_struct.supported_eye_gaze_correction_modes))
    return false;
  if (!mojo::Equals(this->current_eye_gaze_correction_mode, other_struct.current_eye_gaze_correction_mode))
    return false;
  return true;
}

template <typename T, PhotoState::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.supported_white_balance_modes < rhs.supported_white_balance_modes)
    return true;
  if (rhs.supported_white_balance_modes < lhs.supported_white_balance_modes)
    return false;
  if (lhs.current_white_balance_mode < rhs.current_white_balance_mode)
    return true;
  if (rhs.current_white_balance_mode < lhs.current_white_balance_mode)
    return false;
  if (lhs.supported_exposure_modes < rhs.supported_exposure_modes)
    return true;
  if (rhs.supported_exposure_modes < lhs.supported_exposure_modes)
    return false;
  if (lhs.current_exposure_mode < rhs.current_exposure_mode)
    return true;
  if (rhs.current_exposure_mode < lhs.current_exposure_mode)
    return false;
  if (lhs.supported_focus_modes < rhs.supported_focus_modes)
    return true;
  if (rhs.supported_focus_modes < lhs.supported_focus_modes)
    return false;
  if (lhs.current_focus_mode < rhs.current_focus_mode)
    return true;
  if (rhs.current_focus_mode < lhs.current_focus_mode)
    return false;
  if (lhs.points_of_interest < rhs.points_of_interest)
    return true;
  if (rhs.points_of_interest < lhs.points_of_interest)
    return false;
  if (lhs.exposure_compensation < rhs.exposure_compensation)
    return true;
  if (rhs.exposure_compensation < lhs.exposure_compensation)
    return false;
  if (lhs.exposure_time < rhs.exposure_time)
    return true;
  if (rhs.exposure_time < lhs.exposure_time)
    return false;
  if (lhs.color_temperature < rhs.color_temperature)
    return true;
  if (rhs.color_temperature < lhs.color_temperature)
    return false;
  if (lhs.iso < rhs.iso)
    return true;
  if (rhs.iso < lhs.iso)
    return false;
  if (lhs.brightness < rhs.brightness)
    return true;
  if (rhs.brightness < lhs.brightness)
    return false;
  if (lhs.contrast < rhs.contrast)
    return true;
  if (rhs.contrast < lhs.contrast)
    return false;
  if (lhs.saturation < rhs.saturation)
    return true;
  if (rhs.saturation < lhs.saturation)
    return false;
  if (lhs.sharpness < rhs.sharpness)
    return true;
  if (rhs.sharpness < lhs.sharpness)
    return false;
  if (lhs.focus_distance < rhs.focus_distance)
    return true;
  if (rhs.focus_distance < lhs.focus_distance)
    return false;
  if (lhs.pan < rhs.pan)
    return true;
  if (rhs.pan < lhs.pan)
    return false;
  if (lhs.tilt < rhs.tilt)
    return true;
  if (rhs.tilt < lhs.tilt)
    return false;
  if (lhs.zoom < rhs.zoom)
    return true;
  if (rhs.zoom < lhs.zoom)
    return false;
  if (lhs.supports_torch < rhs.supports_torch)
    return true;
  if (rhs.supports_torch < lhs.supports_torch)
    return false;
  if (lhs.torch < rhs.torch)
    return true;
  if (rhs.torch < lhs.torch)
    return false;
  if (lhs.red_eye_reduction < rhs.red_eye_reduction)
    return true;
  if (rhs.red_eye_reduction < lhs.red_eye_reduction)
    return false;
  if (lhs.height < rhs.height)
    return true;
  if (rhs.height < lhs.height)
    return false;
  if (lhs.width < rhs.width)
    return true;
  if (rhs.width < lhs.width)
    return false;
  if (lhs.fill_light_mode < rhs.fill_light_mode)
    return true;
  if (rhs.fill_light_mode < lhs.fill_light_mode)
    return false;
  if (lhs.supported_background_blur_modes < rhs.supported_background_blur_modes)
    return true;
  if (rhs.supported_background_blur_modes < lhs.supported_background_blur_modes)
    return false;
  if (lhs.background_blur_mode < rhs.background_blur_mode)
    return true;
  if (rhs.background_blur_mode < lhs.background_blur_mode)
    return false;
  if (lhs.supported_face_framing_modes < rhs.supported_face_framing_modes)
    return true;
  if (rhs.supported_face_framing_modes < lhs.supported_face_framing_modes)
    return false;
  if (lhs.current_face_framing_mode < rhs.current_face_framing_mode)
    return true;
  if (rhs.current_face_framing_mode < lhs.current_face_framing_mode)
    return false;
  if (lhs.supported_eye_gaze_correction_modes < rhs.supported_eye_gaze_correction_modes)
    return true;
  if (rhs.supported_eye_gaze_correction_modes < lhs.supported_eye_gaze_correction_modes)
    return false;
  if (lhs.current_eye_gaze_correction_mode < rhs.current_eye_gaze_correction_mode)
    return true;
  if (rhs.current_eye_gaze_correction_mode < lhs.current_eye_gaze_correction_mode)
    return false;
  return false;
}
template <typename StructPtrType>
Point2DPtr Point2D::Clone() const {
  return New(
      mojo::Clone(x),
      mojo::Clone(y)
  );
}

template <typename T, Point2D::EnableIfSame<T>*>
bool Point2D::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->x, other_struct.x))
    return false;
  if (!mojo::Equals(this->y, other_struct.y))
    return false;
  return true;
}

template <typename T, Point2D::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.x < rhs.x)
    return true;
  if (rhs.x < lhs.x)
    return false;
  if (lhs.y < rhs.y)
    return true;
  if (rhs.y < lhs.y)
    return false;
  return false;
}
template <typename StructPtrType>
PhotoSettingsPtr PhotoSettings::Clone() const {
  return New(
      mojo::Clone(has_white_balance_mode),
      mojo::Clone(white_balance_mode),
      mojo::Clone(has_exposure_mode),
      mojo::Clone(exposure_mode),
      mojo::Clone(has_focus_mode),
      mojo::Clone(focus_mode),
      mojo::Clone(points_of_interest),
      mojo::Clone(has_exposure_compensation),
      mojo::Clone(exposure_compensation),
      mojo::Clone(has_exposure_time),
      mojo::Clone(exposure_time),
      mojo::Clone(has_color_temperature),
      mojo::Clone(color_temperature),
      mojo::Clone(has_iso),
      mojo::Clone(iso),
      mojo::Clone(has_brightness),
      mojo::Clone(brightness),
      mojo::Clone(has_contrast),
      mojo::Clone(contrast),
      mojo::Clone(has_saturation),
      mojo::Clone(saturation),
      mojo::Clone(has_sharpness),
      mojo::Clone(sharpness),
      mojo::Clone(has_focus_distance),
      mojo::Clone(focus_distance),
      mojo::Clone(has_pan),
      mojo::Clone(pan),
      mojo::Clone(has_tilt),
      mojo::Clone(tilt),
      mojo::Clone(has_zoom),
      mojo::Clone(zoom),
      mojo::Clone(has_torch),
      mojo::Clone(torch),
      mojo::Clone(has_fill_light_mode),
      mojo::Clone(fill_light_mode),
      mojo::Clone(has_width),
      mojo::Clone(width),
      mojo::Clone(has_height),
      mojo::Clone(height),
      mojo::Clone(has_red_eye_reduction),
      mojo::Clone(red_eye_reduction),
      mojo::Clone(has_background_blur_mode),
      mojo::Clone(background_blur_mode),
      mojo::Clone(has_face_framing_mode),
      mojo::Clone(face_framing_mode),
      mojo::Clone(eye_gaze_correction_mode)
  );
}

template <typename T, PhotoSettings::EnableIfSame<T>*>
bool PhotoSettings::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->has_white_balance_mode, other_struct.has_white_balance_mode))
    return false;
  if (!mojo::Equals(this->white_balance_mode, other_struct.white_balance_mode))
    return false;
  if (!mojo::Equals(this->has_exposure_mode, other_struct.has_exposure_mode))
    return false;
  if (!mojo::Equals(this->exposure_mode, other_struct.exposure_mode))
    return false;
  if (!mojo::Equals(this->has_focus_mode, other_struct.has_focus_mode))
    return false;
  if (!mojo::Equals(this->focus_mode, other_struct.focus_mode))
    return false;
  if (!mojo::Equals(this->points_of_interest, other_struct.points_of_interest))
    return false;
  if (!mojo::Equals(this->has_exposure_compensation, other_struct.has_exposure_compensation))
    return false;
  if (!mojo::Equals(this->exposure_compensation, other_struct.exposure_compensation))
    return false;
  if (!mojo::Equals(this->has_exposure_time, other_struct.has_exposure_time))
    return false;
  if (!mojo::Equals(this->exposure_time, other_struct.exposure_time))
    return false;
  if (!mojo::Equals(this->has_color_temperature, other_struct.has_color_temperature))
    return false;
  if (!mojo::Equals(this->color_temperature, other_struct.color_temperature))
    return false;
  if (!mojo::Equals(this->has_iso, other_struct.has_iso))
    return false;
  if (!mojo::Equals(this->iso, other_struct.iso))
    return false;
  if (!mojo::Equals(this->has_brightness, other_struct.has_brightness))
    return false;
  if (!mojo::Equals(this->brightness, other_struct.brightness))
    return false;
  if (!mojo::Equals(this->has_contrast, other_struct.has_contrast))
    return false;
  if (!mojo::Equals(this->contrast, other_struct.contrast))
    return false;
  if (!mojo::Equals(this->has_saturation, other_struct.has_saturation))
    return false;
  if (!mojo::Equals(this->saturation, other_struct.saturation))
    return false;
  if (!mojo::Equals(this->has_sharpness, other_struct.has_sharpness))
    return false;
  if (!mojo::Equals(this->sharpness, other_struct.sharpness))
    return false;
  if (!mojo::Equals(this->has_focus_distance, other_struct.has_focus_distance))
    return false;
  if (!mojo::Equals(this->focus_distance, other_struct.focus_distance))
    return false;
  if (!mojo::Equals(this->has_pan, other_struct.has_pan))
    return false;
  if (!mojo::Equals(this->pan, other_struct.pan))
    return false;
  if (!mojo::Equals(this->has_tilt, other_struct.has_tilt))
    return false;
  if (!mojo::Equals(this->tilt, other_struct.tilt))
    return false;
  if (!mojo::Equals(this->has_zoom, other_struct.has_zoom))
    return false;
  if (!mojo::Equals(this->zoom, other_struct.zoom))
    return false;
  if (!mojo::Equals(this->has_torch, other_struct.has_torch))
    return false;
  if (!mojo::Equals(this->torch, other_struct.torch))
    return false;
  if (!mojo::Equals(this->has_fill_light_mode, other_struct.has_fill_light_mode))
    return false;
  if (!mojo::Equals(this->fill_light_mode, other_struct.fill_light_mode))
    return false;
  if (!mojo::Equals(this->has_width, other_struct.has_width))
    return false;
  if (!mojo::Equals(this->width, other_struct.width))
    return false;
  if (!mojo::Equals(this->has_height, other_struct.has_height))
    return false;
  if (!mojo::Equals(this->height, other_struct.height))
    return false;
  if (!mojo::Equals(this->has_red_eye_reduction, other_struct.has_red_eye_reduction))
    return false;
  if (!mojo::Equals(this->red_eye_reduction, other_struct.red_eye_reduction))
    return false;
  if (!mojo::Equals(this->has_background_blur_mode, other_struct.has_background_blur_mode))
    return false;
  if (!mojo::Equals(this->background_blur_mode, other_struct.background_blur_mode))
    return false;
  if (!mojo::Equals(this->has_face_framing_mode, other_struct.has_face_framing_mode))
    return false;
  if (!mojo::Equals(this->face_framing_mode, other_struct.face_framing_mode))
    return false;
  if (!mojo::Equals(this->eye_gaze_correction_mode, other_struct.eye_gaze_correction_mode))
    return false;
  return true;
}

template <typename T, PhotoSettings::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.has_white_balance_mode < rhs.has_white_balance_mode)
    return true;
  if (rhs.has_white_balance_mode < lhs.has_white_balance_mode)
    return false;
  if (lhs.white_balance_mode < rhs.white_balance_mode)
    return true;
  if (rhs.white_balance_mode < lhs.white_balance_mode)
    return false;
  if (lhs.has_exposure_mode < rhs.has_exposure_mode)
    return true;
  if (rhs.has_exposure_mode < lhs.has_exposure_mode)
    return false;
  if (lhs.exposure_mode < rhs.exposure_mode)
    return true;
  if (rhs.exposure_mode < lhs.exposure_mode)
    return false;
  if (lhs.has_focus_mode < rhs.has_focus_mode)
    return true;
  if (rhs.has_focus_mode < lhs.has_focus_mode)
    return false;
  if (lhs.focus_mode < rhs.focus_mode)
    return true;
  if (rhs.focus_mode < lhs.focus_mode)
    return false;
  if (lhs.points_of_interest < rhs.points_of_interest)
    return true;
  if (rhs.points_of_interest < lhs.points_of_interest)
    return false;
  if (lhs.has_exposure_compensation < rhs.has_exposure_compensation)
    return true;
  if (rhs.has_exposure_compensation < lhs.has_exposure_compensation)
    return false;
  if (lhs.exposure_compensation < rhs.exposure_compensation)
    return true;
  if (rhs.exposure_compensation < lhs.exposure_compensation)
    return false;
  if (lhs.has_exposure_time < rhs.has_exposure_time)
    return true;
  if (rhs.has_exposure_time < lhs.has_exposure_time)
    return false;
  if (lhs.exposure_time < rhs.exposure_time)
    return true;
  if (rhs.exposure_time < lhs.exposure_time)
    return false;
  if (lhs.has_color_temperature < rhs.has_color_temperature)
    return true;
  if (rhs.has_color_temperature < lhs.has_color_temperature)
    return false;
  if (lhs.color_temperature < rhs.color_temperature)
    return true;
  if (rhs.color_temperature < lhs.color_temperature)
    return false;
  if (lhs.has_iso < rhs.has_iso)
    return true;
  if (rhs.has_iso < lhs.has_iso)
    return false;
  if (lhs.iso < rhs.iso)
    return true;
  if (rhs.iso < lhs.iso)
    return false;
  if (lhs.has_brightness < rhs.has_brightness)
    return true;
  if (rhs.has_brightness < lhs.has_brightness)
    return false;
  if (lhs.brightness < rhs.brightness)
    return true;
  if (rhs.brightness < lhs.brightness)
    return false;
  if (lhs.has_contrast < rhs.has_contrast)
    return true;
  if (rhs.has_contrast < lhs.has_contrast)
    return false;
  if (lhs.contrast < rhs.contrast)
    return true;
  if (rhs.contrast < lhs.contrast)
    return false;
  if (lhs.has_saturation < rhs.has_saturation)
    return true;
  if (rhs.has_saturation < lhs.has_saturation)
    return false;
  if (lhs.saturation < rhs.saturation)
    return true;
  if (rhs.saturation < lhs.saturation)
    return false;
  if (lhs.has_sharpness < rhs.has_sharpness)
    return true;
  if (rhs.has_sharpness < lhs.has_sharpness)
    return false;
  if (lhs.sharpness < rhs.sharpness)
    return true;
  if (rhs.sharpness < lhs.sharpness)
    return false;
  if (lhs.has_focus_distance < rhs.has_focus_distance)
    return true;
  if (rhs.has_focus_distance < lhs.has_focus_distance)
    return false;
  if (lhs.focus_distance < rhs.focus_distance)
    return true;
  if (rhs.focus_distance < lhs.focus_distance)
    return false;
  if (lhs.has_pan < rhs.has_pan)
    return true;
  if (rhs.has_pan < lhs.has_pan)
    return false;
  if (lhs.pan < rhs.pan)
    return true;
  if (rhs.pan < lhs.pan)
    return false;
  if (lhs.has_tilt < rhs.has_tilt)
    return true;
  if (rhs.has_tilt < lhs.has_tilt)
    return false;
  if (lhs.tilt < rhs.tilt)
    return true;
  if (rhs.tilt < lhs.tilt)
    return false;
  if (lhs.has_zoom < rhs.has_zoom)
    return true;
  if (rhs.has_zoom < lhs.has_zoom)
    return false;
  if (lhs.zoom < rhs.zoom)
    return true;
  if (rhs.zoom < lhs.zoom)
    return false;
  if (lhs.has_torch < rhs.has_torch)
    return true;
  if (rhs.has_torch < lhs.has_torch)
    return false;
  if (lhs.torch < rhs.torch)
    return true;
  if (rhs.torch < lhs.torch)
    return false;
  if (lhs.has_fill_light_mode < rhs.has_fill_light_mode)
    return true;
  if (rhs.has_fill_light_mode < lhs.has_fill_light_mode)
    return false;
  if (lhs.fill_light_mode < rhs.fill_light_mode)
    return true;
  if (rhs.fill_light_mode < lhs.fill_light_mode)
    return false;
  if (lhs.has_width < rhs.has_width)
    return true;
  if (rhs.has_width < lhs.has_width)
    return false;
  if (lhs.width < rhs.width)
    return true;
  if (rhs.width < lhs.width)
    return false;
  if (lhs.has_height < rhs.has_height)
    return true;
  if (rhs.has_height < lhs.has_height)
    return false;
  if (lhs.height < rhs.height)
    return true;
  if (rhs.height < lhs.height)
    return false;
  if (lhs.has_red_eye_reduction < rhs.has_red_eye_reduction)
    return true;
  if (rhs.has_red_eye_reduction < lhs.has_red_eye_reduction)
    return false;
  if (lhs.red_eye_reduction < rhs.red_eye_reduction)
    return true;
  if (rhs.red_eye_reduction < lhs.red_eye_reduction)
    return false;
  if (lhs.has_background_blur_mode < rhs.has_background_blur_mode)
    return true;
  if (rhs.has_background_blur_mode < lhs.has_background_blur_mode)
    return false;
  if (lhs.background_blur_mode < rhs.background_blur_mode)
    return true;
  if (rhs.background_blur_mode < lhs.background_blur_mode)
    return false;
  if (lhs.has_face_framing_mode < rhs.has_face_framing_mode)
    return true;
  if (rhs.has_face_framing_mode < lhs.has_face_framing_mode)
    return false;
  if (lhs.face_framing_mode < rhs.face_framing_mode)
    return true;
  if (rhs.face_framing_mode < lhs.face_framing_mode)
    return false;
  if (lhs.eye_gaze_correction_mode < rhs.eye_gaze_correction_mode)
    return true;
  if (rhs.eye_gaze_correction_mode < lhs.eye_gaze_correction_mode)
    return false;
  return false;
}
template <typename StructPtrType>
BlobPtr Blob::Clone() const {
  return New(
      mojo::Clone(mime_type),
      mojo::Clone(data)
  );
}

template <typename T, Blob::EnableIfSame<T>*>
bool Blob::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->mime_type, other_struct.mime_type))
    return false;
  if (!mojo::Equals(this->data, other_struct.data))
    return false;
  return true;
}

template <typename T, Blob::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.mime_type < rhs.mime_type)
    return true;
  if (rhs.mime_type < lhs.mime_type)
    return false;
  if (lhs.data < rhs.data)
    return true;
  if (rhs.data < lhs.data)
    return false;
  return false;
}


}  // media::mojom::blink

namespace mojo {


template <>
struct  StructTraits<::media::mojom::blink::Range::DataView,
                                         ::media::mojom::blink::RangePtr> {
  static bool IsNull(const ::media::mojom::blink::RangePtr& input) { return !input; }
  static void SetToNull(::media::mojom::blink::RangePtr* output) { output->reset(); }

  static decltype(::media::mojom::blink::Range::max) max(
      const ::media::mojom::blink::RangePtr& input) {
    return input->max;
  }

  static decltype(::media::mojom::blink::Range::min) min(
      const ::media::mojom::blink::RangePtr& input) {
    return input->min;
  }

  static decltype(::media::mojom::blink::Range::current) current(
      const ::media::mojom::blink::RangePtr& input) {
    return input->current;
  }

  static decltype(::media::mojom::blink::Range::step) step(
      const ::media::mojom::blink::RangePtr& input) {
    return input->step;
  }

  static bool Read(::media::mojom::blink::Range::DataView input, ::media::mojom::blink::RangePtr* output);
};


template <>
struct  StructTraits<::media::mojom::blink::PhotoState::DataView,
                                         ::media::mojom::blink::PhotoStatePtr> {
  static bool IsNull(const ::media::mojom::blink::PhotoStatePtr& input) { return !input; }
  static void SetToNull(::media::mojom::blink::PhotoStatePtr* output) { output->reset(); }

  static const decltype(::media::mojom::blink::PhotoState::supported_white_balance_modes)& supported_white_balance_modes(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->supported_white_balance_modes;
  }

  static decltype(::media::mojom::blink::PhotoState::current_white_balance_mode) current_white_balance_mode(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->current_white_balance_mode;
  }

  static const decltype(::media::mojom::blink::PhotoState::supported_exposure_modes)& supported_exposure_modes(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->supported_exposure_modes;
  }

  static decltype(::media::mojom::blink::PhotoState::current_exposure_mode) current_exposure_mode(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->current_exposure_mode;
  }

  static const decltype(::media::mojom::blink::PhotoState::supported_focus_modes)& supported_focus_modes(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->supported_focus_modes;
  }

  static decltype(::media::mojom::blink::PhotoState::current_focus_mode) current_focus_mode(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->current_focus_mode;
  }

  static const decltype(::media::mojom::blink::PhotoState::points_of_interest)& points_of_interest(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->points_of_interest;
  }

  static const decltype(::media::mojom::blink::PhotoState::exposure_compensation)& exposure_compensation(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->exposure_compensation;
  }

  static const decltype(::media::mojom::blink::PhotoState::exposure_time)& exposure_time(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->exposure_time;
  }

  static const decltype(::media::mojom::blink::PhotoState::color_temperature)& color_temperature(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->color_temperature;
  }

  static const decltype(::media::mojom::blink::PhotoState::iso)& iso(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->iso;
  }

  static const decltype(::media::mojom::blink::PhotoState::brightness)& brightness(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->brightness;
  }

  static const decltype(::media::mojom::blink::PhotoState::contrast)& contrast(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->contrast;
  }

  static const decltype(::media::mojom::blink::PhotoState::saturation)& saturation(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->saturation;
  }

  static const decltype(::media::mojom::blink::PhotoState::sharpness)& sharpness(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->sharpness;
  }

  static const decltype(::media::mojom::blink::PhotoState::focus_distance)& focus_distance(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->focus_distance;
  }

  static const decltype(::media::mojom::blink::PhotoState::pan)& pan(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->pan;
  }

  static const decltype(::media::mojom::blink::PhotoState::tilt)& tilt(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->tilt;
  }

  static const decltype(::media::mojom::blink::PhotoState::zoom)& zoom(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->zoom;
  }

  static decltype(::media::mojom::blink::PhotoState::supports_torch) supports_torch(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->supports_torch;
  }

  static decltype(::media::mojom::blink::PhotoState::torch) torch(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->torch;
  }

  static decltype(::media::mojom::blink::PhotoState::red_eye_reduction) red_eye_reduction(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->red_eye_reduction;
  }

  static const decltype(::media::mojom::blink::PhotoState::height)& height(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->height;
  }

  static const decltype(::media::mojom::blink::PhotoState::width)& width(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->width;
  }

  static const decltype(::media::mojom::blink::PhotoState::fill_light_mode)& fill_light_mode(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->fill_light_mode;
  }

  static const decltype(::media::mojom::blink::PhotoState::supported_background_blur_modes)& supported_background_blur_modes(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->supported_background_blur_modes;
  }

  static decltype(::media::mojom::blink::PhotoState::background_blur_mode) background_blur_mode(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->background_blur_mode;
  }

  static const decltype(::media::mojom::blink::PhotoState::supported_face_framing_modes)& supported_face_framing_modes(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->supported_face_framing_modes;
  }

  static decltype(::media::mojom::blink::PhotoState::current_face_framing_mode) current_face_framing_mode(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->current_face_framing_mode;
  }

  static const decltype(::media::mojom::blink::PhotoState::supported_eye_gaze_correction_modes)& supported_eye_gaze_correction_modes(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->supported_eye_gaze_correction_modes;
  }

  static decltype(::media::mojom::blink::PhotoState::current_eye_gaze_correction_mode) current_eye_gaze_correction_mode(
      const ::media::mojom::blink::PhotoStatePtr& input) {
    return input->current_eye_gaze_correction_mode;
  }

  static bool Read(::media::mojom::blink::PhotoState::DataView input, ::media::mojom::blink::PhotoStatePtr* output);
};


template <>
struct  StructTraits<::media::mojom::blink::Point2D::DataView,
                                         ::media::mojom::blink::Point2DPtr> {
  static bool IsNull(const ::media::mojom::blink::Point2DPtr& input) { return !input; }
  static void SetToNull(::media::mojom::blink::Point2DPtr* output) { output->reset(); }

  static decltype(::media::mojom::blink::Point2D::x) x(
      const ::media::mojom::blink::Point2DPtr& input) {
    return input->x;
  }

  static decltype(::media::mojom::blink::Point2D::y) y(
      const ::media::mojom::blink::Point2DPtr& input) {
    return input->y;
  }

  static bool Read(::media::mojom::blink::Point2D::DataView input, ::media::mojom::blink::Point2DPtr* output);
};


template <>
struct  StructTraits<::media::mojom::blink::PhotoSettings::DataView,
                                         ::media::mojom::blink::PhotoSettingsPtr> {
  static bool IsNull(const ::media::mojom::blink::PhotoSettingsPtr& input) { return !input; }
  static void SetToNull(::media::mojom::blink::PhotoSettingsPtr* output) { output->reset(); }

  static decltype(::media::mojom::blink::PhotoSettings::has_white_balance_mode) has_white_balance_mode(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_white_balance_mode;
  }

  static decltype(::media::mojom::blink::PhotoSettings::white_balance_mode) white_balance_mode(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->white_balance_mode;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_exposure_mode) has_exposure_mode(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_exposure_mode;
  }

  static decltype(::media::mojom::blink::PhotoSettings::exposure_mode) exposure_mode(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->exposure_mode;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_focus_mode) has_focus_mode(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_focus_mode;
  }

  static decltype(::media::mojom::blink::PhotoSettings::focus_mode) focus_mode(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->focus_mode;
  }

  static const decltype(::media::mojom::blink::PhotoSettings::points_of_interest)& points_of_interest(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->points_of_interest;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_exposure_compensation) has_exposure_compensation(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_exposure_compensation;
  }

  static decltype(::media::mojom::blink::PhotoSettings::exposure_compensation) exposure_compensation(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->exposure_compensation;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_exposure_time) has_exposure_time(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_exposure_time;
  }

  static decltype(::media::mojom::blink::PhotoSettings::exposure_time) exposure_time(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->exposure_time;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_color_temperature) has_color_temperature(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_color_temperature;
  }

  static decltype(::media::mojom::blink::PhotoSettings::color_temperature) color_temperature(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->color_temperature;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_iso) has_iso(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_iso;
  }

  static decltype(::media::mojom::blink::PhotoSettings::iso) iso(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->iso;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_brightness) has_brightness(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_brightness;
  }

  static decltype(::media::mojom::blink::PhotoSettings::brightness) brightness(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->brightness;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_contrast) has_contrast(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_contrast;
  }

  static decltype(::media::mojom::blink::PhotoSettings::contrast) contrast(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->contrast;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_saturation) has_saturation(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_saturation;
  }

  static decltype(::media::mojom::blink::PhotoSettings::saturation) saturation(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->saturation;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_sharpness) has_sharpness(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_sharpness;
  }

  static decltype(::media::mojom::blink::PhotoSettings::sharpness) sharpness(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->sharpness;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_focus_distance) has_focus_distance(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_focus_distance;
  }

  static decltype(::media::mojom::blink::PhotoSettings::focus_distance) focus_distance(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->focus_distance;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_pan) has_pan(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_pan;
  }

  static decltype(::media::mojom::blink::PhotoSettings::pan) pan(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->pan;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_tilt) has_tilt(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_tilt;
  }

  static decltype(::media::mojom::blink::PhotoSettings::tilt) tilt(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->tilt;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_zoom) has_zoom(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_zoom;
  }

  static decltype(::media::mojom::blink::PhotoSettings::zoom) zoom(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->zoom;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_torch) has_torch(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_torch;
  }

  static decltype(::media::mojom::blink::PhotoSettings::torch) torch(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->torch;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_fill_light_mode) has_fill_light_mode(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_fill_light_mode;
  }

  static decltype(::media::mojom::blink::PhotoSettings::fill_light_mode) fill_light_mode(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->fill_light_mode;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_width) has_width(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_width;
  }

  static decltype(::media::mojom::blink::PhotoSettings::width) width(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->width;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_height) has_height(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_height;
  }

  static decltype(::media::mojom::blink::PhotoSettings::height) height(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->height;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_red_eye_reduction) has_red_eye_reduction(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_red_eye_reduction;
  }

  static decltype(::media::mojom::blink::PhotoSettings::red_eye_reduction) red_eye_reduction(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->red_eye_reduction;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_background_blur_mode) has_background_blur_mode(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_background_blur_mode;
  }

  static decltype(::media::mojom::blink::PhotoSettings::background_blur_mode) background_blur_mode(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->background_blur_mode;
  }

  static decltype(::media::mojom::blink::PhotoSettings::has_face_framing_mode) has_face_framing_mode(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->has_face_framing_mode;
  }

  static decltype(::media::mojom::blink::PhotoSettings::face_framing_mode) face_framing_mode(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->face_framing_mode;
  }

  static decltype(::media::mojom::blink::PhotoSettings::eye_gaze_correction_mode) eye_gaze_correction_mode(
      const ::media::mojom::blink::PhotoSettingsPtr& input) {
    return input->eye_gaze_correction_mode;
  }

  static bool Read(::media::mojom::blink::PhotoSettings::DataView input, ::media::mojom::blink::PhotoSettingsPtr* output);
};


template <>
struct  StructTraits<::media::mojom::blink::Blob::DataView,
                                         ::media::mojom::blink::BlobPtr> {
  static bool IsNull(const ::media::mojom::blink::BlobPtr& input) { return !input; }
  static void SetToNull(::media::mojom::blink::BlobPtr* output) { output->reset(); }

  static const decltype(::media::mojom::blink::Blob::mime_type)& mime_type(
      const ::media::mojom::blink::BlobPtr& input) {
    return input->mime_type;
  }

  static const decltype(::media::mojom::blink::Blob::data)& data(
      const ::media::mojom::blink::BlobPtr& input) {
    return input->data;
  }

  static bool Read(::media::mojom::blink::Blob::DataView input, ::media::mojom::blink::BlobPtr* output);
};

}  // namespace mojo

#endif  // MEDIA_CAPTURE_MOJOM_IMAGE_CAPTURE_MOJOM_BLINK_H_
/* Metadata comment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==
*/