win-Debug/gen/services/preferences/public/mojom/preferences.mojom-shared.h

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

#ifndef SERVICES_PREFERENCES_PUBLIC_MOJOM_PREFERENCES_MOJOM_SHARED_H_
#define SERVICES_PREFERENCES_PUBLIC_MOJOM_PREFERENCES_MOJOM_SHARED_H_

#include <stdint.h>

#include <functional>
#include <ostream>
#include <type_traits>
#include <utility>

#include "base/compiler_specific.h"
#include "base/containers/flat_map.h"
#include "mojo/public/cpp/bindings/array_data_view.h"
#include "mojo/public/cpp/bindings/enum_traits.h"
#include "mojo/public/cpp/bindings/interface_data_view.h"
#include "mojo/public/cpp/bindings/lib/bindings_internal.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"
#include "mojo/public/cpp/bindings/map_data_view.h"
#include "mojo/public/cpp/bindings/string_data_view.h"
#include "services/preferences/public/mojom/preferences.mojom-shared-internal.h"
#include "mojo/public/mojom/base/file_path.mojom-shared.h"
#include "mojo/public/mojom/base/string16.mojom-shared.h"
#include "mojo/public/mojom/base/values.mojom-shared.h"
#include "services/preferences/public/mojom/tracked_preference_validation_delegate.mojom-shared.h"

#include "mojo/public/cpp/bindings/lib/interface_serialization.h"


#include "mojo/public/cpp/bindings/native_enum.h"
#include "mojo/public/cpp/bindings/lib/native_struct_serialization.h"

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


namespace prefs {
namespace mojom {
class PrefStoreConnectionDataView;

class PersistentPrefStoreConnectionDataView;

class IncognitoPersistentPrefStoreConnectionDataView;

class SubPrefUpdateDataView;

class PrefUpdateDataView;

class PrefRegistryDataView;

class PrefRegistrationDataView;

class TrackedPersistentPrefStoreConfigurationDataView;

class TrackedPreferenceMetadataDataView;

class PrefUpdateValueDataView;


}  // namespace mojom
}  // namespace prefs

namespace mojo {
namespace internal {

template <>
struct MojomTypeTraits<::prefs::mojom::PrefStoreConnectionDataView> {
  using Data = ::prefs::mojom::internal::PrefStoreConnection_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::STRUCT;
};

template <>
struct MojomTypeTraits<::prefs::mojom::PersistentPrefStoreConnectionDataView> {
  using Data = ::prefs::mojom::internal::PersistentPrefStoreConnection_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::STRUCT;
};

template <>
struct MojomTypeTraits<::prefs::mojom::IncognitoPersistentPrefStoreConnectionDataView> {
  using Data = ::prefs::mojom::internal::IncognitoPersistentPrefStoreConnection_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::STRUCT;
};

template <>
struct MojomTypeTraits<::prefs::mojom::SubPrefUpdateDataView> {
  using Data = ::prefs::mojom::internal::SubPrefUpdate_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::STRUCT;
};

template <>
struct MojomTypeTraits<::prefs::mojom::PrefUpdateDataView> {
  using Data = ::prefs::mojom::internal::PrefUpdate_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::STRUCT;
};

template <>
struct MojomTypeTraits<::prefs::mojom::PrefRegistryDataView> {
  using Data = ::prefs::mojom::internal::PrefRegistry_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::STRUCT;
};

template <>
struct MojomTypeTraits<::prefs::mojom::PrefRegistrationDataView> {
  using Data = ::prefs::mojom::internal::PrefRegistration_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::STRUCT;
};

template <>
struct MojomTypeTraits<::prefs::mojom::TrackedPersistentPrefStoreConfigurationDataView> {
  using Data = ::prefs::mojom::internal::TrackedPersistentPrefStoreConfiguration_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::STRUCT;
};

template <>
struct MojomTypeTraits<::prefs::mojom::TrackedPreferenceMetadataDataView> {
  using Data = ::prefs::mojom::internal::TrackedPreferenceMetadata_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::STRUCT;
};

template <>
struct MojomTypeTraits<::prefs::mojom::PrefUpdateValueDataView> {
  using Data = ::prefs::mojom::internal::PrefUpdateValue_Data;
  using DataAsArrayElement = Data;
  static constexpr MojomTypeCategory category = MojomTypeCategory::UNION;
};

}  // namespace internal
}  // namespace mojo


namespace prefs {
namespace mojom {


// @generated_from: prefs.mojom.PrefStoreType
enum class PrefStoreType : int32_t {
  
// @generated_from: prefs.mojom.PrefStoreType.MANAGED
  MANAGED,
  
// @generated_from: prefs.mojom.PrefStoreType.SUPERVISED_USER
  SUPERVISED_USER,
  
// @generated_from: prefs.mojom.PrefStoreType.EXTENSION
  EXTENSION,
  
// @generated_from: prefs.mojom.PrefStoreType.COMMAND_LINE
  COMMAND_LINE,
  
// @generated_from: prefs.mojom.PrefStoreType.USER
  USER,
  
// @generated_from: prefs.mojom.PrefStoreType.RECOMMENDED
  RECOMMENDED,
  
// @generated_from: prefs.mojom.PrefStoreType.DEFAULT
  DEFAULT,
  kMinValue = 0,
  kMaxValue = 6,
};

 std::ostream& operator<<(std::ostream& os, PrefStoreType value);
inline bool IsKnownEnumValue(PrefStoreType value) {
  return internal::PrefStoreType_Data::IsKnownValue(
      static_cast<int32_t>(value));
}


// @generated_from: prefs.mojom.PersistentPrefStoreConnection.ReadError
enum class PersistentPrefStoreConnection_ReadError : int32_t {
  
// @generated_from: prefs.mojom.PersistentPrefStoreConnection.ReadError.NONE
  NONE = 0,
  
// @generated_from: prefs.mojom.PersistentPrefStoreConnection.ReadError.JSON_PARSE
  JSON_PARSE = 1,
  
// @generated_from: prefs.mojom.PersistentPrefStoreConnection.ReadError.JSON_TYPE
  JSON_TYPE = 2,
  
// @generated_from: prefs.mojom.PersistentPrefStoreConnection.ReadError.ACCESS_DENIED
  ACCESS_DENIED = 3,
  
// @generated_from: prefs.mojom.PersistentPrefStoreConnection.ReadError.FILE_OTHER
  FILE_OTHER = 4,
  
// @generated_from: prefs.mojom.PersistentPrefStoreConnection.ReadError.FILE_LOCKED
  FILE_LOCKED = 5,
  
// @generated_from: prefs.mojom.PersistentPrefStoreConnection.ReadError.NO_FILE
  NO_FILE = 6,
  
// @generated_from: prefs.mojom.PersistentPrefStoreConnection.ReadError.JSON_REPEAT
  JSON_REPEAT = 7,
  
// @generated_from: prefs.mojom.PersistentPrefStoreConnection.ReadError.FILE_NOT_SPECIFIED
  FILE_NOT_SPECIFIED = 9,
  
// @generated_from: prefs.mojom.PersistentPrefStoreConnection.ReadError.ASYNCHRONOUS_TASK_INCOMPLETE
  ASYNCHRONOUS_TASK_INCOMPLETE = 10,
  kMinValue = 0,
  kMaxValue = 10,
};

