third_party/blink/renderer/modules/mediastream/media_constraints.h - chromium/src.git - Git at Google

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
  * distribution.
  *     * Neither the name of Google Inc. nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_MEDIASTREAM_MEDIA_CONSTRAINTS_H_
 #define THIRD_PARTY_BLINK_RENDERER_MODULES_MEDIASTREAM_MEDIA_CONSTRAINTS_H_

 #include "third_party/blink/public/platform/web_private_ptr.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
 #include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
 #include "third_party/blink/renderer/platform/wtf/vector.h"

 namespace blink {

 class MediaConstraintsPrivate;

 class MODULES_EXPORT BaseConstraint {
  public:
   explicit BaseConstraint(const char* name);
   virtual ~BaseConstraint();

   bool IsPresent() const { return is_present_ || !IsUnconstrained(); }
   void SetIsPresent(bool is_present) { is_present_ = is_present; }

   // true if the Constraint has neither Mandatory (min/max/exact) nor Ideal
   // values, false otherwise.
   virtual bool IsUnconstrained() const = 0;
   virtual bool HasMandatory() const;
   virtual bool HasMin() const { return false; }
   virtual bool HasMax() const { return false; }
   virtual bool HasExact() const = 0;
   const char* GetName() const { return name_; }
   virtual void ResetToUnconstrained() = 0;
   virtual String ToString() const = 0;

  private:
   const char* name_;
   bool is_present_ = false;
 };

 // Note this class refers to the "long" WebIDL definition which is
 // equivalent to int32_t.
 class MODULES_EXPORT LongConstraint : public BaseConstraint {
  public:
   explicit LongConstraint(const char* name);

   void SetMin(int32_t value) {
     min_ = value;
     has_min_ = true;
   }

   void SetMax(int32_t value) {
     max_ = value;
     has_max_ = true;
   }

   void SetExact(int32_t value) {
     exact_ = value;
     has_exact_ = true;
   }

   void SetIdeal(int32_t value) {
     ideal_ = value;
     has_ideal_ = true;
   }

   bool Matches(int32_t value) const;
   bool IsUnconstrained() const override;
   bool HasMin() const override { return has_min_; }
   bool HasMax() const override { return has_max_; }
   bool HasExact() const override { return has_exact_; }
   void ResetToUnconstrained() override;
   String ToString() const override;
   int32_t Min() const { return min_; }
   int32_t Max() const { return max_; }
   int32_t Exact() const { return exact_; }
   bool HasIdeal() const { return has_ideal_; }
   int32_t Ideal() const { return ideal_; }

  private:
   int32_t min_;
   int32_t max_;
   int32_t exact_;
   int32_t ideal_;
   unsigned has_min_ : 1;
   unsigned has_max_ : 1;
   unsigned has_exact_ : 1;
   unsigned has_ideal_ : 1;
 };

 class MODULES_EXPORT DoubleConstraint : public BaseConstraint {
  public:
   // Permit a certain leeway when comparing floats. The offset of 0.00001
   // is chosen based on observed behavior of doubles formatted with
   // webrtc::ToString.
   static const double kConstraintEpsilon;

   explicit DoubleConstraint(const char* name);

   void SetMin(double value) {
     min_ = value;
     has_min_ = true;
   }

   void SetMax(double value) {
     max_ = value;
     has_max_ = true;
   }

   void SetExact(double value) {
     exact_ = value;
     has_exact_ = true;
   }

   void SetIdeal(double value) {
     ideal_ = value;
     has_ideal_ = true;
   }

   bool Matches(double value) const;
   bool IsUnconstrained() const override;
   bool HasMin() const override { return has_min_; }
   bool HasMax() const override { return has_max_; }
   bool HasExact() const override { return has_exact_; }
   void ResetToUnconstrained() override;
   String ToString() const override;
   double Min() const { return min_; }
   double Max() const { return max_; }
   double Exact() const { return exact_; }
   bool HasIdeal() const { return has_ideal_; }
   double Ideal() const { return ideal_; }

  private:
   double min_;
   double max_;
   double exact_;
   double ideal_;
   unsigned has_min_ : 1;
   unsigned has_max_ : 1;
   unsigned has_exact_ : 1;
   unsigned has_ideal_ : 1;
 };

 class MODULES_EXPORT DoubleOrBooleanConstraint : public DoubleConstraint {
  public:
   explicit DoubleOrBooleanConstraint(const char* name);

   bool HasMandatory() const override;
   bool HasExactBoolean() const { return has_exact_boolean_; }
   bool ExactBoolean() const { return exact_boolean_; }
   bool HasIdealBoolean() const { return has_ideal_boolean_; }
   bool IdealBoolean() const { return ideal_boolean_; }

   void SetExactBoolean(bool value) {
     exact_boolean_ = value;
     has_exact_boolean_ = true;
   }

   void SetIdealBoolean(bool value) {
     ideal_boolean_ = value;
     has_ideal_boolean_ = true;
   }

   bool Matches(double value) const;
   bool MatchesBoolean(bool value) const;
   bool IsPresentAndNotFalse() const;
   bool IsUnconstrained() const override;
   void ResetToUnconstrained() override;
   String ToString() const override;

  private:
   unsigned exact_boolean_ : 1 = 0;
   unsigned ideal_boolean_ : 1 = 0;
   unsigned has_exact_boolean_ : 1 = 0;
   unsigned has_ideal_boolean_ : 1 = 0;
 };

 class MODULES_EXPORT StringConstraint : public BaseConstraint {
  public:
   // String-valued options don't have min or max, but can have multiple
   // values for ideal and exact.
   explicit StringConstraint(const char* name);

   void SetExact(const String& exact) { exact_ = {exact}; }

   void SetExact(const Vector<String>& exact) { exact_ = exact; }

   void SetIdeal(const String& ideal) { ideal_ = {ideal}; }

   void SetIdeal(const Vector<String>& ideal) { ideal_ = ideal; }

   bool Matches(String value) const;
   bool IsUnconstrained() const override;
   bool HasExact() const override { return !exact_.empty(); }
   void ResetToUnconstrained() override;
   String ToString() const override;
   bool HasIdeal() const { return !ideal_.empty(); }
   const Vector<String>& Exact() const;
   const Vector<String>& Ideal() const;

  private:
   Vector<String> exact_;
   Vector<String> ideal_;
 };

 class MODULES_EXPORT BooleanConstraint : public BaseConstraint {
  public:
   explicit BooleanConstraint(const char* name);

   bool Exact() const { return exact_; }
   bool Ideal() const { return ideal_; }
   void SetIdeal(bool value) {
     ideal_ = value;
     has_ideal_ = true;
   }

   void SetExact(bool value) {
     exact_ = value;
     has_exact_ = true;
   }

   bool Matches(bool value) const;
   bool IsUnconstrained() const override;
   bool HasExact() const override { return has_exact_; }
   void ResetToUnconstrained() override;
   String ToString() const override;
   bool HasIdeal() const { return has_ideal_; }

  private:
   unsigned ideal_ : 1;
   unsigned exact_ : 1;
   unsigned has_ideal_ : 1;
   unsigned has_exact_ : 1;
 };

 class MODULES_EXPORT BooleanOrStringConstraint : public BaseConstraint {
  public:
   explicit BooleanOrStringConstraint(const char* name);

   bool HasExactBoolean() const { return has_exact_boolean_; }
   bool ExactBoolean() const { return exact_boolean_; }
   bool HasIdealBoolean() const { return has_ideal_boolean_; }
   bool IdealBoolean() const { return ideal_boolean_; }

   void SetExactBoolean(bool value) {
     exact_boolean_ = value;
     has_exact_boolean_ = true;
   }

   void SetIdealBoolean(bool value) {
     ideal_boolean_ = value;
     has_ideal_boolean_ = true;
   }

   bool HasExactString() const { return has_exact_string_; }
   String ExactString() const { return exact_string_; }
   bool HasIdealString() const { return has_ideal_string_; }
   String IdealString() const { return ideal_string_; }

   void SetExactString(const String& value) {
     exact_string_ = value;
     has_exact_string_ = true;
   }

   void SetIdealString(const String& value) {
     ideal_string_ = value;
     has_ideal_string_ = true;
   }

   // BaseConstraint overrides
   bool HasExact() const override;
   bool IsUnconstrained() const override;
   void ResetToUnconstrained() override;
   String ToString() const override;

   bool HasIdeal() const;

  private:
   unsigned exact_boolean_ : 1 = false;
   unsigned ideal_boolean_ : 1 = false;
   unsigned has_exact_boolean_ : 1 = false;
   unsigned has_ideal_boolean_ : 1 = false;
   unsigned has_exact_string_ : 1 = false;
   unsigned has_ideal_string_ : 1 = false;
   String exact_string_;
   String ideal_string_;
 };

 struct MediaTrackConstraintSetPlatform {
  public:
   MODULES_EXPORT MediaTrackConstraintSetPlatform();

   LongConstraint width;
   LongConstraint height;
   DoubleConstraint aspect_ratio;
   DoubleConstraint frame_rate;
   StringConstraint facing_mode;
   StringConstraint resize_mode;
   DoubleConstraint volume;
   LongConstraint sample_rate;
   LongConstraint sample_size;
   BooleanOrStringConstraint echo_cancellation;
   BooleanConstraint auto_gain_control;
   BooleanConstraint noise_suppression;
   BooleanConstraint voice_isolation;
   DoubleConstraint latency;
   LongConstraint channel_count;
   StringConstraint device_id;
   BooleanConstraint disable_local_echo;
   BooleanConstraint suppress_local_audio_playback;
   BooleanConstraint restrict_own_audio;
   StringConstraint group_id;
   StringConstraint display_surface;

   // W3C Image Capture
   DoubleConstraint exposure_compensation;
   DoubleConstraint exposure_time;
   DoubleConstraint color_temperature;
   DoubleConstraint iso;
   DoubleConstraint brightness;
   DoubleConstraint contrast;
   DoubleConstraint saturation;
   DoubleConstraint sharpness;
   DoubleConstraint focus_distance;
   DoubleOrBooleanConstraint pan;
   DoubleOrBooleanConstraint tilt;
   DoubleOrBooleanConstraint zoom;
   BooleanConstraint torch;

   // W3C Media Capture Extensions
   BooleanConstraint background_blur;
   BooleanConstraint background_segmentation_mask;
   BooleanConstraint eye_gaze_correction;
   BooleanConstraint face_framing;

   // Constraints not exposed in Blink at the moment, only through
   // the legacy name interface.
   StringConstraint media_stream_source;  // tab, screen, desktop, system
   BooleanConstraint render_to_associated_sink;
   BooleanConstraint goog_noise_reduction;

   MODULES_EXPORT bool IsUnconstrained() const;
   MODULES_EXPORT bool HasMandatory() const;
   MODULES_EXPORT bool HasMandatoryOutsideSet(const Vector<String>&,
                                              String&) const;
   MODULES_EXPORT bool HasMin() const;
   MODULES_EXPORT bool HasExact() const;
   MODULES_EXPORT String ToString() const;

  private:
   Vector<const BaseConstraint*> AllConstraints() const;
 };

 class MediaConstraints {
  public:
   MODULES_EXPORT MediaConstraints();
   MediaConstraints(const MediaConstraints& other);
   ~MediaConstraints() { Reset(); }

   MediaConstraints& operator=(const MediaConstraints& other) {
     Assign(other);
     return *this;
   }

   MODULES_EXPORT void Assign(const MediaConstraints&);

   MODULES_EXPORT void Reset();
   bool IsNull() const { return private_.IsNull(); }
   MODULES_EXPORT bool IsUnconstrained() const;

   MODULES_EXPORT void Initialize();
   MODULES_EXPORT void Initialize(
       const MediaTrackConstraintSetPlatform& basic,
       const Vector<MediaTrackConstraintSetPlatform>& advanced);

   MODULES_EXPORT const MediaTrackConstraintSetPlatform& Basic() const;
   MODULES_EXPORT MediaTrackConstraintSetPlatform& MutableBasic();
   MODULES_EXPORT const Vector<MediaTrackConstraintSetPlatform>& Advanced()
       const;

   MODULES_EXPORT const String ToString() const;

  private:
   WebPrivatePtrForRefCounted<MediaConstraintsPrivate> private_;
 };

 }  // namespace blink

 #endif  // THIRD_PARTY_BLINK_RENDERER_MODULES_MEDIASTREAM_MEDIA_CONSTRAINTS_H_
	/*
	* Copyright (C) 2012 Google Inc. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are
	* met:
	*
	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* * Redistributions in binary form must reproduce the above
	* copyright notice, this list of conditions and the following disclaimer
	* in the documentation and/or other materials provided with the
	* distribution.
	* * Neither the name of Google Inc. nor the names of its
	* contributors may be used to endorse or promote products derived from
	* this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_MEDIASTREAM_MEDIA_CONSTRAINTS_H_
	#define THIRD_PARTY_BLINK_RENDERER_MODULES_MEDIASTREAM_MEDIA_CONSTRAINTS_H_

	#include "third_party/blink/public/platform/web_private_ptr.h"
	#include "third_party/blink/renderer/modules/modules_export.h"
	#include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
	#include "third_party/blink/renderer/platform/wtf/vector.h"

	namespace blink {

	class MediaConstraintsPrivate;

	class MODULES_EXPORT BaseConstraint {
	public:
	explicit BaseConstraint(const char* name);
	virtual ~BaseConstraint();

	bool IsPresent() const { return is_present_ \|\| !IsUnconstrained(); }
	void SetIsPresent(bool is_present) { is_present_ = is_present; }

	// true if the Constraint has neither Mandatory (min/max/exact) nor Ideal
	// values, false otherwise.
	virtual bool IsUnconstrained() const = 0;
	virtual bool HasMandatory() const;
	virtual bool HasMin() const { return false; }
	virtual bool HasMax() const { return false; }
	virtual bool HasExact() const = 0;
	const char* GetName() const { return name_; }
	virtual void ResetToUnconstrained() = 0;
	virtual String ToString() const = 0;

	private:
	const char* name_;
	bool is_present_ = false;
	};

	// Note this class refers to the "long" WebIDL definition which is
	// equivalent to int32_t.
	class MODULES_EXPORT LongConstraint : public BaseConstraint {
	public:
	explicit LongConstraint(const char* name);

	void SetMin(int32_t value) {
	min_ = value;
	has_min_ = true;
	}

	void SetMax(int32_t value) {
	max_ = value;
	has_max_ = true;
	}

	void SetExact(int32_t value) {
	exact_ = value;
	has_exact_ = true;
	}

	void SetIdeal(int32_t value) {
	ideal_ = value;
	has_ideal_ = true;
	}

	bool Matches(int32_t value) const;
	bool IsUnconstrained() const override;
	bool HasMin() const override { return has_min_; }
	bool HasMax() const override { return has_max_; }
	bool HasExact() const override { return has_exact_; }
	void ResetToUnconstrained() override;
	String ToString() const override;
	int32_t Min() const { return min_; }
	int32_t Max() const { return max_; }
	int32_t Exact() const { return exact_; }
	bool HasIdeal() const { return has_ideal_; }
	int32_t Ideal() const { return ideal_; }

	private:
	int32_t min_;
	int32_t max_;
	int32_t exact_;
	int32_t ideal_;
	unsigned has_min_ : 1;
	unsigned has_max_ : 1;
	unsigned has_exact_ : 1;
	unsigned has_ideal_ : 1;
	};

	class MODULES_EXPORT DoubleConstraint : public BaseConstraint {
	public:
	// Permit a certain leeway when comparing floats. The offset of 0.00001
	// is chosen based on observed behavior of doubles formatted with
	// webrtc::ToString.
	static const double kConstraintEpsilon;

	explicit DoubleConstraint(const char* name);

	void SetMin(double value) {
	min_ = value;
	has_min_ = true;
	}

	void SetMax(double value) {
	max_ = value;
	has_max_ = true;
	}

	void SetExact(double value) {
	exact_ = value;
	has_exact_ = true;
	}

	void SetIdeal(double value) {
	ideal_ = value;
	has_ideal_ = true;
	}

	bool Matches(double value) const;
	bool IsUnconstrained() const override;
	bool HasMin() const override { return has_min_; }
	bool HasMax() const override { return has_max_; }
	bool HasExact() const override { return has_exact_; }
	void ResetToUnconstrained() override;
	String ToString() const override;
	double Min() const { return min_; }
	double Max() const { return max_; }
	double Exact() const { return exact_; }
	bool HasIdeal() const { return has_ideal_; }
	double Ideal() const { return ideal_; }

	private:
	double min_;
	double max_;
	double exact_;
	double ideal_;
	unsigned has_min_ : 1;
	unsigned has_max_ : 1;
	unsigned has_exact_ : 1;
	unsigned has_ideal_ : 1;
	};

	class MODULES_EXPORT DoubleOrBooleanConstraint : public DoubleConstraint {
	public:
	explicit DoubleOrBooleanConstraint(const char* name);

	bool HasMandatory() const override;
	bool HasExactBoolean() const { return has_exact_boolean_; }
	bool ExactBoolean() const { return exact_boolean_; }
	bool HasIdealBoolean() const { return has_ideal_boolean_; }
	bool IdealBoolean() const { return ideal_boolean_; }

	void SetExactBoolean(bool value) {
	exact_boolean_ = value;
	has_exact_boolean_ = true;
	}

	void SetIdealBoolean(bool value) {
	ideal_boolean_ = value;
	has_ideal_boolean_ = true;
	}

	bool Matches(double value) const;
	bool MatchesBoolean(bool value) const;
	bool IsPresentAndNotFalse() const;
	bool IsUnconstrained() const override;
	void ResetToUnconstrained() override;
	String ToString() const override;

	private:
	unsigned exact_boolean_ : 1 = 0;
	unsigned ideal_boolean_ : 1 = 0;
	unsigned has_exact_boolean_ : 1 = 0;
	unsigned has_ideal_boolean_ : 1 = 0;
	};

	class MODULES_EXPORT StringConstraint : public BaseConstraint {
	public:
	// String-valued options don't have min or max, but can have multiple
	// values for ideal and exact.
	explicit StringConstraint(const char* name);

	void SetExact(const String& exact) { exact_ = {exact}; }

	void SetExact(const Vector<String>& exact) { exact_ = exact; }

	void SetIdeal(const String& ideal) { ideal_ = {ideal}; }

	void SetIdeal(const Vector<String>& ideal) { ideal_ = ideal; }

	bool Matches(String value) const;
	bool IsUnconstrained() const override;
	bool HasExact() const override { return !exact_.empty(); }
	void ResetToUnconstrained() override;
	String ToString() const override;
	bool HasIdeal() const { return !ideal_.empty(); }
	const Vector<String>& Exact() const;
	const Vector<String>& Ideal() const;

	private:
	Vector<String> exact_;
	Vector<String> ideal_;
	};

	class MODULES_EXPORT BooleanConstraint : public BaseConstraint {
	public:
	explicit BooleanConstraint(const char* name);

	bool Exact() const { return exact_; }
	bool Ideal() const { return ideal_; }
	void SetIdeal(bool value) {
	ideal_ = value;
	has_ideal_ = true;
	}

	void SetExact(bool value) {
	exact_ = value;
	has_exact_ = true;
	}

	bool Matches(bool value) const;
	bool IsUnconstrained() const override;
	bool HasExact() const override { return has_exact_; }
	void ResetToUnconstrained() override;
	String ToString() const override;
	bool HasIdeal() const { return has_ideal_; }

	private:
	unsigned ideal_ : 1;
	unsigned exact_ : 1;
	unsigned has_ideal_ : 1;
	unsigned has_exact_ : 1;
	};

	class MODULES_EXPORT BooleanOrStringConstraint : public BaseConstraint {
	public:
	explicit BooleanOrStringConstraint(const char* name);

	bool HasExactBoolean() const { return has_exact_boolean_; }
	bool ExactBoolean() const { return exact_boolean_; }
	bool HasIdealBoolean() const { return has_ideal_boolean_; }
	bool IdealBoolean() const { return ideal_boolean_; }

	void SetExactBoolean(bool value) {
	exact_boolean_ = value;
	has_exact_boolean_ = true;
	}

	void SetIdealBoolean(bool value) {
	ideal_boolean_ = value;
	has_ideal_boolean_ = true;
	}

	bool HasExactString() const { return has_exact_string_; }
	String ExactString() const { return exact_string_; }
	bool HasIdealString() const { return has_ideal_string_; }
	String IdealString() const { return ideal_string_; }

	void SetExactString(const String& value) {
	exact_string_ = value;
	has_exact_string_ = true;
	}

	void SetIdealString(const String& value) {
	ideal_string_ = value;
	has_ideal_string_ = true;
	}

	// BaseConstraint overrides
	bool HasExact() const override;
	bool IsUnconstrained() const override;
	void ResetToUnconstrained() override;
	String ToString() const override;

	bool HasIdeal() const;

	private:
	unsigned exact_boolean_ : 1 = false;
	unsigned ideal_boolean_ : 1 = false;
	unsigned has_exact_boolean_ : 1 = false;
	unsigned has_ideal_boolean_ : 1 = false;
	unsigned has_exact_string_ : 1 = false;
	unsigned has_ideal_string_ : 1 = false;
	String exact_string_;
	String ideal_string_;
	};

	struct MediaTrackConstraintSetPlatform {
	public:
	MODULES_EXPORT MediaTrackConstraintSetPlatform();

	LongConstraint width;
	LongConstraint height;
	DoubleConstraint aspect_ratio;
	DoubleConstraint frame_rate;
	StringConstraint facing_mode;
	StringConstraint resize_mode;
	DoubleConstraint volume;
	LongConstraint sample_rate;
	LongConstraint sample_size;
	BooleanOrStringConstraint echo_cancellation;
	BooleanConstraint auto_gain_control;
	BooleanConstraint noise_suppression;
	BooleanConstraint voice_isolation;
	DoubleConstraint latency;
	LongConstraint channel_count;
	StringConstraint device_id;
	BooleanConstraint disable_local_echo;
	BooleanConstraint suppress_local_audio_playback;
	BooleanConstraint restrict_own_audio;
	StringConstraint group_id;
	StringConstraint display_surface;

	// W3C Image Capture
	DoubleConstraint exposure_compensation;
	DoubleConstraint exposure_time;
	DoubleConstraint color_temperature;
	DoubleConstraint iso;
	DoubleConstraint brightness;
	DoubleConstraint contrast;
	DoubleConstraint saturation;
	DoubleConstraint sharpness;
	DoubleConstraint focus_distance;
	DoubleOrBooleanConstraint pan;
	DoubleOrBooleanConstraint tilt;
	DoubleOrBooleanConstraint zoom;
	BooleanConstraint torch;

	// W3C Media Capture Extensions
	BooleanConstraint background_blur;
	BooleanConstraint background_segmentation_mask;
	BooleanConstraint eye_gaze_correction;
	BooleanConstraint face_framing;

	// Constraints not exposed in Blink at the moment, only through
	// the legacy name interface.
	StringConstraint media_stream_source; // tab, screen, desktop, system
	BooleanConstraint render_to_associated_sink;
	BooleanConstraint goog_noise_reduction;

	MODULES_EXPORT bool IsUnconstrained() const;
	MODULES_EXPORT bool HasMandatory() const;
	MODULES_EXPORT bool HasMandatoryOutsideSet(const Vector<String>&,
	String&) const;
	MODULES_EXPORT bool HasMin() const;
	MODULES_EXPORT bool HasExact() const;
	MODULES_EXPORT String ToString() const;

	private:
	Vector<const BaseConstraint*> AllConstraints() const;
	};

	class MediaConstraints {
	public:
	MODULES_EXPORT MediaConstraints();
	MediaConstraints(const MediaConstraints& other);
	~MediaConstraints() { Reset(); }

	MediaConstraints& operator=(const MediaConstraints& other) {
	Assign(other);
	return *this;
	}

	MODULES_EXPORT void Assign(const MediaConstraints&);

	MODULES_EXPORT void Reset();
	bool IsNull() const { return private_.IsNull(); }
	MODULES_EXPORT bool IsUnconstrained() const;

	MODULES_EXPORT void Initialize();
	MODULES_EXPORT void Initialize(
	const MediaTrackConstraintSetPlatform& basic,
	const Vector<MediaTrackConstraintSetPlatform>& advanced);

	MODULES_EXPORT const MediaTrackConstraintSetPlatform& Basic() const;
	MODULES_EXPORT MediaTrackConstraintSetPlatform& MutableBasic();
	MODULES_EXPORT const Vector<MediaTrackConstraintSetPlatform>& Advanced()
	const;

	MODULES_EXPORT const String ToString() const;

	private:
	WebPrivatePtrForRefCounted<MediaConstraintsPrivate> private_;
	};

	} // namespace blink

	#endif // THIRD_PARTY_BLINK_RENDERER_MODULES_MEDIASTREAM_MEDIA_CONSTRAINTS_H_