// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: extension_install.proto

#include "extension_install.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
namespace metrics {
class ExtensionInstallProtoDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ExtensionInstallProto> _instance;
} _ExtensionInstallProto_default_instance_;
}  // namespace metrics
static void InitDefaultsscc_info_ExtensionInstallProto_extension_5finstall_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::metrics::_ExtensionInstallProto_default_instance_;
    new (ptr) ::metrics::ExtensionInstallProto();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::metrics::ExtensionInstallProto::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ExtensionInstallProto_extension_5finstall_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_ExtensionInstallProto_extension_5finstall_2eproto}, {}};

namespace metrics {
bool ExtensionInstallProto_Type_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ExtensionInstallProto_Type_strings[9] = {};

static const char ExtensionInstallProto_Type_names[] =
  "EXTENSION"
  "HOSTED_APP"
  "LEGACY_PACKAGED_APP"
  "LOGIN_SCREEN_EXTENSION"
  "PLATFORM_APP"
  "SHARED_MODULE"
  "THEME"
  "UNKNOWN_TYPE"
  "USER_SCRIPT";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ExtensionInstallProto_Type_entries[] = {
  { {ExtensionInstallProto_Type_names + 0, 9}, 1 },
  { {ExtensionInstallProto_Type_names + 9, 10}, 4 },
  { {ExtensionInstallProto_Type_names + 19, 19}, 5 },
  { {ExtensionInstallProto_Type_names + 38, 22}, 8 },
  { {ExtensionInstallProto_Type_names + 60, 12}, 6 },
  { {ExtensionInstallProto_Type_names + 72, 13}, 7 },
  { {ExtensionInstallProto_Type_names + 85, 5}, 2 },
  { {ExtensionInstallProto_Type_names + 90, 12}, 0 },
  { {ExtensionInstallProto_Type_names + 102, 11}, 3 },
};

static const int ExtensionInstallProto_Type_entries_by_number[] = {
  7, // 0 -> UNKNOWN_TYPE
  0, // 1 -> EXTENSION
  6, // 2 -> THEME
  8, // 3 -> USER_SCRIPT
  1, // 4 -> HOSTED_APP
  2, // 5 -> LEGACY_PACKAGED_APP
  4, // 6 -> PLATFORM_APP
  5, // 7 -> SHARED_MODULE
  3, // 8 -> LOGIN_SCREEN_EXTENSION
};

const std::string& ExtensionInstallProto_Type_Name(
    ExtensionInstallProto_Type value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ExtensionInstallProto_Type_entries,
          ExtensionInstallProto_Type_entries_by_number,
          9, ExtensionInstallProto_Type_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ExtensionInstallProto_Type_entries,
      ExtensionInstallProto_Type_entries_by_number,
      9, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ExtensionInstallProto_Type_strings[idx].get();
}
bool ExtensionInstallProto_Type_Parse(
    const std::string& name, ExtensionInstallProto_Type* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ExtensionInstallProto_Type_entries, 9, name, &int_value);
  if (success) {
    *value = static_cast<ExtensionInstallProto_Type>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr ExtensionInstallProto_Type ExtensionInstallProto::UNKNOWN_TYPE;
constexpr ExtensionInstallProto_Type ExtensionInstallProto::EXTENSION;
constexpr ExtensionInstallProto_Type ExtensionInstallProto::THEME;
constexpr ExtensionInstallProto_Type ExtensionInstallProto::USER_SCRIPT;
constexpr ExtensionInstallProto_Type ExtensionInstallProto::HOSTED_APP;
constexpr ExtensionInstallProto_Type ExtensionInstallProto::LEGACY_PACKAGED_APP;
constexpr ExtensionInstallProto_Type ExtensionInstallProto::PLATFORM_APP;
constexpr ExtensionInstallProto_Type ExtensionInstallProto::SHARED_MODULE;
constexpr ExtensionInstallProto_Type ExtensionInstallProto::LOGIN_SCREEN_EXTENSION;
constexpr ExtensionInstallProto_Type ExtensionInstallProto::Type_MIN;
constexpr ExtensionInstallProto_Type ExtensionInstallProto::Type_MAX;
constexpr int ExtensionInstallProto::Type_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
bool ExtensionInstallProto_InstallLocation_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ExtensionInstallProto_InstallLocation_strings[11] = {};

static const char ExtensionInstallProto_InstallLocation_names[] =
  "COMMAND_LINE"
  "COMPONENT"
  "EXTERNAL_COMPONENT"
  "EXTERNAL_POLICY"
  "EXTERNAL_POLICY_DOWNLOAD"
  "EXTERNAL_PREF"
  "EXTERNAL_PREF_DOWNLOAD"
  "EXTERNAL_REGISTRY"
  "INTERNAL"
  "UNKNOWN_LOCATION"
  "UNPACKED";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ExtensionInstallProto_InstallLocation_entries[] = {
  { {ExtensionInstallProto_InstallLocation_names + 0, 12}, 8 },
  { {ExtensionInstallProto_InstallLocation_names + 12, 9}, 5 },
  { {ExtensionInstallProto_InstallLocation_names + 21, 18}, 10 },
  { {ExtensionInstallProto_InstallLocation_names + 39, 15}, 9 },
  { {ExtensionInstallProto_InstallLocation_names + 54, 24}, 7 },
  { {ExtensionInstallProto_InstallLocation_names + 78, 13}, 2 },
  { {ExtensionInstallProto_InstallLocation_names + 91, 22}, 6 },
  { {ExtensionInstallProto_InstallLocation_names + 113, 17}, 3 },
  { {ExtensionInstallProto_InstallLocation_names + 130, 8}, 1 },
  { {ExtensionInstallProto_InstallLocation_names + 138, 16}, 0 },
  { {ExtensionInstallProto_InstallLocation_names + 154, 8}, 4 },
};

static const int ExtensionInstallProto_InstallLocation_entries_by_number[] = {
  9, // 0 -> UNKNOWN_LOCATION
  8, // 1 -> INTERNAL
  5, // 2 -> EXTERNAL_PREF
  7, // 3 -> EXTERNAL_REGISTRY
  10, // 4 -> UNPACKED
  1, // 5 -> COMPONENT
  6, // 6 -> EXTERNAL_PREF_DOWNLOAD
  4, // 7 -> EXTERNAL_POLICY_DOWNLOAD
  0, // 8 -> COMMAND_LINE
  3, // 9 -> EXTERNAL_POLICY
  2, // 10 -> EXTERNAL_COMPONENT
};

const std::string& ExtensionInstallProto_InstallLocation_Name(
    ExtensionInstallProto_InstallLocation value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ExtensionInstallProto_InstallLocation_entries,
          ExtensionInstallProto_InstallLocation_entries_by_number,
          11, ExtensionInstallProto_InstallLocation_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ExtensionInstallProto_InstallLocation_entries,
      ExtensionInstallProto_InstallLocation_entries_by_number,
      11, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ExtensionInstallProto_InstallLocation_strings[idx].get();
}
bool ExtensionInstallProto_InstallLocation_Parse(
    const std::string& name, ExtensionInstallProto_InstallLocation* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ExtensionInstallProto_InstallLocation_entries, 11, name, &int_value);
  if (success) {
    *value = static_cast<ExtensionInstallProto_InstallLocation>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr ExtensionInstallProto_InstallLocation ExtensionInstallProto::UNKNOWN_LOCATION;
constexpr ExtensionInstallProto_InstallLocation ExtensionInstallProto::INTERNAL;
constexpr ExtensionInstallProto_InstallLocation ExtensionInstallProto::EXTERNAL_PREF;
constexpr ExtensionInstallProto_InstallLocation ExtensionInstallProto::EXTERNAL_REGISTRY;
constexpr ExtensionInstallProto_InstallLocation ExtensionInstallProto::UNPACKED;
constexpr ExtensionInstallProto_InstallLocation ExtensionInstallProto::COMPONENT;
constexpr ExtensionInstallProto_InstallLocation ExtensionInstallProto::EXTERNAL_PREF_DOWNLOAD;
constexpr ExtensionInstallProto_InstallLocation ExtensionInstallProto::EXTERNAL_POLICY_DOWNLOAD;
constexpr ExtensionInstallProto_InstallLocation ExtensionInstallProto::COMMAND_LINE;
constexpr ExtensionInstallProto_InstallLocation ExtensionInstallProto::EXTERNAL_POLICY;
constexpr ExtensionInstallProto_InstallLocation ExtensionInstallProto::EXTERNAL_COMPONENT;
constexpr ExtensionInstallProto_InstallLocation ExtensionInstallProto::InstallLocation_MIN;
constexpr ExtensionInstallProto_InstallLocation ExtensionInstallProto::InstallLocation_MAX;
constexpr int ExtensionInstallProto::InstallLocation_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
bool ExtensionInstallProto_ActionType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ExtensionInstallProto_ActionType_strings[4] = {};

static const char ExtensionInstallProto_ActionType_names[] =
  "BROWSER_ACTION"
  "NO_ACTION"
  "PAGE_ACTION"
  "SYSTEM_INDICATOR";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ExtensionInstallProto_ActionType_entries[] = {
  { {ExtensionInstallProto_ActionType_names + 0, 14}, 1 },
  { {ExtensionInstallProto_ActionType_names + 14, 9}, 0 },
  { {ExtensionInstallProto_ActionType_names + 23, 11}, 2 },
  { {ExtensionInstallProto_ActionType_names + 34, 16}, 3 },
};

static const int ExtensionInstallProto_ActionType_entries_by_number[] = {
  1, // 0 -> NO_ACTION
  0, // 1 -> BROWSER_ACTION
  2, // 2 -> PAGE_ACTION
  3, // 3 -> SYSTEM_INDICATOR
};

const std::string& ExtensionInstallProto_ActionType_Name(
    ExtensionInstallProto_ActionType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ExtensionInstallProto_ActionType_entries,
          ExtensionInstallProto_ActionType_entries_by_number,
          4, ExtensionInstallProto_ActionType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ExtensionInstallProto_ActionType_entries,
      ExtensionInstallProto_ActionType_entries_by_number,
      4, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ExtensionInstallProto_ActionType_strings[idx].get();
}
bool ExtensionInstallProto_ActionType_Parse(
    const std::string& name, ExtensionInstallProto_ActionType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ExtensionInstallProto_ActionType_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<ExtensionInstallProto_ActionType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr ExtensionInstallProto_ActionType ExtensionInstallProto::NO_ACTION;
constexpr ExtensionInstallProto_ActionType ExtensionInstallProto::BROWSER_ACTION;
constexpr ExtensionInstallProto_ActionType ExtensionInstallProto::PAGE_ACTION;
constexpr ExtensionInstallProto_ActionType ExtensionInstallProto::SYSTEM_INDICATOR;
constexpr ExtensionInstallProto_ActionType ExtensionInstallProto::ActionType_MIN;
constexpr ExtensionInstallProto_ActionType ExtensionInstallProto::ActionType_MAX;
constexpr int ExtensionInstallProto::ActionType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
bool ExtensionInstallProto_BackgroundScriptType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ExtensionInstallProto_BackgroundScriptType_strings[4] = {};

static const char ExtensionInstallProto_BackgroundScriptType_names[] =
  "EVENT_PAGE"
  "NO_BACKGROUND_SCRIPT"
  "PERSISTENT_BACKGROUND_PAGE"
  "SERVICE_WORKER";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ExtensionInstallProto_BackgroundScriptType_entries[] = {
  { {ExtensionInstallProto_BackgroundScriptType_names + 0, 10}, 2 },
  { {ExtensionInstallProto_BackgroundScriptType_names + 10, 20}, 0 },
  { {ExtensionInstallProto_BackgroundScriptType_names + 30, 26}, 1 },
  { {ExtensionInstallProto_BackgroundScriptType_names + 56, 14}, 3 },
};

static const int ExtensionInstallProto_BackgroundScriptType_entries_by_number[] = {
  1, // 0 -> NO_BACKGROUND_SCRIPT
  2, // 1 -> PERSISTENT_BACKGROUND_PAGE
  0, // 2 -> EVENT_PAGE
  3, // 3 -> SERVICE_WORKER
};

const std::string& ExtensionInstallProto_BackgroundScriptType_Name(
    ExtensionInstallProto_BackgroundScriptType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ExtensionInstallProto_BackgroundScriptType_entries,
          ExtensionInstallProto_BackgroundScriptType_entries_by_number,
          4, ExtensionInstallProto_BackgroundScriptType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ExtensionInstallProto_BackgroundScriptType_entries,
      ExtensionInstallProto_BackgroundScriptType_entries_by_number,
      4, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ExtensionInstallProto_BackgroundScriptType_strings[idx].get();
}
bool ExtensionInstallProto_BackgroundScriptType_Parse(
    const std::string& name, ExtensionInstallProto_BackgroundScriptType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ExtensionInstallProto_BackgroundScriptType_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<ExtensionInstallProto_BackgroundScriptType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr ExtensionInstallProto_BackgroundScriptType ExtensionInstallProto::NO_BACKGROUND_SCRIPT;
constexpr ExtensionInstallProto_BackgroundScriptType ExtensionInstallProto::PERSISTENT_BACKGROUND_PAGE;
constexpr ExtensionInstallProto_BackgroundScriptType ExtensionInstallProto::EVENT_PAGE;
constexpr ExtensionInstallProto_BackgroundScriptType ExtensionInstallProto::SERVICE_WORKER;
constexpr ExtensionInstallProto_BackgroundScriptType ExtensionInstallProto::BackgroundScriptType_MIN;
constexpr ExtensionInstallProto_BackgroundScriptType ExtensionInstallProto::BackgroundScriptType_MAX;
constexpr int ExtensionInstallProto::BackgroundScriptType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
bool ExtensionInstallProto_DisableReason_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ExtensionInstallProto_DisableReason_strings[17] = {};

static const char ExtensionInstallProto_DisableReason_names[] =
  "BLOCKED_BY_POLICY"
  "CORRUPTED"
  "CUSTODIAN_APPROVAL_REQUIRED"
  "DEPRECATED_BLOCKED_MATURE"
  "DISABLE_REMOTELY_FOR_MALWARE"
  "EXTERNAL_EXTENSION"
  "GREYLIST"
  "NOT_VERIFIED"
  "PERMISSIONS_INCREASE"
  "REINSTALL"
  "RELOAD"
  "REMOTE_INSTALL"
  "SIDELOAD_WIPEOUT"
  "UNKNOWN_FROM_SYNC"
  "UNSUPPORTED_REQUIREMENT"
  "UPDATE_REQUIRED_BY_POLICY"
  "USER_ACTION";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ExtensionInstallProto_DisableReason_entries[] = {
  { {ExtensionInstallProto_DisableReason_names + 0, 17}, 13 },
  { {ExtensionInstallProto_DisableReason_names + 17, 9}, 8 },
  { {ExtensionInstallProto_DisableReason_names + 26, 27}, 12 },
  { {ExtensionInstallProto_DisableReason_names + 53, 25}, 14 },
  { {ExtensionInstallProto_DisableReason_names + 78, 28}, 15 },
  { {ExtensionInstallProto_DisableReason_names + 106, 18}, 10 },
  { {ExtensionInstallProto_DisableReason_names + 124, 8}, 7 },
  { {ExtensionInstallProto_DisableReason_names + 132, 12}, 6 },
  { {ExtensionInstallProto_DisableReason_names + 144, 20}, 1 },
  { {ExtensionInstallProto_DisableReason_names + 164, 9}, 16 },
  { {ExtensionInstallProto_DisableReason_names + 173, 6}, 2 },
  { {ExtensionInstallProto_DisableReason_names + 179, 14}, 9 },
  { {ExtensionInstallProto_DisableReason_names + 193, 16}, 4 },
  { {ExtensionInstallProto_DisableReason_names + 209, 17}, 5 },
  { {ExtensionInstallProto_DisableReason_names + 226, 23}, 3 },
  { {ExtensionInstallProto_DisableReason_names + 249, 25}, 11 },
  { {ExtensionInstallProto_DisableReason_names + 274, 11}, 0 },
};

static const int ExtensionInstallProto_DisableReason_entries_by_number[] = {
  16, // 0 -> USER_ACTION
  8, // 1 -> PERMISSIONS_INCREASE
  10, // 2 -> RELOAD
  14, // 3 -> UNSUPPORTED_REQUIREMENT
  12, // 4 -> SIDELOAD_WIPEOUT
  13, // 5 -> UNKNOWN_FROM_SYNC
  7, // 6 -> NOT_VERIFIED
  6, // 7 -> GREYLIST
  1, // 8 -> CORRUPTED
  11, // 9 -> REMOTE_INSTALL
  5, // 10 -> EXTERNAL_EXTENSION
  15, // 11 -> UPDATE_REQUIRED_BY_POLICY
  2, // 12 -> CUSTODIAN_APPROVAL_REQUIRED
  0, // 13 -> BLOCKED_BY_POLICY
  3, // 14 -> DEPRECATED_BLOCKED_MATURE
  4, // 15 -> DISABLE_REMOTELY_FOR_MALWARE
  9, // 16 -> REINSTALL
};

const std::string& ExtensionInstallProto_DisableReason_Name(
    ExtensionInstallProto_DisableReason value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ExtensionInstallProto_DisableReason_entries,
          ExtensionInstallProto_DisableReason_entries_by_number,
          17, ExtensionInstallProto_DisableReason_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ExtensionInstallProto_DisableReason_entries,
      ExtensionInstallProto_DisableReason_entries_by_number,
      17, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ExtensionInstallProto_DisableReason_strings[idx].get();
}
bool ExtensionInstallProto_DisableReason_Parse(
    const std::string& name, ExtensionInstallProto_DisableReason* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ExtensionInstallProto_DisableReason_entries, 17, name, &int_value);
  if (success) {
    *value = static_cast<ExtensionInstallProto_DisableReason>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::USER_ACTION;
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::PERMISSIONS_INCREASE;
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::RELOAD;
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::UNSUPPORTED_REQUIREMENT;
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::SIDELOAD_WIPEOUT;
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::UNKNOWN_FROM_SYNC;
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::NOT_VERIFIED;
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::GREYLIST;
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::CORRUPTED;
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::REMOTE_INSTALL;
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::EXTERNAL_EXTENSION;
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::UPDATE_REQUIRED_BY_POLICY;
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::CUSTODIAN_APPROVAL_REQUIRED;
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::BLOCKED_BY_POLICY;
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::DEPRECATED_BLOCKED_MATURE;
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::DISABLE_REMOTELY_FOR_MALWARE;
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::REINSTALL;
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::DisableReason_MIN;
constexpr ExtensionInstallProto_DisableReason ExtensionInstallProto::DisableReason_MAX;
constexpr int ExtensionInstallProto::DisableReason_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
bool ExtensionInstallProto_BlacklistState_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ExtensionInstallProto_BlacklistState_strings[6] = {};

static const char ExtensionInstallProto_BlacklistState_names[] =
  "BLACKLISTED_CWS_POLICY_VIOLATION"
  "BLACKLISTED_MALWARE"
  "BLACKLISTED_POTENTIALLY_UNWANTED"
  "BLACKLISTED_SECURITY_VULNERABILITY"
  "BLACKLISTED_UNKNOWN"
  "NOT_BLACKLISTED";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ExtensionInstallProto_BlacklistState_entries[] = {
  { {ExtensionInstallProto_BlacklistState_names + 0, 32}, 3 },
  { {ExtensionInstallProto_BlacklistState_names + 32, 19}, 1 },
  { {ExtensionInstallProto_BlacklistState_names + 51, 32}, 4 },
  { {ExtensionInstallProto_BlacklistState_names + 83, 34}, 2 },
  { {ExtensionInstallProto_BlacklistState_names + 117, 19}, 5 },
  { {ExtensionInstallProto_BlacklistState_names + 136, 15}, 0 },
};

static const int ExtensionInstallProto_BlacklistState_entries_by_number[] = {
  5, // 0 -> NOT_BLACKLISTED
  1, // 1 -> BLACKLISTED_MALWARE
  3, // 2 -> BLACKLISTED_SECURITY_VULNERABILITY
  0, // 3 -> BLACKLISTED_CWS_POLICY_VIOLATION
  2, // 4 -> BLACKLISTED_POTENTIALLY_UNWANTED
  4, // 5 -> BLACKLISTED_UNKNOWN
};

const std::string& ExtensionInstallProto_BlacklistState_Name(
    ExtensionInstallProto_BlacklistState value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ExtensionInstallProto_BlacklistState_entries,
          ExtensionInstallProto_BlacklistState_entries_by_number,
          6, ExtensionInstallProto_BlacklistState_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ExtensionInstallProto_BlacklistState_entries,
      ExtensionInstallProto_BlacklistState_entries_by_number,
      6, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ExtensionInstallProto_BlacklistState_strings[idx].get();
}
bool ExtensionInstallProto_BlacklistState_Parse(
    const std::string& name, ExtensionInstallProto_BlacklistState* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ExtensionInstallProto_BlacklistState_entries, 6, name, &int_value);
  if (success) {
    *value = static_cast<ExtensionInstallProto_BlacklistState>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr ExtensionInstallProto_BlacklistState ExtensionInstallProto::NOT_BLACKLISTED;
constexpr ExtensionInstallProto_BlacklistState ExtensionInstallProto::BLACKLISTED_MALWARE;
constexpr ExtensionInstallProto_BlacklistState ExtensionInstallProto::BLACKLISTED_SECURITY_VULNERABILITY;
constexpr ExtensionInstallProto_BlacklistState ExtensionInstallProto::BLACKLISTED_CWS_POLICY_VIOLATION;
constexpr ExtensionInstallProto_BlacklistState ExtensionInstallProto::BLACKLISTED_POTENTIALLY_UNWANTED;
constexpr ExtensionInstallProto_BlacklistState ExtensionInstallProto::BLACKLISTED_UNKNOWN;
constexpr ExtensionInstallProto_BlacklistState ExtensionInstallProto::BlacklistState_MIN;
constexpr ExtensionInstallProto_BlacklistState ExtensionInstallProto::BlacklistState_MAX;
constexpr int ExtensionInstallProto::BlacklistState_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)

// ===================================================================

void ExtensionInstallProto::InitAsDefaultInstance() {
}
class ExtensionInstallProto::_Internal {
 public:
  using HasBits = decltype(std::declval<ExtensionInstallProto>()._has_bits_);
  static void set_has_type(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_install_location(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_manifest_version(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_action_type(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_has_file_access(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_has_incognito_access(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_is_from_store(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_updates_from_store(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_is_from_bookmark(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static void set_has_is_converted_from_user_script(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static void set_has_is_default_installed(HasBits* has_bits) {
    (*has_bits)[0] |= 1024u;
  }
  static void set_has_is_oem_installed(HasBits* has_bits) {
    (*has_bits)[0] |= 2048u;
  }
  static void set_has_background_script_type(HasBits* has_bits) {
    (*has_bits)[0] |= 4096u;
  }
  static void set_has_blacklist_state(HasBits* has_bits) {
    (*has_bits)[0] |= 8192u;
  }
  static void set_has_installed_in_this_sample_period(HasBits* has_bits) {
    (*has_bits)[0] |= 16384u;
  }
};

ExtensionInstallProto::ExtensionInstallProto()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:metrics.ExtensionInstallProto)
}
ExtensionInstallProto::ExtensionInstallProto(const ExtensionInstallProto& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      disable_reasons_(from.disable_reasons_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&type_, &from.type_,
    static_cast<size_t>(reinterpret_cast<char*>(&installed_in_this_sample_period_) -
    reinterpret_cast<char*>(&type_)) + sizeof(installed_in_this_sample_period_));
  // @@protoc_insertion_point(copy_constructor:metrics.ExtensionInstallProto)
}

void ExtensionInstallProto::SharedCtor() {
  ::memset(&type_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&installed_in_this_sample_period_) -
      reinterpret_cast<char*>(&type_)) + sizeof(installed_in_this_sample_period_));
}

ExtensionInstallProto::~ExtensionInstallProto() {
  // @@protoc_insertion_point(destructor:metrics.ExtensionInstallProto)
  SharedDtor();
}

void ExtensionInstallProto::SharedDtor() {
}

void ExtensionInstallProto::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ExtensionInstallProto& ExtensionInstallProto::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ExtensionInstallProto_extension_5finstall_2eproto.base);
  return *internal_default_instance();
}


void ExtensionInstallProto::Clear() {
// @@protoc_insertion_point(message_clear_start:metrics.ExtensionInstallProto)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  disable_reasons_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    ::memset(&type_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&updates_from_store_) -
        reinterpret_cast<char*>(&type_)) + sizeof(updates_from_store_));
  }
  if (cached_has_bits & 0x00007f00u) {
    ::memset(&is_from_bookmark_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&installed_in_this_sample_period_) -
        reinterpret_cast<char*>(&is_from_bookmark_)) + sizeof(installed_in_this_sample_period_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* ExtensionInstallProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .metrics.ExtensionInstallProto.Type type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::metrics::ExtensionInstallProto_Type_IsValid(val))) {
            set_type(static_cast<::metrics::ExtensionInstallProto_Type>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .metrics.ExtensionInstallProto.InstallLocation install_location = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::metrics::ExtensionInstallProto_InstallLocation_IsValid(val))) {
            set_install_location(static_cast<::metrics::ExtensionInstallProto_InstallLocation>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional int32 manifest_version = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_manifest_version(&has_bits);
          manifest_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .metrics.ExtensionInstallProto.ActionType action_type = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::metrics::ExtensionInstallProto_ActionType_IsValid(val))) {
            set_action_type(static_cast<::metrics::ExtensionInstallProto_ActionType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional bool has_file_access = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_has_file_access(&has_bits);
          has_file_access_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool has_incognito_access = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_has_incognito_access(&has_bits);
          has_incognito_access_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool is_from_store = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_is_from_store(&has_bits);
          is_from_store_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool updates_from_store = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          _Internal::set_has_updates_from_store(&has_bits);
          updates_from_store_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool is_from_bookmark = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
          _Internal::set_has_is_from_bookmark(&has_bits);
          is_from_bookmark_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool is_converted_from_user_script = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
          _Internal::set_has_is_converted_from_user_script(&has_bits);
          is_converted_from_user_script_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool is_default_installed = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) {
          _Internal::set_has_is_default_installed(&has_bits);
          is_default_installed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool is_oem_installed = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 96)) {
          _Internal::set_has_is_oem_installed(&has_bits);
          is_oem_installed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .metrics.ExtensionInstallProto.BackgroundScriptType background_script_type = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 104)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::metrics::ExtensionInstallProto_BackgroundScriptType_IsValid(val))) {
            set_background_script_type(static_cast<::metrics::ExtensionInstallProto_BackgroundScriptType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(13, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // repeated .metrics.ExtensionInstallProto.DisableReason disable_reasons = 14;
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 112)) {
          ptr -= 1;
          do {
            ptr += 1;
            ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
            CHK_(ptr);
            if (PROTOBUF_PREDICT_TRUE(::metrics::ExtensionInstallProto_DisableReason_IsValid(val))) {
              add_disable_reasons(static_cast<::metrics::ExtensionInstallProto_DisableReason>(val));
            } else {
              ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(14, val, mutable_unknown_fields());
            }
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 112);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(mutable_disable_reasons(), ptr, ctx, ::metrics::ExtensionInstallProto_DisableReason_IsValid, &_internal_metadata_, 14);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .metrics.ExtensionInstallProto.BlacklistState blacklist_state = 15;
      case 15:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 120)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::metrics::ExtensionInstallProto_BlacklistState_IsValid(val))) {
            set_blacklist_state(static_cast<::metrics::ExtensionInstallProto_BlacklistState>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(15, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional bool installed_in_this_sample_period = 16;
      case 16:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 128)) {
          _Internal::set_has_installed_in_this_sample_period(&has_bits);
          installed_in_this_sample_period_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool ExtensionInstallProto::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:metrics.ExtensionInstallProto)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(16383u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .metrics.ExtensionInstallProto.Type type = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::metrics::ExtensionInstallProto_Type_IsValid(value)) {
            set_type(static_cast< ::metrics::ExtensionInstallProto_Type >(value));
          } else {
            unknown_fields_stream.WriteVarint32(8u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .metrics.ExtensionInstallProto.InstallLocation install_location = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::metrics::ExtensionInstallProto_InstallLocation_IsValid(value)) {
            set_install_location(static_cast< ::metrics::ExtensionInstallProto_InstallLocation >(value));
          } else {
            unknown_fields_stream.WriteVarint32(16u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 manifest_version = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_manifest_version(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &manifest_version_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .metrics.ExtensionInstallProto.ActionType action_type = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::metrics::ExtensionInstallProto_ActionType_IsValid(value)) {
            set_action_type(static_cast< ::metrics::ExtensionInstallProto_ActionType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(32u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool has_file_access = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
          _Internal::set_has_has_file_access(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &has_file_access_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool has_incognito_access = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) {
          _Internal::set_has_has_incognito_access(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &has_incognito_access_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool is_from_store = 7;
      case 7: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (56 & 0xFF)) {
          _Internal::set_has_is_from_store(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_from_store_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool updates_from_store = 8;
      case 8: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (64 & 0xFF)) {
          _Internal::set_has_updates_from_store(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &updates_from_store_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool is_from_bookmark = 9;
      case 9: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (72 & 0xFF)) {
          _Internal::set_has_is_from_bookmark(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_from_bookmark_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool is_converted_from_user_script = 10;
      case 10: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (80 & 0xFF)) {
          _Internal::set_has_is_converted_from_user_script(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_converted_from_user_script_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool is_default_installed = 11;
      case 11: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (88 & 0xFF)) {
          _Internal::set_has_is_default_installed(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_default_installed_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool is_oem_installed = 12;
      case 12: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (96 & 0xFF)) {
          _Internal::set_has_is_oem_installed(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_oem_installed_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .metrics.ExtensionInstallProto.BackgroundScriptType background_script_type = 13;
      case 13: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (104 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::metrics::ExtensionInstallProto_BackgroundScriptType_IsValid(value)) {
            set_background_script_type(static_cast< ::metrics::ExtensionInstallProto_BackgroundScriptType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(104u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .metrics.ExtensionInstallProto.DisableReason disable_reasons = 14;
      case 14: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (112 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::metrics::ExtensionInstallProto_DisableReason_IsValid(value)) {
            add_disable_reasons(static_cast< ::metrics::ExtensionInstallProto_DisableReason >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (114 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedEnumPreserveUnknowns(
                 input,
                 14,
                 ::metrics::ExtensionInstallProto_DisableReason_IsValid,
                 &unknown_fields_stream,
                 this->mutable_disable_reasons())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .metrics.ExtensionInstallProto.BlacklistState blacklist_state = 15;
      case 15: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (120 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::metrics::ExtensionInstallProto_BlacklistState_IsValid(value)) {
            set_blacklist_state(static_cast< ::metrics::ExtensionInstallProto_BlacklistState >(value));
          } else {
            unknown_fields_stream.WriteVarint32(120u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool installed_in_this_sample_period = 16;
      case 16: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (128 & 0xFF)) {
          _Internal::set_has_installed_in_this_sample_period(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &installed_in_this_sample_period_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:metrics.ExtensionInstallProto)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:metrics.ExtensionInstallProto)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void ExtensionInstallProto::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:metrics.ExtensionInstallProto)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .metrics.ExtensionInstallProto.Type type = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // optional .metrics.ExtensionInstallProto.InstallLocation install_location = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      2, this->install_location(), output);
  }

  // optional int32 manifest_version = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32(3, this->manifest_version(), output);
  }

  // optional .metrics.ExtensionInstallProto.ActionType action_type = 4;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      4, this->action_type(), output);
  }

  // optional bool has_file_access = 5;
  if (cached_has_bits & 0x00000010u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(5, this->has_file_access(), output);
  }

  // optional bool has_incognito_access = 6;
  if (cached_has_bits & 0x00000020u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(6, this->has_incognito_access(), output);
  }

  // optional bool is_from_store = 7;
  if (cached_has_bits & 0x00000040u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(7, this->is_from_store(), output);
  }

  // optional bool updates_from_store = 8;
  if (cached_has_bits & 0x00000080u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(8, this->updates_from_store(), output);
  }

  // optional bool is_from_bookmark = 9;
  if (cached_has_bits & 0x00000100u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(9, this->is_from_bookmark(), output);
  }

  // optional bool is_converted_from_user_script = 10;
  if (cached_has_bits & 0x00000200u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(10, this->is_converted_from_user_script(), output);
  }

  // optional bool is_default_installed = 11;
  if (cached_has_bits & 0x00000400u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(11, this->is_default_installed(), output);
  }

  // optional bool is_oem_installed = 12;
  if (cached_has_bits & 0x00000800u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(12, this->is_oem_installed(), output);
  }

  // optional .metrics.ExtensionInstallProto.BackgroundScriptType background_script_type = 13;
  if (cached_has_bits & 0x00001000u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      13, this->background_script_type(), output);
  }

  // repeated .metrics.ExtensionInstallProto.DisableReason disable_reasons = 14;
  for (int i = 0, n = this->disable_reasons_size(); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      14, this->disable_reasons(i), output);
  }

  // optional .metrics.ExtensionInstallProto.BlacklistState blacklist_state = 15;
  if (cached_has_bits & 0x00002000u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      15, this->blacklist_state(), output);
  }

  // optional bool installed_in_this_sample_period = 16;
  if (cached_has_bits & 0x00004000u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(16, this->installed_in_this_sample_period(), output);
  }

  output->WriteRaw(_internal_metadata_.unknown_fields().data(),
                   static_cast<int>(_internal_metadata_.unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:metrics.ExtensionInstallProto)
}

size_t ExtensionInstallProto::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:metrics.ExtensionInstallProto)
  size_t total_size = 0;

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .metrics.ExtensionInstallProto.DisableReason disable_reasons = 14;
  {
    size_t data_size = 0;
    unsigned int count = static_cast<unsigned int>(this->disable_reasons_size());for (unsigned int i = 0; i < count; i++) {
      data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(
        this->disable_reasons(static_cast<int>(i)));
    }
    total_size += (1UL * count) + data_size;
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional .metrics.ExtensionInstallProto.Type type = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->type());
    }

    // optional .metrics.ExtensionInstallProto.InstallLocation install_location = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->install_location());
    }

    // optional int32 manifest_version = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->manifest_version());
    }

    // optional .metrics.ExtensionInstallProto.ActionType action_type = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->action_type());
    }

    // optional bool has_file_access = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 1;
    }

    // optional bool has_incognito_access = 6;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 1;
    }

    // optional bool is_from_store = 7;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 + 1;
    }

    // optional bool updates_from_store = 8;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 + 1;
    }

  }
  if (cached_has_bits & 0x00007f00u) {
    // optional bool is_from_bookmark = 9;
    if (cached_has_bits & 0x00000100u) {
      total_size += 1 + 1;
    }

    // optional bool is_converted_from_user_script = 10;
    if (cached_has_bits & 0x00000200u) {
      total_size += 1 + 1;
    }

    // optional bool is_default_installed = 11;
    if (cached_has_bits & 0x00000400u) {
      total_size += 1 + 1;
    }

    // optional bool is_oem_installed = 12;
    if (cached_has_bits & 0x00000800u) {
      total_size += 1 + 1;
    }

    // optional .metrics.ExtensionInstallProto.BackgroundScriptType background_script_type = 13;
    if (cached_has_bits & 0x00001000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->background_script_type());
    }

    // optional .metrics.ExtensionInstallProto.BlacklistState blacklist_state = 15;
    if (cached_has_bits & 0x00002000u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->blacklist_state());
    }

    // optional bool installed_in_this_sample_period = 16;
    if (cached_has_bits & 0x00004000u) {
      total_size += 2 + 1;
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void ExtensionInstallProto::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ExtensionInstallProto*>(
      &from));
}

void ExtensionInstallProto::MergeFrom(const ExtensionInstallProto& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:metrics.ExtensionInstallProto)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  disable_reasons_.MergeFrom(from.disable_reasons_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      type_ = from.type_;
    }
    if (cached_has_bits & 0x00000002u) {
      install_location_ = from.install_location_;
    }
    if (cached_has_bits & 0x00000004u) {
      manifest_version_ = from.manifest_version_;
    }
    if (cached_has_bits & 0x00000008u) {
      action_type_ = from.action_type_;
    }
    if (cached_has_bits & 0x00000010u) {
      has_file_access_ = from.has_file_access_;
    }
    if (cached_has_bits & 0x00000020u) {
      has_incognito_access_ = from.has_incognito_access_;
    }
    if (cached_has_bits & 0x00000040u) {
      is_from_store_ = from.is_from_store_;
    }
    if (cached_has_bits & 0x00000080u) {
      updates_from_store_ = from.updates_from_store_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00007f00u) {
    if (cached_has_bits & 0x00000100u) {
      is_from_bookmark_ = from.is_from_bookmark_;
    }
    if (cached_has_bits & 0x00000200u) {
      is_converted_from_user_script_ = from.is_converted_from_user_script_;
    }
    if (cached_has_bits & 0x00000400u) {
      is_default_installed_ = from.is_default_installed_;
    }
    if (cached_has_bits & 0x00000800u) {
      is_oem_installed_ = from.is_oem_installed_;
    }
    if (cached_has_bits & 0x00001000u) {
      background_script_type_ = from.background_script_type_;
    }
    if (cached_has_bits & 0x00002000u) {
      blacklist_state_ = from.blacklist_state_;
    }
    if (cached_has_bits & 0x00004000u) {
      installed_in_this_sample_period_ = from.installed_in_this_sample_period_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ExtensionInstallProto::CopyFrom(const ExtensionInstallProto& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:metrics.ExtensionInstallProto)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ExtensionInstallProto::IsInitialized() const {
  return true;
}

void ExtensionInstallProto::InternalSwap(ExtensionInstallProto* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  disable_reasons_.InternalSwap(&other->disable_reasons_);
  swap(type_, other->type_);
  swap(install_location_, other->install_location_);
  swap(manifest_version_, other->manifest_version_);
  swap(action_type_, other->action_type_);
  swap(has_file_access_, other->has_file_access_);
  swap(has_incognito_access_, other->has_incognito_access_);
  swap(is_from_store_, other->is_from_store_);
  swap(updates_from_store_, other->updates_from_store_);
  swap(is_from_bookmark_, other->is_from_bookmark_);
  swap(is_converted_from_user_script_, other->is_converted_from_user_script_);
  swap(is_default_installed_, other->is_default_installed_);
  swap(is_oem_installed_, other->is_oem_installed_);
  swap(background_script_type_, other->background_script_type_);
  swap(blacklist_state_, other->blacklist_state_);
  swap(installed_in_this_sample_period_, other->installed_in_this_sample_period_);
}

std::string ExtensionInstallProto::GetTypeName() const {
  return "metrics.ExtensionInstallProto";
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace metrics
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::metrics::ExtensionInstallProto* Arena::CreateMaybeMessage< ::metrics::ExtensionInstallProto >(Arena* arena) {
  return Arena::CreateInternal< ::metrics::ExtensionInstallProto >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