 std::ostream& operator<<(std::ostream& os, PersistentPrefStoreConnection_ReadError value);
inline bool IsKnownEnumValue(PersistentPrefStoreConnection_ReadError value) {
  return internal::PersistentPrefStoreConnection_ReadError_Data::IsKnownValue(
      static_cast<int32_t>(value));
}


// @generated_from: prefs.mojom.TrackedPreferenceMetadata.EnforcementLevel
enum class TrackedPreferenceMetadata_EnforcementLevel : int32_t {
  
// @generated_from: prefs.mojom.TrackedPreferenceMetadata.EnforcementLevel.NO_ENFORCEMENT
  NO_ENFORCEMENT,
  
// @generated_from: prefs.mojom.TrackedPreferenceMetadata.EnforcementLevel.ENFORCE_ON_LOAD
  ENFORCE_ON_LOAD,
  kMinValue = 0,
  kMaxValue = 1,
};

 std::ostream& operator<<(std::ostream& os, TrackedPreferenceMetadata_EnforcementLevel value);
inline bool IsKnownEnumValue(TrackedPreferenceMetadata_EnforcementLevel value) {
  return internal::TrackedPreferenceMetadata_EnforcementLevel_Data::IsKnownValue(
      static_cast<int32_t>(value));
}


// @generated_from: prefs.mojom.TrackedPreferenceMetadata.PrefTrackingStrategy
enum class TrackedPreferenceMetadata_PrefTrackingStrategy : int32_t {
  
// @generated_from: prefs.mojom.TrackedPreferenceMetadata.PrefTrackingStrategy.ATOMIC
  ATOMIC,
  
// @generated_from: prefs.mojom.TrackedPreferenceMetadata.PrefTrackingStrategy.SPLIT
  SPLIT,
  kMinValue = 0,
  kMaxValue = 1,
};

 std::ostream& operator<<(std::ostream& os, TrackedPreferenceMetadata_PrefTrackingStrategy value);
inline bool IsKnownEnumValue(TrackedPreferenceMetadata_PrefTrackingStrategy value) {
  return internal::TrackedPreferenceMetadata_PrefTrackingStrategy_Data::IsKnownValue(
      static_cast<int32_t>(value));
}


// @generated_from: prefs.mojom.TrackedPreferenceMetadata.ValueType
enum class TrackedPreferenceMetadata_ValueType : int32_t {
  
// @generated_from: prefs.mojom.TrackedPreferenceMetadata.ValueType.IMPERSONAL
  IMPERSONAL,
  
// @generated_from: prefs.mojom.TrackedPreferenceMetadata.ValueType.PERSONAL
  PERSONAL,
  kMinValue = 0,
  kMaxValue = 1,
};

