Merge "Fix/suppress libs/vr google-explicit-constructor warnings"

  bool hung_up() const { return hung_up_; }

 protected:

  BufferHubQueue(pdx::LocalChannelHandle channel);

  BufferHubQueue(const std::string& endpoint_path);

  explicit BufferHubQueue(pdx::LocalChannelHandle channel);

  explicit BufferHubQueue(const std::string& endpoint_path);

  // Imports the queue parameters by querying BufferHub for the parameters for

  // this channel.

 private:

  friend BufferHubQueue;

  ConsumerQueue(pdx::LocalChannelHandle handle);

  explicit ConsumerQueue(pdx::LocalChannelHandle handle);

  // Add a consumer buffer to populate the queue. Once added, a consumer buffer

  // is NOT available to use until the producer side |Post| it. |WaitForBuffers|

  }

  // Constructs an parcelable contains the channel parcelable.

  BufferHubQueueParcelable(

  explicit BufferHubQueueParcelable(

      std::unique_ptr<pdx::ChannelParcelable> channel_parcelable)

      : channel_parcelable_(std::move(channel_parcelable)) {}

  using Base = Flags<Integer>;

  using Type = Integer;

  // NOLINTNEXTLINE(google-explicit-constructor)

  Flags(const Integer& value) : value_{value} {}

  Flags(const Flags&) = default;

  Flags& operator=(const Flags&) = default;

  Integer value() const { return value_; }

  // NOLINTNEXTLINE(google-explicit-constructor)

  operator Integer() const { return value_; }

  bool IsSet(Integer bits) const { return (value_ & bits) == bits; }

class ChannelHandleBase {

 public:

  ChannelHandleBase() = default;

  ChannelHandleBase(const int32_t& value) : value_{value} {}

  explicit ChannelHandleBase(const int32_t& value) : value_{value} {}

  ChannelHandleBase(const ChannelHandleBase&) = delete;

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

class Transaction final : public OutputResourceMapper,

                          public InputResourceMapper {

 public:

  Transaction(Client& client);

  explicit Transaction(Client& client);

  ~Transaction();

  template <typename T>