 std::ostream& operator<<(std::ostream& os, TrackedPreferenceMetadata_ValueType value);
inline bool IsKnownEnumValue(TrackedPreferenceMetadata_ValueType value) {
  return internal::TrackedPreferenceMetadata_ValueType_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
// Interface base classes. They are used for type safety check.
class PrefStoreObserverInterfaceBase {};

using PrefStoreObserverPtrDataView =
    mojo::InterfacePtrDataView<PrefStoreObserverInterfaceBase>;
using PrefStoreObserverRequestDataView =
    mojo::InterfaceRequestDataView<PrefStoreObserverInterfaceBase>;
using PrefStoreObserverAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<PrefStoreObserverInterfaceBase>;
using PrefStoreObserverAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<PrefStoreObserverInterfaceBase>;
class PrefStoreConnectorInterfaceBase {};

using PrefStoreConnectorPtrDataView =
    mojo::InterfacePtrDataView<PrefStoreConnectorInterfaceBase>;
using PrefStoreConnectorRequestDataView =
    mojo::InterfaceRequestDataView<PrefStoreConnectorInterfaceBase>;
using PrefStoreConnectorAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<PrefStoreConnectorInterfaceBase>;
using PrefStoreConnectorAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<PrefStoreConnectorInterfaceBase>;
class PersistentPrefStoreInterfaceBase {};

using PersistentPrefStorePtrDataView =
    mojo::InterfacePtrDataView<PersistentPrefStoreInterfaceBase>;
using PersistentPrefStoreRequestDataView =
    mojo::InterfaceRequestDataView<PersistentPrefStoreInterfaceBase>;
using PersistentPrefStoreAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<PersistentPrefStoreInterfaceBase>;
using PersistentPrefStoreAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<PersistentPrefStoreInterfaceBase>;
class ResetOnLoadObserverInterfaceBase {};

using ResetOnLoadObserverPtrDataView =
    mojo::InterfacePtrDataView<ResetOnLoadObserverInterfaceBase>;
using ResetOnLoadObserverRequestDataView =
    mojo::InterfaceRequestDataView<ResetOnLoadObserverInterfaceBase>;
using ResetOnLoadObserverAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<ResetOnLoadObserverInterfaceBase>;
using ResetOnLoadObserverAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<ResetOnLoadObserverInterfaceBase>;
class PrefStoreConnectionDataView {
 public:
  PrefStoreConnectionDataView() {}

  PrefStoreConnectionDataView(
      internal::PrefStoreConnection_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  UserType TakeObserver() {
    UserType result;
    bool ret =
        mojo::internal::Deserialize<::prefs::mojom::PrefStoreObserverRequestDataView>(
            &data_->observer, &result, context_);
    DCHECK(ret);
    return result;
  }
  inline void GetInitialPrefsDataView(
      ::mojo_base::mojom::DictionaryValueDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadInitialPrefs(UserType* output) {
    auto* pointer = data_->initial_prefs.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::DictionaryValueDataView>(
        pointer, output, context_);
  }
  bool is_initialized() const {
    return data_->is_initialized;
  }
 private:
  internal::PrefStoreConnection_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};

class PersistentPrefStoreConnectionDataView {
 public:
  PersistentPrefStoreConnectionDataView() {}

  PersistentPrefStoreConnectionDataView(
      internal::PersistentPrefStoreConnection_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  inline void GetPrefStoreConnectionDataView(
      PrefStoreConnectionDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadPrefStoreConnection(UserType* output) {
    auto* pointer = data_->pref_store_connection.Get();
    return mojo::internal::Deserialize<::prefs::mojom::PrefStoreConnectionDataView>(
        pointer, output, context_);
  }
  template <typename UserType>
  UserType TakePrefStore() {
    UserType result;
    bool ret =
        mojo::internal::Deserialize<::prefs::mojom::PersistentPrefStorePtrDataView>(
            &data_->pref_store, &result, context_);
    DCHECK(ret);
    return result;
  }
  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadReadError(UserType* output) const {
    auto data_value = data_->read_error;
    return mojo::internal::Deserialize<::prefs::mojom::PersistentPrefStoreConnection_ReadError>(
        data_value, output);
  }

  PersistentPrefStoreConnection_ReadError read_error() const {
    return static_cast<PersistentPrefStoreConnection_ReadError>(data_->read_error);
  }
  bool read_only() const {
    return data_->read_only;
  }
 private:
  internal::PersistentPrefStoreConnection_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};

class IncognitoPersistentPrefStoreConnectionDataView {
 public:
  IncognitoPersistentPrefStoreConnectionDataView() {}

  IncognitoPersistentPrefStoreConnectionDataView(
      internal::IncognitoPersistentPrefStoreConnection_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  inline void GetPrefStoreConnectionDataView(
      PersistentPrefStoreConnectionDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadPrefStoreConnection(UserType* output) {
    auto* pointer = data_->pref_store_connection.Get();
    return mojo::internal::Deserialize<::prefs::mojom::PersistentPrefStoreConnectionDataView>(
        pointer, output, context_);
  }
  inline void GetPersistentPrefNamesDataView(
      mojo::ArrayDataView<mojo::StringDataView>* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadPersistentPrefNames(UserType* output) {
    auto* pointer = data_->persistent_pref_names.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<mojo::StringDataView>>(
        pointer, output, context_);
  }
 private:
  internal::IncognitoPersistentPrefStoreConnection_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};

class SubPrefUpdateDataView {
 public:
  SubPrefUpdateDataView() {}

  SubPrefUpdateDataView(
      internal::SubPrefUpdate_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  inline void GetPathDataView(
      mojo::ArrayDataView<mojo::StringDataView>* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadPath(UserType* output) {
    auto* pointer = data_->path.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<mojo::StringDataView>>(
        pointer, output, context_);
  }
  inline void GetValueDataView(
      ::mojo_base::mojom::ValueDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadValue(UserType* output) {
    auto* pointer = !data_->value.is_null() ? &data_->value : nullptr;
    return mojo::internal::Deserialize<::mojo_base::mojom::ValueDataView>(
        pointer, output, context_);
  }
 private:
  internal::SubPrefUpdate_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};

class PrefUpdateDataView {
 public:
  PrefUpdateDataView() {}

  PrefUpdateDataView(
      internal::PrefUpdate_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  inline void GetKeyDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadKey(UserType* output) {
    auto* pointer = data_->key.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, context_);
  }
  inline void GetValueDataView(
      PrefUpdateValueDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadValue(UserType* output) {
    auto* pointer = !data_->value.is_null() ? &data_->value : nullptr;
    return mojo::internal::Deserialize<::prefs::mojom::PrefUpdateValueDataView>(
        pointer, output, context_);
  }
  uint32_t flags() const {
    return data_->flags;
  }
 private:
  internal::PrefUpdate_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};

class PrefRegistryDataView {
 public:
  PrefRegistryDataView() {}

  PrefRegistryDataView(
      internal::PrefRegistry_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  inline void GetPrivateRegistrationsDataView(
      mojo::ArrayDataView<mojo::StringDataView>* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadPrivateRegistrations(UserType* output) {
    auto* pointer = data_->private_registrations.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<mojo::StringDataView>>(
        pointer, output, context_);
  }
  inline void GetForeignRegistrationsDataView(
      mojo::ArrayDataView<mojo::StringDataView>* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadForeignRegistrations(UserType* output) {
    auto* pointer = data_->foreign_registrations.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<mojo::StringDataView>>(
        pointer, output, context_);
  }
  inline void GetPublicRegistrationsDataView(
      mojo::ArrayDataView<PrefRegistrationDataView>* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadPublicRegistrations(UserType* output) {
    auto* pointer = data_->public_registrations.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<::prefs::mojom::PrefRegistrationDataView>>(
        pointer, output, context_);
  }
 private:
  internal::PrefRegistry_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};

class PrefRegistrationDataView {
 public:
  PrefRegistrationDataView() {}

  PrefRegistrationDataView(
      internal::PrefRegistration_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  inline void GetKeyDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadKey(UserType* output) {
    auto* pointer = data_->key.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, context_);
  }
  inline void GetDefaultValueDataView(
      ::mojo_base::mojom::ValueDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadDefaultValue(UserType* output) {
    auto* pointer = !data_->default_value.is_null() ? &data_->default_value : nullptr;
    return mojo::internal::Deserialize<::mojo_base::mojom::ValueDataView>(
        pointer, output, context_);
  }
  uint32_t flags() const {
    return data_->flags;
  }
 private:
  internal::PrefRegistration_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};

class TrackedPersistentPrefStoreConfigurationDataView {
 public:
  TrackedPersistentPrefStoreConfigurationDataView() {}

  TrackedPersistentPrefStoreConfigurationDataView(
      internal::TrackedPersistentPrefStoreConfiguration_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  inline void GetUnprotectedPrefFilenameDataView(
      ::mojo_base::mojom::FilePathDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadUnprotectedPrefFilename(UserType* output) {
    auto* pointer = data_->unprotected_pref_filename.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::FilePathDataView>(
        pointer, output, context_);
  }
  inline void GetProtectedPrefFilenameDataView(
      ::mojo_base::mojom::FilePathDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadProtectedPrefFilename(UserType* output) {
    auto* pointer = data_->protected_pref_filename.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::FilePathDataView>(
        pointer, output, context_);
  }
  inline void GetTrackingConfigurationDataView(
      mojo::ArrayDataView<TrackedPreferenceMetadataDataView>* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadTrackingConfiguration(UserType* output) {
    auto* pointer = data_->tracking_configuration.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<::prefs::mojom::TrackedPreferenceMetadataDataView>>(
        pointer, output, context_);
  }
  uint64_t reporting_ids_count() const {
    return data_->reporting_ids_count;
  }
  inline void GetSeedDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadSeed(UserType* output) {
    auto* pointer = data_->seed.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, context_);
  }
  inline void GetLegacyDeviceIdDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadLegacyDeviceId(UserType* output) {
    auto* pointer = data_->legacy_device_id.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, context_);
  }
  inline void GetRegistrySeedDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadRegistrySeed(UserType* output) {
    auto* pointer = data_->registry_seed.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, context_);
  }
  inline void GetRegistryPathDataView(
      ::mojo_base::mojom::String16DataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadRegistryPath(UserType* output) {
    auto* pointer = data_->registry_path.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::String16DataView>(
        pointer, output, context_);
  }
  template <typename UserType>
  UserType TakeValidationDelegate() {
    UserType result;
    bool ret =
        mojo::internal::Deserialize<::prefs::mojom::TrackedPreferenceValidationDelegatePtrDataView>(
            &data_->validation_delegate, &result, context_);
    DCHECK(ret);
    return result;
  }
  template <typename UserType>
  UserType TakeResetOnLoadObserver() {
    UserType result;
    bool ret =
        mojo::internal::Deserialize<::prefs::mojom::ResetOnLoadObserverPtrDataView>(
            &data_->reset_on_load_observer, &result, context_);
    DCHECK(ret);
    return result;
  }
 private:
  internal::TrackedPersistentPrefStoreConfiguration_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};

class TrackedPreferenceMetadataDataView {
 public:
  TrackedPreferenceMetadataDataView() {}

  TrackedPreferenceMetadataDataView(
      internal::TrackedPreferenceMetadata_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const { return !data_; }
  uint64_t reporting_id() const {
    return data_->reporting_id;
  }
  inline void GetNameDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadName(UserType* output) {
    auto* pointer = data_->name.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, context_);
  }
  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadEnforcementLevel(UserType* output) const {
    auto data_value = data_->enforcement_level;
    return mojo::internal::Deserialize<::prefs::mojom::TrackedPreferenceMetadata_EnforcementLevel>(
        data_value, output);
  }

  TrackedPreferenceMetadata_EnforcementLevel enforcement_level() const {
    return static_cast<TrackedPreferenceMetadata_EnforcementLevel>(data_->enforcement_level);
  }
  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadStrategy(UserType* output) const {
    auto data_value = data_->strategy;
    return mojo::internal::Deserialize<::prefs::mojom::TrackedPreferenceMetadata_PrefTrackingStrategy>(
        data_value, output);
  }

  TrackedPreferenceMetadata_PrefTrackingStrategy strategy() const {
    return static_cast<TrackedPreferenceMetadata_PrefTrackingStrategy>(data_->strategy);
  }
  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadValueType(UserType* output) const {
    auto data_value = data_->value_type;
    return mojo::internal::Deserialize<::prefs::mojom::TrackedPreferenceMetadata_ValueType>(
        data_value, output);
  }

  TrackedPreferenceMetadata_ValueType value_type() const {
    return static_cast<TrackedPreferenceMetadata_ValueType>(data_->value_type);
  }
 private:
  internal::TrackedPreferenceMetadata_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};

class PrefUpdateValueDataView {
 public:
  using Tag = internal::PrefUpdateValue_Data::PrefUpdateValue_Tag;

  PrefUpdateValueDataView() {}

  PrefUpdateValueDataView(
      internal::PrefUpdateValue_Data* data,
      mojo::internal::SerializationContext* context)
      : data_(data), context_(context) {}

  bool is_null() const {
    // For inlined unions, |data_| is always non-null. In that case we need to
    // check |data_->is_null()|.
    return !data_ || data_->is_null();
  }

  Tag tag() const { return data_->tag; }
  bool is_split_updates() const { return data_->tag == Tag::SPLIT_UPDATES; }
  inline void GetSplitUpdatesDataView(
      mojo::ArrayDataView<SubPrefUpdateDataView>* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadSplitUpdates(UserType* output) {
    DCHECK(is_split_updates());
    return mojo::internal::Deserialize<mojo::ArrayDataView<::prefs::mojom::SubPrefUpdateDataView>>(
        data_->data.f_split_updates.Get(), output, context_);
  }
  bool is_atomic_update() const { return data_->tag == Tag::ATOMIC_UPDATE; }
  inline void GetAtomicUpdateDataView(
      ::mojo_base::mojom::ValueDataView* output);

  template <typename UserType>
  WARN_UNUSED_RESULT bool ReadAtomicUpdate(UserType* output) {
    DCHECK(is_atomic_update());
    return mojo::internal::Deserialize<::mojo_base::mojom::ValueDataView>(
        data_->data.f_atomic_update.Get(), output, context_);
  }

 private:
  internal::PrefUpdateValue_Data* data_ = nullptr;
  mojo::internal::SerializationContext* context_ = nullptr;
};



}  // namespace mojom
}  // namespace prefs

namespace std {

template <>
struct hash<::prefs::mojom::PrefStoreType>
    : public mojo::internal::EnumHashImpl<::prefs::mojom::PrefStoreType> {};

template <>
struct hash<::prefs::mojom::PersistentPrefStoreConnection_ReadError>
    : public mojo::internal::EnumHashImpl<::prefs::mojom::PersistentPrefStoreConnection_ReadError> {};

template <>
struct hash<::prefs::mojom::TrackedPreferenceMetadata_EnforcementLevel>
    : public mojo::internal::EnumHashImpl<::prefs::mojom::TrackedPreferenceMetadata_EnforcementLevel> {};

template <>
struct hash<::prefs::mojom::TrackedPreferenceMetadata_PrefTrackingStrategy>
    : public mojo::internal::EnumHashImpl<::prefs::mojom::TrackedPreferenceMetadata_PrefTrackingStrategy> {};

template <>
struct hash<::prefs::mojom::TrackedPreferenceMetadata_ValueType>
    : public mojo::internal::EnumHashImpl<::prefs::mojom::TrackedPreferenceMetadata_ValueType> {};

}  // namespace std

namespace mojo {


template <>
struct EnumTraits<::prefs::mojom::PrefStoreType, ::prefs::mojom::PrefStoreType> {
  static ::prefs::mojom::PrefStoreType ToMojom(::prefs::mojom::PrefStoreType input) { return input; }
  static bool FromMojom(::prefs::mojom::PrefStoreType input, ::prefs::mojom::PrefStoreType* output) {
    *output = input;
    return true;
  }
};

namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::prefs::mojom::PrefStoreType, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::prefs::mojom::PrefStoreType, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    return Traits::FromMojom(static_cast<::prefs::mojom::PrefStoreType>(input), output);
  }
};

}  // namespace internal


template <>
struct EnumTraits<::prefs::mojom::PersistentPrefStoreConnection_ReadError, ::prefs::mojom::PersistentPrefStoreConnection_ReadError> {
  static ::prefs::mojom::PersistentPrefStoreConnection_ReadError ToMojom(::prefs::mojom::PersistentPrefStoreConnection_ReadError input) { return input; }
  static bool FromMojom(::prefs::mojom::PersistentPrefStoreConnection_ReadError input, ::prefs::mojom::PersistentPrefStoreConnection_ReadError* output) {
    *output = input;
    return true;
  }
};

namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::prefs::mojom::PersistentPrefStoreConnection_ReadError, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::prefs::mojom::PersistentPrefStoreConnection_ReadError, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    return Traits::FromMojom(static_cast<::prefs::mojom::PersistentPrefStoreConnection_ReadError>(input), output);
  }
};

}  // namespace internal


template <>
struct EnumTraits<::prefs::mojom::TrackedPreferenceMetadata_EnforcementLevel, ::prefs::mojom::TrackedPreferenceMetadata_EnforcementLevel> {
  static ::prefs::mojom::TrackedPreferenceMetadata_EnforcementLevel ToMojom(::prefs::mojom::TrackedPreferenceMetadata_EnforcementLevel input) { return input; }
  static bool FromMojom(::prefs::mojom::TrackedPreferenceMetadata_EnforcementLevel input, ::prefs::mojom::TrackedPreferenceMetadata_EnforcementLevel* output) {
    *output = input;
    return true;
  }
};

namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::prefs::mojom::TrackedPreferenceMetadata_EnforcementLevel, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::prefs::mojom::TrackedPreferenceMetadata_EnforcementLevel, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    return Traits::FromMojom(static_cast<::prefs::mojom::TrackedPreferenceMetadata_EnforcementLevel>(input), output);
  }
};

}  // namespace internal


template <>
struct EnumTraits<::prefs::mojom::TrackedPreferenceMetadata_PrefTrackingStrategy, ::prefs::mojom::TrackedPreferenceMetadata_PrefTrackingStrategy> {
  static ::prefs::mojom::TrackedPreferenceMetadata_PrefTrackingStrategy ToMojom(::prefs::mojom::TrackedPreferenceMetadata_PrefTrackingStrategy input) { return input; }
  static bool FromMojom(::prefs::mojom::TrackedPreferenceMetadata_PrefTrackingStrategy input, ::prefs::mojom::TrackedPreferenceMetadata_PrefTrackingStrategy* output) {
    *output = input;
    return true;
  }
};

namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::prefs::mojom::TrackedPreferenceMetadata_PrefTrackingStrategy, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::prefs::mojom::TrackedPreferenceMetadata_PrefTrackingStrategy, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    return Traits::FromMojom(static_cast<::prefs::mojom::TrackedPreferenceMetadata_PrefTrackingStrategy>(input), output);
  }
};

}  // namespace internal


template <>
struct EnumTraits<::prefs::mojom::TrackedPreferenceMetadata_ValueType, ::prefs::mojom::TrackedPreferenceMetadata_ValueType> {
  static ::prefs::mojom::TrackedPreferenceMetadata_ValueType ToMojom(::prefs::mojom::TrackedPreferenceMetadata_ValueType input) { return input; }
  static bool FromMojom(::prefs::mojom::TrackedPreferenceMetadata_ValueType input, ::prefs::mojom::TrackedPreferenceMetadata_ValueType* output) {
    *output = input;
    return true;
  }
};

namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::prefs::mojom::TrackedPreferenceMetadata_ValueType, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::prefs::mojom::TrackedPreferenceMetadata_ValueType, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    return Traits::FromMojom(static_cast<::prefs::mojom::TrackedPreferenceMetadata_ValueType>(input), output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::prefs::mojom::PrefStoreConnectionDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::prefs::mojom::PrefStoreConnectionDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        Buffer* buffer,
                        ::prefs::mojom::internal::PrefStoreConnection_Data::BufferWriter* output,
                        SerializationContext* context) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    (*output).Allocate(buffer);
    decltype(Traits::observer(input)) in_observer = Traits::observer(input);
    mojo::internal::Serialize<::prefs::mojom::PrefStoreObserverRequestDataView>(
        in_observer, &(*output)->observer, context);
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        !mojo::internal::IsHandleOrInterfaceValid((*output)->observer),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
        "invalid observer in PrefStoreConnection struct");
    decltype(Traits::initial_prefs(input)) in_initial_prefs = Traits::initial_prefs(input);
    typename decltype((*output)->initial_prefs)::BaseType::BufferWriter
        initial_prefs_writer;
    mojo::internal::Serialize<::mojo_base::mojom::DictionaryValueDataView>(
        in_initial_prefs, buffer, &initial_prefs_writer, context);
    (*output)->initial_prefs.Set(
        initial_prefs_writer.is_null() ? nullptr : initial_prefs_writer.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->initial_prefs.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null initial_prefs in PrefStoreConnection struct");
    (*output)->is_initialized = Traits::is_initialized(input);
  }

  static bool Deserialize(::prefs::mojom::internal::PrefStoreConnection_Data* input,
                          UserType* output,
                          SerializationContext* context) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::prefs::mojom::PrefStoreConnectionDataView data_view(input, context);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::prefs::mojom::PersistentPrefStoreConnectionDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::prefs::mojom::PersistentPrefStoreConnectionDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        Buffer* buffer,
                        ::prefs::mojom::internal::PersistentPrefStoreConnection_Data::BufferWriter* output,
                        SerializationContext* context) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    (*output).Allocate(buffer);
    decltype(Traits::pref_store_connection(input)) in_pref_store_connection = Traits::pref_store_connection(input);
    typename decltype((*output)->pref_store_connection)::BaseType::BufferWriter
        pref_store_connection_writer;
    mojo::internal::Serialize<::prefs::mojom::PrefStoreConnectionDataView>(
        in_pref_store_connection, buffer, &pref_store_connection_writer, context);
    (*output)->pref_store_connection.Set(
        pref_store_connection_writer.is_null() ? nullptr : pref_store_connection_writer.data());
    decltype(Traits::pref_store(input)) in_pref_store = Traits::pref_store(input);
    mojo::internal::Serialize<::prefs::mojom::PersistentPrefStorePtrDataView>(
        in_pref_store, &(*output)->pref_store, context);
    mojo::internal::Serialize<::prefs::mojom::PersistentPrefStoreConnection_ReadError>(
        Traits::read_error(input), &(*output)->read_error);
    (*output)->read_only = Traits::read_only(input);
  }

  static bool Deserialize(::prefs::mojom::internal::PersistentPrefStoreConnection_Data* input,
                          UserType* output,
                          SerializationContext* context) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::prefs::mojom::PersistentPrefStoreConnectionDataView data_view(input, context);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::prefs::mojom::IncognitoPersistentPrefStoreConnectionDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::prefs::mojom::IncognitoPersistentPrefStoreConnectionDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        Buffer* buffer,
                        ::prefs::mojom::internal::IncognitoPersistentPrefStoreConnection_Data::BufferWriter* output,
                        SerializationContext* context) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    (*output).Allocate(buffer);
    decltype(Traits::pref_store_connection(input)) in_pref_store_connection = Traits::pref_store_connection(input);
    typename decltype((*output)->pref_store_connection)::BaseType::BufferWriter
        pref_store_connection_writer;
    mojo::internal::Serialize<::prefs::mojom::PersistentPrefStoreConnectionDataView>(
        in_pref_store_connection, buffer, &pref_store_connection_writer, context);
    (*output)->pref_store_connection.Set(
        pref_store_connection_writer.is_null() ? nullptr : pref_store_connection_writer.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->pref_store_connection.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null pref_store_connection in IncognitoPersistentPrefStoreConnection struct");
    decltype(Traits::persistent_pref_names(input)) in_persistent_pref_names = Traits::persistent_pref_names(input);
    typename decltype((*output)->persistent_pref_names)::BaseType::BufferWriter
        persistent_pref_names_writer;
    const mojo::internal::ContainerValidateParams persistent_pref_names_validate_params(
        0, false, new mojo::internal::ContainerValidateParams(0, false, nullptr));
    mojo::internal::Serialize<mojo::ArrayDataView<mojo::StringDataView>>(
        in_persistent_pref_names, buffer, &persistent_pref_names_writer, &persistent_pref_names_validate_params,
        context);
    (*output)->persistent_pref_names.Set(
        persistent_pref_names_writer.is_null() ? nullptr : persistent_pref_names_writer.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->persistent_pref_names.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null persistent_pref_names in IncognitoPersistentPrefStoreConnection struct");
  }

  static bool Deserialize(::prefs::mojom::internal::IncognitoPersistentPrefStoreConnection_Data* input,
                          UserType* output,
                          SerializationContext* context) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::prefs::mojom::IncognitoPersistentPrefStoreConnectionDataView data_view(input, context);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::prefs::mojom::SubPrefUpdateDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::prefs::mojom::SubPrefUpdateDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        Buffer* buffer,
                        ::prefs::mojom::internal::SubPrefUpdate_Data::BufferWriter* output,
                        SerializationContext* context) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    (*output).Allocate(buffer);
    decltype(Traits::path(input)) in_path = Traits::path(input);
    typename decltype((*output)->path)::BaseType::BufferWriter
        path_writer;
    const mojo::internal::ContainerValidateParams path_validate_params(
        0, false, new mojo::internal::ContainerValidateParams(0, false, nullptr));
    mojo::internal::Serialize<mojo::ArrayDataView<mojo::StringDataView>>(
        in_path, buffer, &path_writer, &path_validate_params,
        context);
    (*output)->path.Set(
        path_writer.is_null() ? nullptr : path_writer.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->path.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null path in SubPrefUpdate struct");
    decltype(Traits::value(input)) in_value = Traits::value(input);
    typename decltype((*output)->value)::BufferWriter value_writer;
    value_writer.AllocateInline(buffer, &(*output)->value);
    mojo::internal::Serialize<::mojo_base::mojom::ValueDataView>(
        in_value, buffer, &value_writer, true, context);
  }

  static bool Deserialize(::prefs::mojom::internal::SubPrefUpdate_Data* input,
                          UserType* output,
                          SerializationContext* context) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::prefs::mojom::SubPrefUpdateDataView data_view(input, context);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::prefs::mojom::PrefUpdateDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::prefs::mojom::PrefUpdateDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        Buffer* buffer,
                        ::prefs::mojom::internal::PrefUpdate_Data::BufferWriter* output,
                        SerializationContext* context) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    (*output).Allocate(buffer);
    decltype(Traits::key(input)) in_key = Traits::key(input);
    typename decltype((*output)->key)::BaseType::BufferWriter
        key_writer;
    mojo::internal::Serialize<mojo::StringDataView>(
        in_key, buffer, &key_writer, context);
    (*output)->key.Set(
        key_writer.is_null() ? nullptr : key_writer.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->key.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null key in PrefUpdate struct");
    decltype(Traits::value(input)) in_value = Traits::value(input);
    typename decltype((*output)->value)::BufferWriter value_writer;
    value_writer.AllocateInline(buffer, &(*output)->value);
    mojo::internal::Serialize<::prefs::mojom::PrefUpdateValueDataView>(
        in_value, buffer, &value_writer, true, context);
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->value.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null value in PrefUpdate struct");
    (*output)->flags = Traits::flags(input);
  }

  static bool Deserialize(::prefs::mojom::internal::PrefUpdate_Data* input,
                          UserType* output,
                          SerializationContext* context) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::prefs::mojom::PrefUpdateDataView data_view(input, context);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::prefs::mojom::PrefRegistryDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::prefs::mojom::PrefRegistryDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        Buffer* buffer,
                        ::prefs::mojom::internal::PrefRegistry_Data::BufferWriter* output,
                        SerializationContext* context) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    (*output).Allocate(buffer);
    decltype(Traits::private_registrations(input)) in_private_registrations = Traits::private_registrations(input);
    typename decltype((*output)->private_registrations)::BaseType::BufferWriter
        private_registrations_writer;
    const mojo::internal::ContainerValidateParams private_registrations_validate_params(
        0, false, new mojo::internal::ContainerValidateParams(0, false, nullptr));
    mojo::internal::Serialize<mojo::ArrayDataView<mojo::StringDataView>>(
        in_private_registrations, buffer, &private_registrations_writer, &private_registrations_validate_params,
        context);
    (*output)->private_registrations.Set(
        private_registrations_writer.is_null() ? nullptr : private_registrations_writer.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->private_registrations.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null private_registrations in PrefRegistry struct");
    decltype(Traits::foreign_registrations(input)) in_foreign_registrations = Traits::foreign_registrations(input);
    typename decltype((*output)->foreign_registrations)::BaseType::BufferWriter
        foreign_registrations_writer;
    const mojo::internal::ContainerValidateParams foreign_registrations_validate_params(
        0, false, new mojo::internal::ContainerValidateParams(0, false, nullptr));
    mojo::internal::Serialize<mojo::ArrayDataView<mojo::StringDataView>>(
        in_foreign_registrations, buffer, &foreign_registrations_writer, &foreign_registrations_validate_params,
        context);
    (*output)->foreign_registrations.Set(
        foreign_registrations_writer.is_null() ? nullptr : foreign_registrations_writer.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->foreign_registrations.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null foreign_registrations in PrefRegistry struct");
    decltype(Traits::public_registrations(input)) in_public_registrations = Traits::public_registrations(input);
    typename decltype((*output)->public_registrations)::BaseType::BufferWriter
        public_registrations_writer;
    const mojo::internal::ContainerValidateParams public_registrations_validate_params(
        0, false, nullptr);
    mojo::internal::Serialize<mojo::ArrayDataView<::prefs::mojom::PrefRegistrationDataView>>(
        in_public_registrations, buffer, &public_registrations_writer, &public_registrations_validate_params,
        context);
    (*output)->public_registrations.Set(
        public_registrations_writer.is_null() ? nullptr : public_registrations_writer.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->public_registrations.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null public_registrations in PrefRegistry struct");
  }

  static bool Deserialize(::prefs::mojom::internal::PrefRegistry_Data* input,
                          UserType* output,
                          SerializationContext* context) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::prefs::mojom::PrefRegistryDataView data_view(input, context);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::prefs::mojom::PrefRegistrationDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::prefs::mojom::PrefRegistrationDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        Buffer* buffer,
                        ::prefs::mojom::internal::PrefRegistration_Data::BufferWriter* output,
                        SerializationContext* context) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    (*output).Allocate(buffer);
    decltype(Traits::key(input)) in_key = Traits::key(input);
    typename decltype((*output)->key)::BaseType::BufferWriter
        key_writer;
    mojo::internal::Serialize<mojo::StringDataView>(
        in_key, buffer, &key_writer, context);
    (*output)->key.Set(
        key_writer.is_null() ? nullptr : key_writer.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->key.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null key in PrefRegistration struct");
    decltype(Traits::default_value(input)) in_default_value = Traits::default_value(input);
    typename decltype((*output)->default_value)::BufferWriter default_value_writer;
    default_value_writer.AllocateInline(buffer, &(*output)->default_value);
    mojo::internal::Serialize<::mojo_base::mojom::ValueDataView>(
        in_default_value, buffer, &default_value_writer, true, context);
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->default_value.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null default_value in PrefRegistration struct");
    (*output)->flags = Traits::flags(input);
  }

  static bool Deserialize(::prefs::mojom::internal::PrefRegistration_Data* input,
                          UserType* output,
                          SerializationContext* context) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::prefs::mojom::PrefRegistrationDataView data_view(input, context);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::prefs::mojom::TrackedPersistentPrefStoreConfigurationDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::prefs::mojom::TrackedPersistentPrefStoreConfigurationDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        Buffer* buffer,
                        ::prefs::mojom::internal::TrackedPersistentPrefStoreConfiguration_Data::BufferWriter* output,
                        SerializationContext* context) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    (*output).Allocate(buffer);
    decltype(Traits::unprotected_pref_filename(input)) in_unprotected_pref_filename = Traits::unprotected_pref_filename(input);
    typename decltype((*output)->unprotected_pref_filename)::BaseType::BufferWriter
        unprotected_pref_filename_writer;
    mojo::internal::Serialize<::mojo_base::mojom::FilePathDataView>(
        in_unprotected_pref_filename, buffer, &unprotected_pref_filename_writer, context);
    (*output)->unprotected_pref_filename.Set(
        unprotected_pref_filename_writer.is_null() ? nullptr : unprotected_pref_filename_writer.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->unprotected_pref_filename.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null unprotected_pref_filename in TrackedPersistentPrefStoreConfiguration struct");
    decltype(Traits::protected_pref_filename(input)) in_protected_pref_filename = Traits::protected_pref_filename(input);
    typename decltype((*output)->protected_pref_filename)::BaseType::BufferWriter
        protected_pref_filename_writer;
    mojo::internal::Serialize<::mojo_base::mojom::FilePathDataView>(
        in_protected_pref_filename, buffer, &protected_pref_filename_writer, context);
    (*output)->protected_pref_filename.Set(
        protected_pref_filename_writer.is_null() ? nullptr : protected_pref_filename_writer.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->protected_pref_filename.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null protected_pref_filename in TrackedPersistentPrefStoreConfiguration struct");
    decltype(Traits::tracking_configuration(input)) in_tracking_configuration = Traits::tracking_configuration(input);
    typename decltype((*output)->tracking_configuration)::BaseType::BufferWriter
        tracking_configuration_writer;
    const mojo::internal::ContainerValidateParams tracking_configuration_validate_params(
        0, false, nullptr);
    mojo::internal::Serialize<mojo::ArrayDataView<::prefs::mojom::TrackedPreferenceMetadataDataView>>(
        in_tracking_configuration, buffer, &tracking_configuration_writer, &tracking_configuration_validate_params,
        context);
    (*output)->tracking_configuration.Set(
        tracking_configuration_writer.is_null() ? nullptr : tracking_configuration_writer.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->tracking_configuration.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null tracking_configuration in TrackedPersistentPrefStoreConfiguration struct");
    (*output)->reporting_ids_count = Traits::reporting_ids_count(input);
    decltype(Traits::seed(input)) in_seed = Traits::seed(input);
    typename decltype((*output)->seed)::BaseType::BufferWriter
        seed_writer;
    mojo::internal::Serialize<mojo::StringDataView>(
        in_seed, buffer, &seed_writer, context);
    (*output)->seed.Set(
        seed_writer.is_null() ? nullptr : seed_writer.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->seed.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null seed in TrackedPersistentPrefStoreConfiguration struct");
    decltype(Traits::legacy_device_id(input)) in_legacy_device_id = Traits::legacy_device_id(input);
    typename decltype((*output)->legacy_device_id)::BaseType::BufferWriter
        legacy_device_id_writer;
    mojo::internal::Serialize<mojo::StringDataView>(
        in_legacy_device_id, buffer, &legacy_device_id_writer, context);
    (*output)->legacy_device_id.Set(
        legacy_device_id_writer.is_null() ? nullptr : legacy_device_id_writer.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->legacy_device_id.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null legacy_device_id in TrackedPersistentPrefStoreConfiguration struct");
    decltype(Traits::registry_seed(input)) in_registry_seed = Traits::registry_seed(input);
    typename decltype((*output)->registry_seed)::BaseType::BufferWriter
        registry_seed_writer;
    mojo::internal::Serialize<mojo::StringDataView>(
        in_registry_seed, buffer, &registry_seed_writer, context);
    (*output)->registry_seed.Set(
        registry_seed_writer.is_null() ? nullptr : registry_seed_writer.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->registry_seed.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null registry_seed in TrackedPersistentPrefStoreConfiguration struct");
    decltype(Traits::registry_path(input)) in_registry_path = Traits::registry_path(input);
    typename decltype((*output)->registry_path)::BaseType::BufferWriter
        registry_path_writer;
    mojo::internal::Serialize<::mojo_base::mojom::String16DataView>(
        in_registry_path, buffer, &registry_path_writer, context);
    (*output)->registry_path.Set(
        registry_path_writer.is_null() ? nullptr : registry_path_writer.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->registry_path.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null registry_path in TrackedPersistentPrefStoreConfiguration struct");
    decltype(Traits::validation_delegate(input)) in_validation_delegate = Traits::validation_delegate(input);
    mojo::internal::Serialize<::prefs::mojom::TrackedPreferenceValidationDelegatePtrDataView>(
        in_validation_delegate, &(*output)->validation_delegate, context);
    decltype(Traits::reset_on_load_observer(input)) in_reset_on_load_observer = Traits::reset_on_load_observer(input);
    mojo::internal::Serialize<::prefs::mojom::ResetOnLoadObserverPtrDataView>(
        in_reset_on_load_observer, &(*output)->reset_on_load_observer, context);
  }

  static bool Deserialize(::prefs::mojom::internal::TrackedPersistentPrefStoreConfiguration_Data* input,
                          UserType* output,
                          SerializationContext* context) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::prefs::mojom::TrackedPersistentPrefStoreConfigurationDataView data_view(input, context);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::prefs::mojom::TrackedPreferenceMetadataDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::prefs::mojom::TrackedPreferenceMetadataDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        Buffer* buffer,
                        ::prefs::mojom::internal::TrackedPreferenceMetadata_Data::BufferWriter* output,
                        SerializationContext* context) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    (*output).Allocate(buffer);
    (*output)->reporting_id = Traits::reporting_id(input);
    decltype(Traits::name(input)) in_name = Traits::name(input);
    typename decltype((*output)->name)::BaseType::BufferWriter
        name_writer;
    mojo::internal::Serialize<mojo::StringDataView>(
        in_name, buffer, &name_writer, context);
    (*output)->name.Set(
        name_writer.is_null() ? nullptr : name_writer.data());
    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
        (*output)->name.is_null(),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null name in TrackedPreferenceMetadata struct");
    mojo::internal::Serialize<::prefs::mojom::TrackedPreferenceMetadata_EnforcementLevel>(
        Traits::enforcement_level(input), &(*output)->enforcement_level);
    mojo::internal::Serialize<::prefs::mojom::TrackedPreferenceMetadata_PrefTrackingStrategy>(
        Traits::strategy(input), &(*output)->strategy);
    mojo::internal::Serialize<::prefs::mojom::TrackedPreferenceMetadata_ValueType>(
        Traits::value_type(input), &(*output)->value_type);
  }

  static bool Deserialize(::prefs::mojom::internal::TrackedPreferenceMetadata_Data* input,
                          UserType* output,
                          SerializationContext* context) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::prefs::mojom::TrackedPreferenceMetadataDataView data_view(input, context);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::prefs::mojom::PrefUpdateValueDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::prefs::mojom::PrefUpdateValueDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        Buffer* buffer,
                        ::prefs::mojom::internal::PrefUpdateValue_Data::BufferWriter* writer,
                        bool inlined,
                        SerializationContext* context) {
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
         writer->data()->set_null();
      return;
    }
    if (!inlined)
      writer->Allocate(buffer);

    ::prefs::mojom::internal::PrefUpdateValue_Data::BufferWriter& result = *writer;
    ALLOW_UNUSED_LOCAL(result);
    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
    result->size = kUnionDataSize;
    result->tag = Traits::GetTag(input);
    switch (result->tag) {
      case ::prefs::mojom::PrefUpdateValueDataView::Tag::SPLIT_UPDATES: {
        decltype(Traits::split_updates(input))
            in_split_updates = Traits::split_updates(input);
        typename decltype(result->data.f_split_updates)::BaseType::BufferWriter
            value_writer;
        const ContainerValidateParams split_updates_validate_params(
            0, false, nullptr);
        mojo::internal::Serialize<mojo::ArrayDataView<::prefs::mojom::SubPrefUpdateDataView>>(
            in_split_updates, buffer, &value_writer, &split_updates_validate_params,
            context);
        MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
            value_writer.is_null(),
            mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
            "null split_updates in PrefUpdateValue union");
        result->data.f_split_updates.Set(
            value_writer.is_null() ? nullptr : value_writer.data());
        break;
      }
      case ::prefs::mojom::PrefUpdateValueDataView::Tag::ATOMIC_UPDATE: {
        decltype(Traits::atomic_update(input))
            in_atomic_update = Traits::atomic_update(input);
        typename decltype(result->data.f_atomic_update)::BaseType::BufferWriter
            value_writer;
        mojo::internal::Serialize<::mojo_base::mojom::ValueDataView>(
            in_atomic_update, buffer, &value_writer, false, context);
        result->data.f_atomic_update.Set(
            value_writer.is_null() ? nullptr : value_writer.data());
        break;
      }
    }
  }

  static bool Deserialize(::prefs::mojom::internal::PrefUpdateValue_Data* input,
                          UserType* output,
                          SerializationContext* context) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::prefs::mojom::PrefUpdateValueDataView data_view(input, context);
    return Traits::Read(data_view, output);
  }
};

}  // namespace internal

}  // namespace mojo


namespace prefs {
namespace mojom {

inline void PrefStoreConnectionDataView::GetInitialPrefsDataView(
    ::mojo_base::mojom::DictionaryValueDataView* output) {
  auto pointer = data_->initial_prefs.Get();
  *output = ::mojo_base::mojom::DictionaryValueDataView(pointer, context_);
}


inline void PersistentPrefStoreConnectionDataView::GetPrefStoreConnectionDataView(
    PrefStoreConnectionDataView* output) {
  auto pointer = data_->pref_store_connection.Get();
  *output = PrefStoreConnectionDataView(pointer, context_);
}


inline void IncognitoPersistentPrefStoreConnectionDataView::GetPrefStoreConnectionDataView(
    PersistentPrefStoreConnectionDataView* output) {
  auto pointer = data_->pref_store_connection.Get();
  *output = PersistentPrefStoreConnectionDataView(pointer, context_);
}
inline void IncognitoPersistentPrefStoreConnectionDataView::GetPersistentPrefNamesDataView(
    mojo::ArrayDataView<mojo::StringDataView>* output) {
  auto pointer = data_->persistent_pref_names.Get();
  *output = mojo::ArrayDataView<mojo::StringDataView>(pointer, context_);
}


inline void SubPrefUpdateDataView::GetPathDataView(
    mojo::ArrayDataView<mojo::StringDataView>* output) {
  auto pointer = data_->path.Get();
  *output = mojo::ArrayDataView<mojo::StringDataView>(pointer, context_);
}
inline void SubPrefUpdateDataView::GetValueDataView(
    ::mojo_base::mojom::ValueDataView* output) {
  auto pointer = &data_->value;
  *output = ::mojo_base::mojom::ValueDataView(pointer, context_);
}


inline void PrefUpdateDataView::GetKeyDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->key.Get();
  *output = mojo::StringDataView(pointer, context_);
}
inline void PrefUpdateDataView::GetValueDataView(
    PrefUpdateValueDataView* output) {
  auto pointer = &data_->value;
  *output = PrefUpdateValueDataView(pointer, context_);
}


inline void PrefRegistryDataView::GetPrivateRegistrationsDataView(
    mojo::ArrayDataView<mojo::StringDataView>* output) {
  auto pointer = data_->private_registrations.Get();
  *output = mojo::ArrayDataView<mojo::StringDataView>(pointer, context_);
}
inline void PrefRegistryDataView::GetForeignRegistrationsDataView(
    mojo::ArrayDataView<mojo::StringDataView>* output) {
  auto pointer = data_->foreign_registrations.Get();
  *output = mojo::ArrayDataView<mojo::StringDataView>(pointer, context_);
}
inline void PrefRegistryDataView::GetPublicRegistrationsDataView(
    mojo::ArrayDataView<PrefRegistrationDataView>* output) {
  auto pointer = data_->public_registrations.Get();
  *output = mojo::ArrayDataView<PrefRegistrationDataView>(pointer, context_);
}


inline void PrefRegistrationDataView::GetKeyDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->key.Get();
  *output = mojo::StringDataView(pointer, context_);
}
inline void PrefRegistrationDataView::GetDefaultValueDataView(
    ::mojo_base::mojom::ValueDataView* output) {
  auto pointer = &data_->default_value;
  *output = ::mojo_base::mojom::ValueDataView(pointer, context_);
}


inline void TrackedPersistentPrefStoreConfigurationDataView::GetUnprotectedPrefFilenameDataView(
    ::mojo_base::mojom::FilePathDataView* output) {
  auto pointer = data_->unprotected_pref_filename.Get();
  *output = ::mojo_base::mojom::FilePathDataView(pointer, context_);
}
inline void TrackedPersistentPrefStoreConfigurationDataView::GetProtectedPrefFilenameDataView(
    ::mojo_base::mojom::FilePathDataView* output) {
  auto pointer = data_->protected_pref_filename.Get();
  *output = ::mojo_base::mojom::FilePathDataView(pointer, context_);
}
inline void TrackedPersistentPrefStoreConfigurationDataView::GetTrackingConfigurationDataView(
    mojo::ArrayDataView<TrackedPreferenceMetadataDataView>* output) {
  auto pointer = data_->tracking_configuration.Get();
  *output = mojo::ArrayDataView<TrackedPreferenceMetadataDataView>(pointer, context_);
}
inline void TrackedPersistentPrefStoreConfigurationDataView::GetSeedDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->seed.Get();
  *output = mojo::StringDataView(pointer, context_);
}
inline void TrackedPersistentPrefStoreConfigurationDataView::GetLegacyDeviceIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->legacy_device_id.Get();
  *output = mojo::StringDataView(pointer, context_);
}
inline void TrackedPersistentPrefStoreConfigurationDataView::GetRegistrySeedDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->registry_seed.Get();
  *output = mojo::StringDataView(pointer, context_);
}
inline void TrackedPersistentPrefStoreConfigurationDataView::GetRegistryPathDataView(
    ::mojo_base::mojom::String16DataView* output) {
  auto pointer = data_->registry_path.Get();
  *output = ::mojo_base::mojom::String16DataView(pointer, context_);
}


inline void TrackedPreferenceMetadataDataView::GetNameDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->name.Get();
  *output = mojo::StringDataView(pointer, context_);
}


inline void PrefUpdateValueDataView::GetSplitUpdatesDataView(
    mojo::ArrayDataView<SubPrefUpdateDataView>* output) {
  DCHECK(is_split_updates());
  *output = mojo::ArrayDataView<SubPrefUpdateDataView>(data_->data.f_split_updates.Get(), context_);
}
inline void PrefUpdateValueDataView::GetAtomicUpdateDataView(
    ::mojo_base::mojom::ValueDataView* output) {
  DCHECK(is_atomic_update());
  *output = ::mojo_base::mojom::ValueDataView(data_->data.f_atomic_update.Get(), context_);
}


}  // namespace mojom
}  // namespace prefs

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