Add m-esr52 at 52.6.0

2 files changed, 13449 insertions, 0 deletions

diff --git a/toolkit/components/url-classifier/protobuf/safebrowsing.pb.cc b/toolkit/components/url-classifier/protobuf/safebrowsing.pb.cc
new file mode 100644
index 000000000..d3e49251b
--- /dev/null
+++ b/toolkit/components/url-classifier/protobuf/safebrowsing.pb.cc
@@ -0,0 +1,7166 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: safebrowsing.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "safebrowsing.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
+// @@protoc_insertion_point(includes)
+
+namespace mozilla {
+namespace safebrowsing {
+
+void protobuf_ShutdownFile_safebrowsing_2eproto() {
+  delete ThreatInfo::default_instance_;
+  delete ThreatMatch::default_instance_;
+  delete FindThreatMatchesRequest::default_instance_;
+  delete FindThreatMatchesResponse::default_instance_;
+  delete FetchThreatListUpdatesRequest::default_instance_;
+  delete FetchThreatListUpdatesRequest_ListUpdateRequest::default_instance_;
+  delete FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::default_instance_;
+  delete FetchThreatListUpdatesResponse::default_instance_;
+  delete FetchThreatListUpdatesResponse_ListUpdateResponse::default_instance_;
+  delete FindFullHashesRequest::default_instance_;
+  delete FindFullHashesResponse::default_instance_;
+  delete ThreatHit::default_instance_;
+  delete ThreatHit_ThreatSource::default_instance_;
+  delete ClientInfo::default_instance_;
+  delete Checksum::default_instance_;
+  delete ThreatEntry::default_instance_;
+  delete ThreatEntrySet::default_instance_;
+  delete RawIndices::default_instance_;
+  delete RawHashes::default_instance_;
+  delete RiceDeltaEncoding::default_instance_;
+  delete ThreatEntryMetadata::default_instance_;
+  delete ThreatEntryMetadata_MetadataEntry::default_instance_;
+  delete ThreatListDescriptor::default_instance_;
+  delete ListThreatListsResponse::default_instance_;
+  delete Duration::default_instance_;
+}
+
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+void protobuf_AddDesc_safebrowsing_2eproto_impl() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+#else
+void protobuf_AddDesc_safebrowsing_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+#endif
+  ThreatInfo::default_instance_ = new ThreatInfo();
+  ThreatMatch::default_instance_ = new ThreatMatch();
+  FindThreatMatchesRequest::default_instance_ = new FindThreatMatchesRequest();
+  FindThreatMatchesResponse::default_instance_ = new FindThreatMatchesResponse();
+  FetchThreatListUpdatesRequest::default_instance_ = new FetchThreatListUpdatesRequest();
+  FetchThreatListUpdatesRequest_ListUpdateRequest::default_instance_ = new FetchThreatListUpdatesRequest_ListUpdateRequest();
+  FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::default_instance_ = new FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints();
+  FetchThreatListUpdatesResponse::default_instance_ = new FetchThreatListUpdatesResponse();
+  FetchThreatListUpdatesResponse_ListUpdateResponse::default_instance_ = new FetchThreatListUpdatesResponse_ListUpdateResponse();
+  FindFullHashesRequest::default_instance_ = new FindFullHashesRequest();
+  FindFullHashesResponse::default_instance_ = new FindFullHashesResponse();
+  ThreatHit::default_instance_ = new ThreatHit();
+  ThreatHit_ThreatSource::default_instance_ = new ThreatHit_ThreatSource();
+  ClientInfo::default_instance_ = new ClientInfo();
+  Checksum::default_instance_ = new Checksum();
+  ThreatEntry::default_instance_ = new ThreatEntry();
+  ThreatEntrySet::default_instance_ = new ThreatEntrySet();
+  RawIndices::default_instance_ = new RawIndices();
+  RawHashes::default_instance_ = new RawHashes();
+  RiceDeltaEncoding::default_instance_ = new RiceDeltaEncoding();
+  ThreatEntryMetadata::default_instance_ = new ThreatEntryMetadata();
+  ThreatEntryMetadata_MetadataEntry::default_instance_ = new ThreatEntryMetadata_MetadataEntry();
+  ThreatListDescriptor::default_instance_ = new ThreatListDescriptor();
+  ListThreatListsResponse::default_instance_ = new ListThreatListsResponse();
+  Duration::default_instance_ = new Duration();
+  ThreatInfo::default_instance_->InitAsDefaultInstance();
+  ThreatMatch::default_instance_->InitAsDefaultInstance();
+  FindThreatMatchesRequest::default_instance_->InitAsDefaultInstance();
+  FindThreatMatchesResponse::default_instance_->InitAsDefaultInstance();
+  FetchThreatListUpdatesRequest::default_instance_->InitAsDefaultInstance();
+  FetchThreatListUpdatesRequest_ListUpdateRequest::default_instance_->InitAsDefaultInstance();
+  FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::default_instance_->InitAsDefaultInstance();
+  FetchThreatListUpdatesResponse::default_instance_->InitAsDefaultInstance();
+  FetchThreatListUpdatesResponse_ListUpdateResponse::default_instance_->InitAsDefaultInstance();
+  FindFullHashesRequest::default_instance_->InitAsDefaultInstance();
+  FindFullHashesResponse::default_instance_->InitAsDefaultInstance();
+  ThreatHit::default_instance_->InitAsDefaultInstance();
+  ThreatHit_ThreatSource::default_instance_->InitAsDefaultInstance();
+  ClientInfo::default_instance_->InitAsDefaultInstance();
+  Checksum::default_instance_->InitAsDefaultInstance();
+  ThreatEntry::default_instance_->InitAsDefaultInstance();
+  ThreatEntrySet::default_instance_->InitAsDefaultInstance();
+  RawIndices::default_instance_->InitAsDefaultInstance();
+  RawHashes::default_instance_->InitAsDefaultInstance();
+  RiceDeltaEncoding::default_instance_->InitAsDefaultInstance();
+  ThreatEntryMetadata::default_instance_->InitAsDefaultInstance();
+  ThreatEntryMetadata_MetadataEntry::default_instance_->InitAsDefaultInstance();
+  ThreatListDescriptor::default_instance_->InitAsDefaultInstance();
+  ListThreatListsResponse::default_instance_->InitAsDefaultInstance();
+  Duration::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_safebrowsing_2eproto);
+}
+
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_safebrowsing_2eproto_once_);
+void protobuf_AddDesc_safebrowsing_2eproto() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_safebrowsing_2eproto_once_,
+                 &protobuf_AddDesc_safebrowsing_2eproto_impl);
+}
+#else
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_safebrowsing_2eproto {
+  StaticDescriptorInitializer_safebrowsing_2eproto() {
+    protobuf_AddDesc_safebrowsing_2eproto();
+  }
+} static_descriptor_initializer_safebrowsing_2eproto_;
+#endif
+bool ThreatType_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool PlatformType_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;
+  }
+}
+
+bool CompressionType_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool ThreatEntryType_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ThreatInfo::kThreatTypesFieldNumber;
+const int ThreatInfo::kPlatformTypesFieldNumber;
+const int ThreatInfo::kThreatEntryTypesFieldNumber;
+const int ThreatInfo::kThreatEntriesFieldNumber;
+#endif  // !_MSC_VER
+
+ThreatInfo::ThreatInfo()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatInfo)
+}
+
+void ThreatInfo::InitAsDefaultInstance() {
+}
+
+ThreatInfo::ThreatInfo(const ThreatInfo& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatInfo)
+}
+
+void ThreatInfo::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ThreatInfo::~ThreatInfo() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatInfo)
+  SharedDtor();
+}
+
+void ThreatInfo::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ThreatInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ThreatInfo& ThreatInfo::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ThreatInfo* ThreatInfo::default_instance_ = NULL;
+
+ThreatInfo* ThreatInfo::New() const {
+  return new ThreatInfo;
+}
+
+void ThreatInfo::Clear() {
+  threat_types_.Clear();
+  platform_types_.Clear();
+  threat_entry_types_.Clear();
+  threat_entries_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ThreatInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ThreatInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .mozilla.safebrowsing.ThreatType threat_types = 1;
+      case 1: {
+        if (tag == 8) {
+         parse_threat_types:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::ThreatType_IsValid(value)) {
+            add_threat_types(static_cast< ::mozilla::safebrowsing::ThreatType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else if (tag == 10) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline(
+                 input,
+                 &::mozilla::safebrowsing::ThreatType_IsValid,
+                 this->mutable_threat_types())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(8)) goto parse_threat_types;
+        if (input->ExpectTag(16)) goto parse_platform_types;
+        break;
+      }
+
+      // repeated .mozilla.safebrowsing.PlatformType platform_types = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_platform_types:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::PlatformType_IsValid(value)) {
+            add_platform_types(static_cast< ::mozilla::safebrowsing::PlatformType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else if (tag == 18) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline(
+                 input,
+                 &::mozilla::safebrowsing::PlatformType_IsValid,
+                 this->mutable_platform_types())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_platform_types;
+        if (input->ExpectTag(26)) goto parse_threat_entries;
+        break;
+      }
+
+      // repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_threat_entries:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_threat_entries()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_threat_entries;
+        if (input->ExpectTag(32)) goto parse_threat_entry_types;
+        break;
+      }
+
+      // repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_threat_entry_types:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::ThreatEntryType_IsValid(value)) {
+            add_threat_entry_types(static_cast< ::mozilla::safebrowsing::ThreatEntryType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else if (tag == 34) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline(
+                 input,
+                 &::mozilla::safebrowsing::ThreatEntryType_IsValid,
+                 this->mutable_threat_entry_types())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_threat_entry_types;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.ThreatInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ThreatInfo)
+  return false;
+#undef DO_
+}
+
+void ThreatInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ThreatInfo)
+  // repeated .mozilla.safebrowsing.ThreatType threat_types = 1;
+  for (int i = 0; i < this->threat_types_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->threat_types(i), output);
+  }
+
+  // repeated .mozilla.safebrowsing.PlatformType platform_types = 2;
+  for (int i = 0; i < this->platform_types_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->platform_types(i), output);
+  }
+
+  // repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3;
+  for (int i = 0; i < this->threat_entries_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->threat_entries(i), output);
+  }
+
+  // repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4;
+  for (int i = 0; i < this->threat_entry_types_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      4, this->threat_entry_types(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ThreatInfo)
+}
+
+int ThreatInfo::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .mozilla.safebrowsing.ThreatType threat_types = 1;
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->threat_types_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
+        this->threat_types(i));
+    }
+    total_size += 1 * this->threat_types_size() + data_size;
+  }
+
+  // repeated .mozilla.safebrowsing.PlatformType platform_types = 2;
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->platform_types_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
+        this->platform_types(i));
+    }
+    total_size += 1 * this->platform_types_size() + data_size;
+  }
+
+  // repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4;
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->threat_entry_types_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
+        this->threat_entry_types(i));
+    }
+    total_size += 1 * this->threat_entry_types_size() + data_size;
+  }
+
+  // repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3;
+  total_size += 1 * this->threat_entries_size();
+  for (int i = 0; i < this->threat_entries_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->threat_entries(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ThreatInfo::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ThreatInfo*>(&from));
+}
+
+void ThreatInfo::MergeFrom(const ThreatInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  threat_types_.MergeFrom(from.threat_types_);
+  platform_types_.MergeFrom(from.platform_types_);
+  threat_entry_types_.MergeFrom(from.threat_entry_types_);
+  threat_entries_.MergeFrom(from.threat_entries_);
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ThreatInfo::CopyFrom(const ThreatInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ThreatInfo::IsInitialized() const {
+
+  return true;
+}
+
+void ThreatInfo::Swap(ThreatInfo* other) {
+  if (other != this) {
+    threat_types_.Swap(&other->threat_types_);
+    platform_types_.Swap(&other->platform_types_);
+    threat_entry_types_.Swap(&other->threat_entry_types_);
+    threat_entries_.Swap(&other->threat_entries_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ThreatInfo::GetTypeName() const {
+  return "mozilla.safebrowsing.ThreatInfo";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ThreatMatch::kThreatTypeFieldNumber;
+const int ThreatMatch::kPlatformTypeFieldNumber;
+const int ThreatMatch::kThreatEntryTypeFieldNumber;
+const int ThreatMatch::kThreatFieldNumber;
+const int ThreatMatch::kThreatEntryMetadataFieldNumber;
+const int ThreatMatch::kCacheDurationFieldNumber;
+#endif  // !_MSC_VER
+
+ThreatMatch::ThreatMatch()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatMatch)
+}
+
+void ThreatMatch::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  threat_ = const_cast< ::mozilla::safebrowsing::ThreatEntry*>(
+      ::mozilla::safebrowsing::ThreatEntry::internal_default_instance());
+#else
+  threat_ = const_cast< ::mozilla::safebrowsing::ThreatEntry*>(&::mozilla::safebrowsing::ThreatEntry::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  threat_entry_metadata_ = const_cast< ::mozilla::safebrowsing::ThreatEntryMetadata*>(
+      ::mozilla::safebrowsing::ThreatEntryMetadata::internal_default_instance());
+#else
+  threat_entry_metadata_ = const_cast< ::mozilla::safebrowsing::ThreatEntryMetadata*>(&::mozilla::safebrowsing::ThreatEntryMetadata::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  cache_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>(
+      ::mozilla::safebrowsing::Duration::internal_default_instance());
+#else
+  cache_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>(&::mozilla::safebrowsing::Duration::default_instance());
+#endif
+}
+
+ThreatMatch::ThreatMatch(const ThreatMatch& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatMatch)
+}
+
+void ThreatMatch::SharedCtor() {
+  _cached_size_ = 0;
+  threat_type_ = 0;
+  platform_type_ = 0;
+  threat_entry_type_ = 0;
+  threat_ = NULL;
+  threat_entry_metadata_ = NULL;
+  cache_duration_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ThreatMatch::~ThreatMatch() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatMatch)
+  SharedDtor();
+}
+
+void ThreatMatch::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete threat_;
+    delete threat_entry_metadata_;
+    delete cache_duration_;
+  }
+}
+
+void ThreatMatch::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ThreatMatch& ThreatMatch::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ThreatMatch* ThreatMatch::default_instance_ = NULL;
+
+ThreatMatch* ThreatMatch::New() const {
+  return new ThreatMatch;
+}
+
+void ThreatMatch::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ThreatMatch*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 63) {
+    ZR_(threat_type_, platform_type_);
+    threat_entry_type_ = 0;
+    if (has_threat()) {
+      if (threat_ != NULL) threat_->::mozilla::safebrowsing::ThreatEntry::Clear();
+    }
+    if (has_threat_entry_metadata()) {
+      if (threat_entry_metadata_ != NULL) threat_entry_metadata_->::mozilla::safebrowsing::ThreatEntryMetadata::Clear();
+    }
+    if (has_cache_duration()) {
+      if (cache_duration_ != NULL) cache_duration_->::mozilla::safebrowsing::Duration::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ThreatMatch::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ThreatMatch)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+      case 1: {
+        if (tag == 8) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::ThreatType_IsValid(value)) {
+            set_threat_type(static_cast< ::mozilla::safebrowsing::ThreatType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_platform_type;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_platform_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::PlatformType_IsValid(value)) {
+            set_platform_type(static_cast< ::mozilla::safebrowsing::PlatformType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_threat;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.ThreatEntry threat = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_threat:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_threat()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_threat_entry_metadata;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_threat_entry_metadata:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_threat_entry_metadata()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_cache_duration;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.Duration cache_duration = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_cache_duration:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_cache_duration()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_threat_entry_type;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_threat_entry_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::ThreatEntryType_IsValid(value)) {
+            set_threat_entry_type(static_cast< ::mozilla::safebrowsing::ThreatEntryType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.ThreatMatch)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ThreatMatch)
+  return false;
+#undef DO_
+}
+
+void ThreatMatch::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ThreatMatch)
+  // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+  if (has_threat_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->threat_type(), output);
+  }
+
+  // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+  if (has_platform_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->platform_type(), output);
+  }
+
+  // optional .mozilla.safebrowsing.ThreatEntry threat = 3;
+  if (has_threat()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->threat(), output);
+  }
+
+  // optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4;
+  if (has_threat_entry_metadata()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      4, this->threat_entry_metadata(), output);
+  }
+
+  // optional .mozilla.safebrowsing.Duration cache_duration = 5;
+  if (has_cache_duration()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      5, this->cache_duration(), output);
+  }
+
+  // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6;
+  if (has_threat_entry_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      6, this->threat_entry_type(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ThreatMatch)
+}
+
+int ThreatMatch::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+    if (has_threat_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_type());
+    }
+
+    // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+    if (has_platform_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->platform_type());
+    }
+
+    // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6;
+    if (has_threat_entry_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_entry_type());
+    }
+
+    // optional .mozilla.safebrowsing.ThreatEntry threat = 3;
+    if (has_threat()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->threat());
+    }
+
+    // optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4;
+    if (has_threat_entry_metadata()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->threat_entry_metadata());
+    }
+
+    // optional .mozilla.safebrowsing.Duration cache_duration = 5;
+    if (has_cache_duration()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->cache_duration());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ThreatMatch::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ThreatMatch*>(&from));
+}
+
+void ThreatMatch::MergeFrom(const ThreatMatch& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_threat_type()) {
+      set_threat_type(from.threat_type());
+    }
+    if (from.has_platform_type()) {
+      set_platform_type(from.platform_type());
+    }
+    if (from.has_threat_entry_type()) {
+      set_threat_entry_type(from.threat_entry_type());
+    }
+    if (from.has_threat()) {
+      mutable_threat()->::mozilla::safebrowsing::ThreatEntry::MergeFrom(from.threat());
+    }
+    if (from.has_threat_entry_metadata()) {
+      mutable_threat_entry_metadata()->::mozilla::safebrowsing::ThreatEntryMetadata::MergeFrom(from.threat_entry_metadata());
+    }
+    if (from.has_cache_duration()) {
+      mutable_cache_duration()->::mozilla::safebrowsing::Duration::MergeFrom(from.cache_duration());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ThreatMatch::CopyFrom(const ThreatMatch& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ThreatMatch::IsInitialized() const {
+
+  return true;
+}
+
+void ThreatMatch::Swap(ThreatMatch* other) {
+  if (other != this) {
+    std::swap(threat_type_, other->threat_type_);
+    std::swap(platform_type_, other->platform_type_);
+    std::swap(threat_entry_type_, other->threat_entry_type_);
+    std::swap(threat_, other->threat_);
+    std::swap(threat_entry_metadata_, other->threat_entry_metadata_);
+    std::swap(cache_duration_, other->cache_duration_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ThreatMatch::GetTypeName() const {
+  return "mozilla.safebrowsing.ThreatMatch";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int FindThreatMatchesRequest::kClientFieldNumber;
+const int FindThreatMatchesRequest::kThreatInfoFieldNumber;
+#endif  // !_MSC_VER
+
+FindThreatMatchesRequest::FindThreatMatchesRequest()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.FindThreatMatchesRequest)
+}
+
+void FindThreatMatchesRequest::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  client_ = const_cast< ::mozilla::safebrowsing::ClientInfo*>(
+      ::mozilla::safebrowsing::ClientInfo::internal_default_instance());
+#else
+  client_ = const_cast< ::mozilla::safebrowsing::ClientInfo*>(&::mozilla::safebrowsing::ClientInfo::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  threat_info_ = const_cast< ::mozilla::safebrowsing::ThreatInfo*>(
+      ::mozilla::safebrowsing::ThreatInfo::internal_default_instance());
+#else
+  threat_info_ = const_cast< ::mozilla::safebrowsing::ThreatInfo*>(&::mozilla::safebrowsing::ThreatInfo::default_instance());
+#endif
+}
+
+FindThreatMatchesRequest::FindThreatMatchesRequest(const FindThreatMatchesRequest& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FindThreatMatchesRequest)
+}
+
+void FindThreatMatchesRequest::SharedCtor() {
+  _cached_size_ = 0;
+  client_ = NULL;
+  threat_info_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+FindThreatMatchesRequest::~FindThreatMatchesRequest() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FindThreatMatchesRequest)
+  SharedDtor();
+}
+
+void FindThreatMatchesRequest::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete client_;
+    delete threat_info_;
+  }
+}
+
+void FindThreatMatchesRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const FindThreatMatchesRequest& FindThreatMatchesRequest::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+FindThreatMatchesRequest* FindThreatMatchesRequest::default_instance_ = NULL;
+
+FindThreatMatchesRequest* FindThreatMatchesRequest::New() const {
+  return new FindThreatMatchesRequest;
+}
+
+void FindThreatMatchesRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_client()) {
+      if (client_ != NULL) client_->::mozilla::safebrowsing::ClientInfo::Clear();
+    }
+    if (has_threat_info()) {
+      if (threat_info_ != NULL) threat_info_->::mozilla::safebrowsing::ThreatInfo::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool FindThreatMatchesRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.FindThreatMatchesRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .mozilla.safebrowsing.ClientInfo client = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_client()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_threat_info;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.ThreatInfo threat_info = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_threat_info:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_threat_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.FindThreatMatchesRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.FindThreatMatchesRequest)
+  return false;
+#undef DO_
+}
+
+void FindThreatMatchesRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.FindThreatMatchesRequest)
+  // optional .mozilla.safebrowsing.ClientInfo client = 1;
+  if (has_client()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->client(), output);
+  }
+
+  // optional .mozilla.safebrowsing.ThreatInfo threat_info = 2;
+  if (has_threat_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->threat_info(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.FindThreatMatchesRequest)
+}
+
+int FindThreatMatchesRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .mozilla.safebrowsing.ClientInfo client = 1;
+    if (has_client()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->client());
+    }
+
+    // optional .mozilla.safebrowsing.ThreatInfo threat_info = 2;
+    if (has_threat_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->threat_info());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void FindThreatMatchesRequest::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const FindThreatMatchesRequest*>(&from));
+}
+
+void FindThreatMatchesRequest::MergeFrom(const FindThreatMatchesRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_client()) {
+      mutable_client()->::mozilla::safebrowsing::ClientInfo::MergeFrom(from.client());
+    }
+    if (from.has_threat_info()) {
+      mutable_threat_info()->::mozilla::safebrowsing::ThreatInfo::MergeFrom(from.threat_info());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void FindThreatMatchesRequest::CopyFrom(const FindThreatMatchesRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FindThreatMatchesRequest::IsInitialized() const {
+
+  return true;
+}
+
+void FindThreatMatchesRequest::Swap(FindThreatMatchesRequest* other) {
+  if (other != this) {
+    std::swap(client_, other->client_);
+    std::swap(threat_info_, other->threat_info_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string FindThreatMatchesRequest::GetTypeName() const {
+  return "mozilla.safebrowsing.FindThreatMatchesRequest";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int FindThreatMatchesResponse::kMatchesFieldNumber;
+#endif  // !_MSC_VER
+
+FindThreatMatchesResponse::FindThreatMatchesResponse()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.FindThreatMatchesResponse)
+}
+
+void FindThreatMatchesResponse::InitAsDefaultInstance() {
+}
+
+FindThreatMatchesResponse::FindThreatMatchesResponse(const FindThreatMatchesResponse& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FindThreatMatchesResponse)
+}
+
+void FindThreatMatchesResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+FindThreatMatchesResponse::~FindThreatMatchesResponse() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FindThreatMatchesResponse)
+  SharedDtor();
+}
+
+void FindThreatMatchesResponse::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void FindThreatMatchesResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const FindThreatMatchesResponse& FindThreatMatchesResponse::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+FindThreatMatchesResponse* FindThreatMatchesResponse::default_instance_ = NULL;
+
+FindThreatMatchesResponse* FindThreatMatchesResponse::New() const {
+  return new FindThreatMatchesResponse;
+}
+
+void FindThreatMatchesResponse::Clear() {
+  matches_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool FindThreatMatchesResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.FindThreatMatchesResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_matches:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_matches()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_matches;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.FindThreatMatchesResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.FindThreatMatchesResponse)
+  return false;
+#undef DO_
+}
+
+void FindThreatMatchesResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.FindThreatMatchesResponse)
+  // repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
+  for (int i = 0; i < this->matches_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->matches(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.FindThreatMatchesResponse)
+}
+
+int FindThreatMatchesResponse::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
+  total_size += 1 * this->matches_size();
+  for (int i = 0; i < this->matches_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->matches(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void FindThreatMatchesResponse::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const FindThreatMatchesResponse*>(&from));
+}
+
+void FindThreatMatchesResponse::MergeFrom(const FindThreatMatchesResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  matches_.MergeFrom(from.matches_);
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void FindThreatMatchesResponse::CopyFrom(const FindThreatMatchesResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FindThreatMatchesResponse::IsInitialized() const {
+
+  return true;
+}
+
+void FindThreatMatchesResponse::Swap(FindThreatMatchesResponse* other) {
+  if (other != this) {
+    matches_.Swap(&other->matches_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string FindThreatMatchesResponse::GetTypeName() const {
+  return "mozilla.safebrowsing.FindThreatMatchesResponse";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::kMaxUpdateEntriesFieldNumber;
+const int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::kMaxDatabaseEntriesFieldNumber;
+const int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::kRegionFieldNumber;
+const int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::kSupportedCompressionsFieldNumber;
+#endif  // !_MSC_VER
+
+FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints)
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::InitAsDefaultInstance() {
+}
+
+FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints)
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  max_update_entries_ = 0;
+  max_database_entries_ = 0;
+  region_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::~FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints)
+  SharedDtor();
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::SharedDtor() {
+  if (region_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete region_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::default_instance_ = NULL;
+
+FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::New() const {
+  return new FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints;
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(max_update_entries_, max_database_entries_);
+    if (has_region()) {
+      if (region_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        region_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  supported_compressions_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional int32 max_update_entries = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &max_update_entries_)));
+          set_has_max_update_entries();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_max_database_entries;
+        break;
+      }
+
+      // optional int32 max_database_entries = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_max_database_entries:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &max_database_entries_)));
+          set_has_max_database_entries();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_region;
+        break;
+      }
+
+      // optional string region = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_region:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_region()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_supported_compressions;
+        break;
+      }
+
+      // repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_supported_compressions:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::CompressionType_IsValid(value)) {
+            add_supported_compressions(static_cast< ::mozilla::safebrowsing::CompressionType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else if (tag == 34) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline(
+                 input,
+                 &::mozilla::safebrowsing::CompressionType_IsValid,
+                 this->mutable_supported_compressions())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_supported_compressions;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints)
+  return false;
+#undef DO_
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints)
+  // optional int32 max_update_entries = 1;
+  if (has_max_update_entries()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->max_update_entries(), output);
+  }
+
+  // optional int32 max_database_entries = 2;
+  if (has_max_database_entries()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->max_database_entries(), output);
+  }
+
+  // optional string region = 3;
+  if (has_region()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->region(), output);
+  }
+
+  // repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4;
+  for (int i = 0; i < this->supported_compressions_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      4, this->supported_compressions(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints)
+}
+
+int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional int32 max_update_entries = 1;
+    if (has_max_update_entries()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->max_update_entries());
+    }
+
+    // optional int32 max_database_entries = 2;
+    if (has_max_database_entries()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->max_database_entries());
+    }
+
+    // optional string region = 3;
+    if (has_region()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->region());
+    }
+
+  }
+  // repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4;
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->supported_compressions_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
+        this->supported_compressions(i));
+    }
+    total_size += 1 * this->supported_compressions_size() + data_size;
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints*>(&from));
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::MergeFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  supported_compressions_.MergeFrom(from.supported_compressions_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_max_update_entries()) {
+      set_max_update_entries(from.max_update_entries());
+    }
+    if (from.has_max_database_entries()) {
+      set_max_database_entries(from.max_database_entries());
+    }
+    if (from.has_region()) {
+      set_region(from.region());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::CopyFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::IsInitialized() const {
+
+  return true;
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::Swap(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* other) {
+  if (other != this) {
+    std::swap(max_update_entries_, other->max_update_entries_);
+    std::swap(max_database_entries_, other->max_database_entries_);
+    std::swap(region_, other->region_);
+    supported_compressions_.Swap(&other->supported_compressions_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::GetTypeName() const {
+  return "mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int FetchThreatListUpdatesRequest_ListUpdateRequest::kThreatTypeFieldNumber;
+const int FetchThreatListUpdatesRequest_ListUpdateRequest::kPlatformTypeFieldNumber;
+const int FetchThreatListUpdatesRequest_ListUpdateRequest::kThreatEntryTypeFieldNumber;
+const int FetchThreatListUpdatesRequest_ListUpdateRequest::kStateFieldNumber;
+const int FetchThreatListUpdatesRequest_ListUpdateRequest::kConstraintsFieldNumber;
+#endif  // !_MSC_VER
+
+FetchThreatListUpdatesRequest_ListUpdateRequest::FetchThreatListUpdatesRequest_ListUpdateRequest()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest)
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  constraints_ = const_cast< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints*>(
+      ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::internal_default_instance());
+#else
+  constraints_ = const_cast< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints*>(&::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::default_instance());
+#endif
+}
+
+FetchThreatListUpdatesRequest_ListUpdateRequest::FetchThreatListUpdatesRequest_ListUpdateRequest(const FetchThreatListUpdatesRequest_ListUpdateRequest& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest)
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  threat_type_ = 0;
+  platform_type_ = 0;
+  threat_entry_type_ = 0;
+  state_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  constraints_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+FetchThreatListUpdatesRequest_ListUpdateRequest::~FetchThreatListUpdatesRequest_ListUpdateRequest() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest)
+  SharedDtor();
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest::SharedDtor() {
+  if (state_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete state_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete constraints_;
+  }
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const FetchThreatListUpdatesRequest_ListUpdateRequest& FetchThreatListUpdatesRequest_ListUpdateRequest::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+FetchThreatListUpdatesRequest_ListUpdateRequest* FetchThreatListUpdatesRequest_ListUpdateRequest::default_instance_ = NULL;
+
+FetchThreatListUpdatesRequest_ListUpdateRequest* FetchThreatListUpdatesRequest_ListUpdateRequest::New() const {
+  return new FetchThreatListUpdatesRequest_ListUpdateRequest;
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<FetchThreatListUpdatesRequest_ListUpdateRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 31) {
+    ZR_(threat_type_, platform_type_);
+    threat_entry_type_ = 0;
+    if (has_state()) {
+      if (state_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        state_->clear();
+      }
+    }
+    if (has_constraints()) {
+      if (constraints_ != NULL) constraints_->::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool FetchThreatListUpdatesRequest_ListUpdateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+      case 1: {
+        if (tag == 8) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::ThreatType_IsValid(value)) {
+            set_threat_type(static_cast< ::mozilla::safebrowsing::ThreatType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_platform_type;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_platform_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::PlatformType_IsValid(value)) {
+            set_platform_type(static_cast< ::mozilla::safebrowsing::PlatformType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_state;
+        break;
+      }
+
+      // optional bytes state = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_state:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_state()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_constraints;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_constraints:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_constraints()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_threat_entry_type;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_threat_entry_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::ThreatEntryType_IsValid(value)) {
+            set_threat_entry_type(static_cast< ::mozilla::safebrowsing::ThreatEntryType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest)
+  return false;
+#undef DO_
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest)
+  // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+  if (has_threat_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->threat_type(), output);
+  }
+
+  // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+  if (has_platform_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->platform_type(), output);
+  }
+
+  // optional bytes state = 3;
+  if (has_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      3, this->state(), output);
+  }
+
+  // optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4;
+  if (has_constraints()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      4, this->constraints(), output);
+  }
+
+  // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5;
+  if (has_threat_entry_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      5, this->threat_entry_type(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest)
+}
+
+int FetchThreatListUpdatesRequest_ListUpdateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+    if (has_threat_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_type());
+    }
+
+    // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+    if (has_platform_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->platform_type());
+    }
+
+    // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5;
+    if (has_threat_entry_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_entry_type());
+    }
+
+    // optional bytes state = 3;
+    if (has_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->state());
+    }
+
+    // optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4;
+    if (has_constraints()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->constraints());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const FetchThreatListUpdatesRequest_ListUpdateRequest*>(&from));
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest::MergeFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_threat_type()) {
+      set_threat_type(from.threat_type());
+    }
+    if (from.has_platform_type()) {
+      set_platform_type(from.platform_type());
+    }
+    if (from.has_threat_entry_type()) {
+      set_threat_entry_type(from.threat_entry_type());
+    }
+    if (from.has_state()) {
+      set_state(from.state());
+    }
+    if (from.has_constraints()) {
+      mutable_constraints()->::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::MergeFrom(from.constraints());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest::CopyFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FetchThreatListUpdatesRequest_ListUpdateRequest::IsInitialized() const {
+
+  return true;
+}
+
+void FetchThreatListUpdatesRequest_ListUpdateRequest::Swap(FetchThreatListUpdatesRequest_ListUpdateRequest* other) {
+  if (other != this) {
+    std::swap(threat_type_, other->threat_type_);
+    std::swap(platform_type_, other->platform_type_);
+    std::swap(threat_entry_type_, other->threat_entry_type_);
+    std::swap(state_, other->state_);
+    std::swap(constraints_, other->constraints_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string FetchThreatListUpdatesRequest_ListUpdateRequest::GetTypeName() const {
+  return "mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int FetchThreatListUpdatesRequest::kClientFieldNumber;
+const int FetchThreatListUpdatesRequest::kListUpdateRequestsFieldNumber;
+#endif  // !_MSC_VER
+
+FetchThreatListUpdatesRequest::FetchThreatListUpdatesRequest()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest)
+}
+
+void FetchThreatListUpdatesRequest::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  client_ = const_cast< ::mozilla::safebrowsing::ClientInfo*>(
+      ::mozilla::safebrowsing::ClientInfo::internal_default_instance());
+#else
+  client_ = const_cast< ::mozilla::safebrowsing::ClientInfo*>(&::mozilla::safebrowsing::ClientInfo::default_instance());
+#endif
+}
+
+FetchThreatListUpdatesRequest::FetchThreatListUpdatesRequest(const FetchThreatListUpdatesRequest& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest)
+}
+
+void FetchThreatListUpdatesRequest::SharedCtor() {
+  _cached_size_ = 0;
+  client_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+FetchThreatListUpdatesRequest::~FetchThreatListUpdatesRequest() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesRequest)
+  SharedDtor();
+}
+
+void FetchThreatListUpdatesRequest::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete client_;
+  }
+}
+
+void FetchThreatListUpdatesRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const FetchThreatListUpdatesRequest& FetchThreatListUpdatesRequest::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+FetchThreatListUpdatesRequest* FetchThreatListUpdatesRequest::default_instance_ = NULL;
+
+FetchThreatListUpdatesRequest* FetchThreatListUpdatesRequest::New() const {
+  return new FetchThreatListUpdatesRequest;
+}
+
+void FetchThreatListUpdatesRequest::Clear() {
+  if (has_client()) {
+    if (client_ != NULL) client_->::mozilla::safebrowsing::ClientInfo::Clear();
+  }
+  list_update_requests_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool FetchThreatListUpdatesRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .mozilla.safebrowsing.ClientInfo client = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_client()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_list_update_requests;
+        break;
+      }
+
+      // repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_list_update_requests:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_list_update_requests()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_list_update_requests;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.FetchThreatListUpdatesRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.FetchThreatListUpdatesRequest)
+  return false;
+#undef DO_
+}
+
+void FetchThreatListUpdatesRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.FetchThreatListUpdatesRequest)
+  // optional .mozilla.safebrowsing.ClientInfo client = 1;
+  if (has_client()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->client(), output);
+  }
+
+  // repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3;
+  for (int i = 0; i < this->list_update_requests_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->list_update_requests(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.FetchThreatListUpdatesRequest)
+}
+
+int FetchThreatListUpdatesRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .mozilla.safebrowsing.ClientInfo client = 1;
+    if (has_client()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->client());
+    }
+
+  }
+  // repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3;
+  total_size += 1 * this->list_update_requests_size();
+  for (int i = 0; i < this->list_update_requests_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->list_update_requests(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void FetchThreatListUpdatesRequest::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const FetchThreatListUpdatesRequest*>(&from));
+}
+
+void FetchThreatListUpdatesRequest::MergeFrom(const FetchThreatListUpdatesRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  list_update_requests_.MergeFrom(from.list_update_requests_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_client()) {
+      mutable_client()->::mozilla::safebrowsing::ClientInfo::MergeFrom(from.client());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void FetchThreatListUpdatesRequest::CopyFrom(const FetchThreatListUpdatesRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FetchThreatListUpdatesRequest::IsInitialized() const {
+
+  return true;
+}
+
+void FetchThreatListUpdatesRequest::Swap(FetchThreatListUpdatesRequest* other) {
+  if (other != this) {
+    std::swap(client_, other->client_);
+    list_update_requests_.Swap(&other->list_update_requests_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string FetchThreatListUpdatesRequest::GetTypeName() const {
+  return "mozilla.safebrowsing.FetchThreatListUpdatesRequest";
+}
+
+
+// ===================================================================
+
+bool FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::RESPONSE_TYPE_UNSPECIFIED;
+const FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::PARTIAL_UPDATE;
+const FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::FULL_UPDATE;
+const FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::ResponseType_MIN;
+const FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::ResponseType_MAX;
+const int FetchThreatListUpdatesResponse_ListUpdateResponse::ResponseType_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int FetchThreatListUpdatesResponse_ListUpdateResponse::kThreatTypeFieldNumber;
+const int FetchThreatListUpdatesResponse_ListUpdateResponse::kThreatEntryTypeFieldNumber;
+const int FetchThreatListUpdatesResponse_ListUpdateResponse::kPlatformTypeFieldNumber;
+const int FetchThreatListUpdatesResponse_ListUpdateResponse::kResponseTypeFieldNumber;
+const int FetchThreatListUpdatesResponse_ListUpdateResponse::kAdditionsFieldNumber;
+const int FetchThreatListUpdatesResponse_ListUpdateResponse::kRemovalsFieldNumber;
+const int FetchThreatListUpdatesResponse_ListUpdateResponse::kNewClientStateFieldNumber;
+const int FetchThreatListUpdatesResponse_ListUpdateResponse::kChecksumFieldNumber;
+#endif  // !_MSC_VER
+
+FetchThreatListUpdatesResponse_ListUpdateResponse::FetchThreatListUpdatesResponse_ListUpdateResponse()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse)
+}
+
+void FetchThreatListUpdatesResponse_ListUpdateResponse::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  checksum_ = const_cast< ::mozilla::safebrowsing::Checksum*>(
+      ::mozilla::safebrowsing::Checksum::internal_default_instance());
+#else
+  checksum_ = const_cast< ::mozilla::safebrowsing::Checksum*>(&::mozilla::safebrowsing::Checksum::default_instance());
+#endif
+}
+
+FetchThreatListUpdatesResponse_ListUpdateResponse::FetchThreatListUpdatesResponse_ListUpdateResponse(const FetchThreatListUpdatesResponse_ListUpdateResponse& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse)
+}
+
+void FetchThreatListUpdatesResponse_ListUpdateResponse::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  threat_type_ = 0;
+  threat_entry_type_ = 0;
+  platform_type_ = 0;
+  response_type_ = 0;
+  new_client_state_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  checksum_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+FetchThreatListUpdatesResponse_ListUpdateResponse::~FetchThreatListUpdatesResponse_ListUpdateResponse() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse)
+  SharedDtor();
+}
+
+void FetchThreatListUpdatesResponse_ListUpdateResponse::SharedDtor() {
+  if (new_client_state_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete new_client_state_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete checksum_;
+  }
+}
+
+void FetchThreatListUpdatesResponse_ListUpdateResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const FetchThreatListUpdatesResponse_ListUpdateResponse& FetchThreatListUpdatesResponse_ListUpdateResponse::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+FetchThreatListUpdatesResponse_ListUpdateResponse* FetchThreatListUpdatesResponse_ListUpdateResponse::default_instance_ = NULL;
+
+FetchThreatListUpdatesResponse_ListUpdateResponse* FetchThreatListUpdatesResponse_ListUpdateResponse::New() const {
+  return new FetchThreatListUpdatesResponse_ListUpdateResponse;
+}
+
+void FetchThreatListUpdatesResponse_ListUpdateResponse::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<FetchThreatListUpdatesResponse_ListUpdateResponse*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 207) {
+    ZR_(threat_type_, response_type_);
+    if (has_new_client_state()) {
+      if (new_client_state_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        new_client_state_->clear();
+      }
+    }
+    if (has_checksum()) {
+      if (checksum_ != NULL) checksum_->::mozilla::safebrowsing::Checksum::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  additions_.Clear();
+  removals_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool FetchThreatListUpdatesResponse_ListUpdateResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+      case 1: {
+        if (tag == 8) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::ThreatType_IsValid(value)) {
+            set_threat_type(static_cast< ::mozilla::safebrowsing::ThreatType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_threat_entry_type;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_threat_entry_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::ThreatEntryType_IsValid(value)) {
+            set_threat_entry_type(static_cast< ::mozilla::safebrowsing::ThreatEntryType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_platform_type;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.PlatformType platform_type = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_platform_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::PlatformType_IsValid(value)) {
+            set_platform_type(static_cast< ::mozilla::safebrowsing::PlatformType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_response_type;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_response_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(value)) {
+            set_response_type(static_cast< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_additions;
+        break;
+      }
+
+      // repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_additions:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_additions()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_additions;
+        if (input->ExpectTag(50)) goto parse_removals;
+        break;
+      }
+
+      // repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_removals:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_removals()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_removals;
+        if (input->ExpectTag(58)) goto parse_new_client_state;
+        break;
+      }
+
+      // optional bytes new_client_state = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_new_client_state:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_new_client_state()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_checksum;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.Checksum checksum = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_checksum:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_checksum()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse)
+  return false;
+#undef DO_
+}
+
+void FetchThreatListUpdatesResponse_ListUpdateResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse)
+  // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+  if (has_threat_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->threat_type(), output);
+  }
+
+  // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2;
+  if (has_threat_entry_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->threat_entry_type(), output);
+  }
+
+  // optional .mozilla.safebrowsing.PlatformType platform_type = 3;
+  if (has_platform_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      3, this->platform_type(), output);
+  }
+
+  // optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4;
+  if (has_response_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      4, this->response_type(), output);
+  }
+
+  // repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5;
+  for (int i = 0; i < this->additions_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      5, this->additions(i), output);
+  }
+
+  // repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6;
+  for (int i = 0; i < this->removals_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      6, this->removals(i), output);
+  }
+
+  // optional bytes new_client_state = 7;
+  if (has_new_client_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      7, this->new_client_state(), output);
+  }
+
+  // optional .mozilla.safebrowsing.Checksum checksum = 8;
+  if (has_checksum()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      8, this->checksum(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse)
+}
+
+int FetchThreatListUpdatesResponse_ListUpdateResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+    if (has_threat_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_type());
+    }
+
+    // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2;
+    if (has_threat_entry_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_entry_type());
+    }
+
+    // optional .mozilla.safebrowsing.PlatformType platform_type = 3;
+    if (has_platform_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->platform_type());
+    }
+
+    // optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4;
+    if (has_response_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->response_type());
+    }
+
+    // optional bytes new_client_state = 7;
+    if (has_new_client_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->new_client_state());
+    }
+
+    // optional .mozilla.safebrowsing.Checksum checksum = 8;
+    if (has_checksum()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->checksum());
+    }
+
+  }
+  // repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5;
+  total_size += 1 * this->additions_size();
+  for (int i = 0; i < this->additions_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->additions(i));
+  }
+
+  // repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6;
+  total_size += 1 * this->removals_size();
+  for (int i = 0; i < this->removals_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->removals(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void FetchThreatListUpdatesResponse_ListUpdateResponse::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const FetchThreatListUpdatesResponse_ListUpdateResponse*>(&from));
+}
+
+void FetchThreatListUpdatesResponse_ListUpdateResponse::MergeFrom(const FetchThreatListUpdatesResponse_ListUpdateResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  additions_.MergeFrom(from.additions_);
+  removals_.MergeFrom(from.removals_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_threat_type()) {
+      set_threat_type(from.threat_type());
+    }
+    if (from.has_threat_entry_type()) {
+      set_threat_entry_type(from.threat_entry_type());
+    }
+    if (from.has_platform_type()) {
+      set_platform_type(from.platform_type());
+    }
+    if (from.has_response_type()) {
+      set_response_type(from.response_type());
+    }
+    if (from.has_new_client_state()) {
+      set_new_client_state(from.new_client_state());
+    }
+    if (from.has_checksum()) {
+      mutable_checksum()->::mozilla::safebrowsing::Checksum::MergeFrom(from.checksum());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void FetchThreatListUpdatesResponse_ListUpdateResponse::CopyFrom(const FetchThreatListUpdatesResponse_ListUpdateResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FetchThreatListUpdatesResponse_ListUpdateResponse::IsInitialized() const {
+
+  return true;
+}
+
+void FetchThreatListUpdatesResponse_ListUpdateResponse::Swap(FetchThreatListUpdatesResponse_ListUpdateResponse* other) {
+  if (other != this) {
+    std::swap(threat_type_, other->threat_type_);
+    std::swap(threat_entry_type_, other->threat_entry_type_);
+    std::swap(platform_type_, other->platform_type_);
+    std::swap(response_type_, other->response_type_);
+    additions_.Swap(&other->additions_);
+    removals_.Swap(&other->removals_);
+    std::swap(new_client_state_, other->new_client_state_);
+    std::swap(checksum_, other->checksum_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string FetchThreatListUpdatesResponse_ListUpdateResponse::GetTypeName() const {
+  return "mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int FetchThreatListUpdatesResponse::kListUpdateResponsesFieldNumber;
+const int FetchThreatListUpdatesResponse::kMinimumWaitDurationFieldNumber;
+#endif  // !_MSC_VER
+
+FetchThreatListUpdatesResponse::FetchThreatListUpdatesResponse()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse)
+}
+
+void FetchThreatListUpdatesResponse::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  minimum_wait_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>(
+      ::mozilla::safebrowsing::Duration::internal_default_instance());
+#else
+  minimum_wait_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>(&::mozilla::safebrowsing::Duration::default_instance());
+#endif
+}
+
+FetchThreatListUpdatesResponse::FetchThreatListUpdatesResponse(const FetchThreatListUpdatesResponse& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse)
+}
+
+void FetchThreatListUpdatesResponse::SharedCtor() {
+  _cached_size_ = 0;
+  minimum_wait_duration_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+FetchThreatListUpdatesResponse::~FetchThreatListUpdatesResponse() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FetchThreatListUpdatesResponse)
+  SharedDtor();
+}
+
+void FetchThreatListUpdatesResponse::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete minimum_wait_duration_;
+  }
+}
+
+void FetchThreatListUpdatesResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const FetchThreatListUpdatesResponse& FetchThreatListUpdatesResponse::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+FetchThreatListUpdatesResponse* FetchThreatListUpdatesResponse::default_instance_ = NULL;
+
+FetchThreatListUpdatesResponse* FetchThreatListUpdatesResponse::New() const {
+  return new FetchThreatListUpdatesResponse;
+}
+
+void FetchThreatListUpdatesResponse::Clear() {
+  if (has_minimum_wait_duration()) {
+    if (minimum_wait_duration_ != NULL) minimum_wait_duration_->::mozilla::safebrowsing::Duration::Clear();
+  }
+  list_update_responses_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool FetchThreatListUpdatesResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_list_update_responses:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_list_update_responses()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_list_update_responses;
+        if (input->ExpectTag(18)) goto parse_minimum_wait_duration;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_minimum_wait_duration:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_minimum_wait_duration()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.FetchThreatListUpdatesResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.FetchThreatListUpdatesResponse)
+  return false;
+#undef DO_
+}
+
+void FetchThreatListUpdatesResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.FetchThreatListUpdatesResponse)
+  // repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1;
+  for (int i = 0; i < this->list_update_responses_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->list_update_responses(i), output);
+  }
+
+  // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
+  if (has_minimum_wait_duration()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->minimum_wait_duration(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.FetchThreatListUpdatesResponse)
+}
+
+int FetchThreatListUpdatesResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
+    if (has_minimum_wait_duration()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->minimum_wait_duration());
+    }
+
+  }
+  // repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1;
+  total_size += 1 * this->list_update_responses_size();
+  for (int i = 0; i < this->list_update_responses_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->list_update_responses(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void FetchThreatListUpdatesResponse::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const FetchThreatListUpdatesResponse*>(&from));
+}
+
+void FetchThreatListUpdatesResponse::MergeFrom(const FetchThreatListUpdatesResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  list_update_responses_.MergeFrom(from.list_update_responses_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_minimum_wait_duration()) {
+      mutable_minimum_wait_duration()->::mozilla::safebrowsing::Duration::MergeFrom(from.minimum_wait_duration());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void FetchThreatListUpdatesResponse::CopyFrom(const FetchThreatListUpdatesResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FetchThreatListUpdatesResponse::IsInitialized() const {
+
+  return true;
+}
+
+void FetchThreatListUpdatesResponse::Swap(FetchThreatListUpdatesResponse* other) {
+  if (other != this) {
+    list_update_responses_.Swap(&other->list_update_responses_);
+    std::swap(minimum_wait_duration_, other->minimum_wait_duration_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string FetchThreatListUpdatesResponse::GetTypeName() const {
+  return "mozilla.safebrowsing.FetchThreatListUpdatesResponse";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int FindFullHashesRequest::kClientFieldNumber;
+const int FindFullHashesRequest::kClientStatesFieldNumber;
+const int FindFullHashesRequest::kThreatInfoFieldNumber;
+#endif  // !_MSC_VER
+
+FindFullHashesRequest::FindFullHashesRequest()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.FindFullHashesRequest)
+}
+
+void FindFullHashesRequest::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  client_ = const_cast< ::mozilla::safebrowsing::ClientInfo*>(
+      ::mozilla::safebrowsing::ClientInfo::internal_default_instance());
+#else
+  client_ = const_cast< ::mozilla::safebrowsing::ClientInfo*>(&::mozilla::safebrowsing::ClientInfo::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  threat_info_ = const_cast< ::mozilla::safebrowsing::ThreatInfo*>(
+      ::mozilla::safebrowsing::ThreatInfo::internal_default_instance());
+#else
+  threat_info_ = const_cast< ::mozilla::safebrowsing::ThreatInfo*>(&::mozilla::safebrowsing::ThreatInfo::default_instance());
+#endif
+}
+
+FindFullHashesRequest::FindFullHashesRequest(const FindFullHashesRequest& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FindFullHashesRequest)
+}
+
+void FindFullHashesRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  client_ = NULL;
+  threat_info_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+FindFullHashesRequest::~FindFullHashesRequest() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FindFullHashesRequest)
+  SharedDtor();
+}
+
+void FindFullHashesRequest::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete client_;
+    delete threat_info_;
+  }
+}
+
+void FindFullHashesRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const FindFullHashesRequest& FindFullHashesRequest::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+FindFullHashesRequest* FindFullHashesRequest::default_instance_ = NULL;
+
+FindFullHashesRequest* FindFullHashesRequest::New() const {
+  return new FindFullHashesRequest;
+}
+
+void FindFullHashesRequest::Clear() {
+  if (_has_bits_[0 / 32] & 5) {
+    if (has_client()) {
+      if (client_ != NULL) client_->::mozilla::safebrowsing::ClientInfo::Clear();
+    }
+    if (has_threat_info()) {
+      if (threat_info_ != NULL) threat_info_->::mozilla::safebrowsing::ThreatInfo::Clear();
+    }
+  }
+  client_states_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool FindFullHashesRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.FindFullHashesRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .mozilla.safebrowsing.ClientInfo client = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_client()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_client_states;
+        break;
+      }
+
+      // repeated bytes client_states = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_client_states:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->add_client_states()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_client_states;
+        if (input->ExpectTag(26)) goto parse_threat_info;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.ThreatInfo threat_info = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_threat_info:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_threat_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.FindFullHashesRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.FindFullHashesRequest)
+  return false;
+#undef DO_
+}
+
+void FindFullHashesRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.FindFullHashesRequest)
+  // optional .mozilla.safebrowsing.ClientInfo client = 1;
+  if (has_client()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->client(), output);
+  }
+
+  // repeated bytes client_states = 2;
+  for (int i = 0; i < this->client_states_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytes(
+      2, this->client_states(i), output);
+  }
+
+  // optional .mozilla.safebrowsing.ThreatInfo threat_info = 3;
+  if (has_threat_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->threat_info(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.FindFullHashesRequest)
+}
+
+int FindFullHashesRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .mozilla.safebrowsing.ClientInfo client = 1;
+    if (has_client()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->client());
+    }
+
+    // optional .mozilla.safebrowsing.ThreatInfo threat_info = 3;
+    if (has_threat_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->threat_info());
+    }
+
+  }
+  // repeated bytes client_states = 2;
+  total_size += 1 * this->client_states_size();
+  for (int i = 0; i < this->client_states_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
+      this->client_states(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void FindFullHashesRequest::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const FindFullHashesRequest*>(&from));
+}
+
+void FindFullHashesRequest::MergeFrom(const FindFullHashesRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  client_states_.MergeFrom(from.client_states_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_client()) {
+      mutable_client()->::mozilla::safebrowsing::ClientInfo::MergeFrom(from.client());
+    }
+    if (from.has_threat_info()) {
+      mutable_threat_info()->::mozilla::safebrowsing::ThreatInfo::MergeFrom(from.threat_info());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void FindFullHashesRequest::CopyFrom(const FindFullHashesRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FindFullHashesRequest::IsInitialized() const {
+
+  return true;
+}
+
+void FindFullHashesRequest::Swap(FindFullHashesRequest* other) {
+  if (other != this) {
+    std::swap(client_, other->client_);
+    client_states_.Swap(&other->client_states_);
+    std::swap(threat_info_, other->threat_info_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string FindFullHashesRequest::GetTypeName() const {
+  return "mozilla.safebrowsing.FindFullHashesRequest";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int FindFullHashesResponse::kMatchesFieldNumber;
+const int FindFullHashesResponse::kMinimumWaitDurationFieldNumber;
+const int FindFullHashesResponse::kNegativeCacheDurationFieldNumber;
+#endif  // !_MSC_VER
+
+FindFullHashesResponse::FindFullHashesResponse()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.FindFullHashesResponse)
+}
+
+void FindFullHashesResponse::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  minimum_wait_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>(
+      ::mozilla::safebrowsing::Duration::internal_default_instance());
+#else
+  minimum_wait_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>(&::mozilla::safebrowsing::Duration::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  negative_cache_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>(
+      ::mozilla::safebrowsing::Duration::internal_default_instance());
+#else
+  negative_cache_duration_ = const_cast< ::mozilla::safebrowsing::Duration*>(&::mozilla::safebrowsing::Duration::default_instance());
+#endif
+}
+
+FindFullHashesResponse::FindFullHashesResponse(const FindFullHashesResponse& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.FindFullHashesResponse)
+}
+
+void FindFullHashesResponse::SharedCtor() {
+  _cached_size_ = 0;
+  minimum_wait_duration_ = NULL;
+  negative_cache_duration_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+FindFullHashesResponse::~FindFullHashesResponse() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.FindFullHashesResponse)
+  SharedDtor();
+}
+
+void FindFullHashesResponse::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete minimum_wait_duration_;
+    delete negative_cache_duration_;
+  }
+}
+
+void FindFullHashesResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const FindFullHashesResponse& FindFullHashesResponse::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+FindFullHashesResponse* FindFullHashesResponse::default_instance_ = NULL;
+
+FindFullHashesResponse* FindFullHashesResponse::New() const {
+  return new FindFullHashesResponse;
+}
+
+void FindFullHashesResponse::Clear() {
+  if (_has_bits_[0 / 32] & 6) {
+    if (has_minimum_wait_duration()) {
+      if (minimum_wait_duration_ != NULL) minimum_wait_duration_->::mozilla::safebrowsing::Duration::Clear();
+    }
+    if (has_negative_cache_duration()) {
+      if (negative_cache_duration_ != NULL) negative_cache_duration_->::mozilla::safebrowsing::Duration::Clear();
+    }
+  }
+  matches_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool FindFullHashesResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.FindFullHashesResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_matches:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_matches()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_matches;
+        if (input->ExpectTag(18)) goto parse_minimum_wait_duration;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_minimum_wait_duration:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_minimum_wait_duration()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_negative_cache_duration;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.Duration negative_cache_duration = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_negative_cache_duration:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_negative_cache_duration()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.FindFullHashesResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.FindFullHashesResponse)
+  return false;
+#undef DO_
+}
+
+void FindFullHashesResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.FindFullHashesResponse)
+  // repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
+  for (int i = 0; i < this->matches_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->matches(i), output);
+  }
+
+  // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
+  if (has_minimum_wait_duration()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->minimum_wait_duration(), output);
+  }
+
+  // optional .mozilla.safebrowsing.Duration negative_cache_duration = 3;
+  if (has_negative_cache_duration()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->negative_cache_duration(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.FindFullHashesResponse)
+}
+
+int FindFullHashesResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
+    if (has_minimum_wait_duration()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->minimum_wait_duration());
+    }
+
+    // optional .mozilla.safebrowsing.Duration negative_cache_duration = 3;
+    if (has_negative_cache_duration()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->negative_cache_duration());
+    }
+
+  }
+  // repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
+  total_size += 1 * this->matches_size();
+  for (int i = 0; i < this->matches_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->matches(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void FindFullHashesResponse::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const FindFullHashesResponse*>(&from));
+}
+
+void FindFullHashesResponse::MergeFrom(const FindFullHashesResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  matches_.MergeFrom(from.matches_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_minimum_wait_duration()) {
+      mutable_minimum_wait_duration()->::mozilla::safebrowsing::Duration::MergeFrom(from.minimum_wait_duration());
+    }
+    if (from.has_negative_cache_duration()) {
+      mutable_negative_cache_duration()->::mozilla::safebrowsing::Duration::MergeFrom(from.negative_cache_duration());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void FindFullHashesResponse::CopyFrom(const FindFullHashesResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FindFullHashesResponse::IsInitialized() const {
+
+  return true;
+}
+
+void FindFullHashesResponse::Swap(FindFullHashesResponse* other) {
+  if (other != this) {
+    matches_.Swap(&other->matches_);
+    std::swap(minimum_wait_duration_, other->minimum_wait_duration_);
+    std::swap(negative_cache_duration_, other->negative_cache_duration_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string FindFullHashesResponse::GetTypeName() const {
+  return "mozilla.safebrowsing.FindFullHashesResponse";
+}
+
+
+// ===================================================================
+
+bool ThreatHit_ThreatSourceType_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const ThreatHit_ThreatSourceType ThreatHit::THREAT_SOURCE_TYPE_UNSPECIFIED;
+const ThreatHit_ThreatSourceType ThreatHit::MATCHING_URL;
+const ThreatHit_ThreatSourceType ThreatHit::TAB_URL;
+const ThreatHit_ThreatSourceType ThreatHit::TAB_REDIRECT;
+const ThreatHit_ThreatSourceType ThreatHit::ThreatSourceType_MIN;
+const ThreatHit_ThreatSourceType ThreatHit::ThreatSourceType_MAX;
+const int ThreatHit::ThreatSourceType_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int ThreatHit_ThreatSource::kUrlFieldNumber;
+const int ThreatHit_ThreatSource::kTypeFieldNumber;
+const int ThreatHit_ThreatSource::kRemoteIpFieldNumber;
+const int ThreatHit_ThreatSource::kReferrerFieldNumber;
+#endif  // !_MSC_VER
+
+ThreatHit_ThreatSource::ThreatHit_ThreatSource()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatHit.ThreatSource)
+}
+
+void ThreatHit_ThreatSource::InitAsDefaultInstance() {
+}
+
+ThreatHit_ThreatSource::ThreatHit_ThreatSource(const ThreatHit_ThreatSource& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatHit.ThreatSource)
+}
+
+void ThreatHit_ThreatSource::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  type_ = 0;
+  remote_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ThreatHit_ThreatSource::~ThreatHit_ThreatSource() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatHit.ThreatSource)
+  SharedDtor();
+}
+
+void ThreatHit_ThreatSource::SharedDtor() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (remote_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete remote_ip_;
+  }
+  if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete referrer_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ThreatHit_ThreatSource::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ThreatHit_ThreatSource& ThreatHit_ThreatSource::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ThreatHit_ThreatSource* ThreatHit_ThreatSource::default_instance_ = NULL;
+
+ThreatHit_ThreatSource* ThreatHit_ThreatSource::New() const {
+  return new ThreatHit_ThreatSource;
+}
+
+void ThreatHit_ThreatSource::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_url()) {
+      if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        url_->clear();
+      }
+    }
+    type_ = 0;
+    if (has_remote_ip()) {
+      if (remote_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        remote_ip_->clear();
+      }
+    }
+    if (has_referrer()) {
+      if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        referrer_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ThreatHit_ThreatSource::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ThreatHit.ThreatSource)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string url = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_url()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_type;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::ThreatHit_ThreatSourceType_IsValid(value)) {
+            set_type(static_cast< ::mozilla::safebrowsing::ThreatHit_ThreatSourceType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_remote_ip;
+        break;
+      }
+
+      // optional string remote_ip = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_remote_ip:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_remote_ip()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_referrer;
+        break;
+      }
+
+      // optional string referrer = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_referrer:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_referrer()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.ThreatHit.ThreatSource)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ThreatHit.ThreatSource)
+  return false;
+#undef DO_
+}
+
+void ThreatHit_ThreatSource::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ThreatHit.ThreatSource)
+  // optional string url = 1;
+  if (has_url()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->url(), output);
+  }
+
+  // optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->type(), output);
+  }
+
+  // optional string remote_ip = 3;
+  if (has_remote_ip()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->remote_ip(), output);
+  }
+
+  // optional string referrer = 4;
+  if (has_referrer()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->referrer(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ThreatHit.ThreatSource)
+}
+
+int ThreatHit_ThreatSource::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string url = 1;
+    if (has_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->url());
+    }
+
+    // optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
+    }
+
+    // optional string remote_ip = 3;
+    if (has_remote_ip()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->remote_ip());
+    }
+
+    // optional string referrer = 4;
+    if (has_referrer()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->referrer());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ThreatHit_ThreatSource::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ThreatHit_ThreatSource*>(&from));
+}
+
+void ThreatHit_ThreatSource::MergeFrom(const ThreatHit_ThreatSource& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_url()) {
+      set_url(from.url());
+    }
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+    if (from.has_remote_ip()) {
+      set_remote_ip(from.remote_ip());
+    }
+    if (from.has_referrer()) {
+      set_referrer(from.referrer());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ThreatHit_ThreatSource::CopyFrom(const ThreatHit_ThreatSource& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ThreatHit_ThreatSource::IsInitialized() const {
+
+  return true;
+}
+
+void ThreatHit_ThreatSource::Swap(ThreatHit_ThreatSource* other) {
+  if (other != this) {
+    std::swap(url_, other->url_);
+    std::swap(type_, other->type_);
+    std::swap(remote_ip_, other->remote_ip_);
+    std::swap(referrer_, other->referrer_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ThreatHit_ThreatSource::GetTypeName() const {
+  return "mozilla.safebrowsing.ThreatHit.ThreatSource";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ThreatHit::kThreatTypeFieldNumber;
+const int ThreatHit::kPlatformTypeFieldNumber;
+const int ThreatHit::kEntryFieldNumber;
+const int ThreatHit::kResourcesFieldNumber;
+#endif  // !_MSC_VER
+
+ThreatHit::ThreatHit()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatHit)
+}
+
+void ThreatHit::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  entry_ = const_cast< ::mozilla::safebrowsing::ThreatEntry*>(
+      ::mozilla::safebrowsing::ThreatEntry::internal_default_instance());
+#else
+  entry_ = const_cast< ::mozilla::safebrowsing::ThreatEntry*>(&::mozilla::safebrowsing::ThreatEntry::default_instance());
+#endif
+}
+
+ThreatHit::ThreatHit(const ThreatHit& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatHit)
+}
+
+void ThreatHit::SharedCtor() {
+  _cached_size_ = 0;
+  threat_type_ = 0;
+  platform_type_ = 0;
+  entry_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ThreatHit::~ThreatHit() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatHit)
+  SharedDtor();
+}
+
+void ThreatHit::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete entry_;
+  }
+}
+
+void ThreatHit::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ThreatHit& ThreatHit::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ThreatHit* ThreatHit::default_instance_ = NULL;
+
+ThreatHit* ThreatHit::New() const {
+  return new ThreatHit;
+}
+
+void ThreatHit::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ThreatHit*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(threat_type_, platform_type_);
+    if (has_entry()) {
+      if (entry_ != NULL) entry_->::mozilla::safebrowsing::ThreatEntry::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  resources_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ThreatHit::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ThreatHit)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+      case 1: {
+        if (tag == 8) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::ThreatType_IsValid(value)) {
+            set_threat_type(static_cast< ::mozilla::safebrowsing::ThreatType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_platform_type;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_platform_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::PlatformType_IsValid(value)) {
+            set_platform_type(static_cast< ::mozilla::safebrowsing::PlatformType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_entry;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.ThreatEntry entry = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_entry:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entry()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_resources;
+        break;
+      }
+
+      // repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_resources:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_resources()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_resources;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.ThreatHit)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ThreatHit)
+  return false;
+#undef DO_
+}
+
+void ThreatHit::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ThreatHit)
+  // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+  if (has_threat_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->threat_type(), output);
+  }
+
+  // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+  if (has_platform_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->platform_type(), output);
+  }
+
+  // optional .mozilla.safebrowsing.ThreatEntry entry = 3;
+  if (has_entry()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->entry(), output);
+  }
+
+  // repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4;
+  for (int i = 0; i < this->resources_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      4, this->resources(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ThreatHit)
+}
+
+int ThreatHit::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+    if (has_threat_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_type());
+    }
+
+    // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+    if (has_platform_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->platform_type());
+    }
+
+    // optional .mozilla.safebrowsing.ThreatEntry entry = 3;
+    if (has_entry()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entry());
+    }
+
+  }
+  // repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4;
+  total_size += 1 * this->resources_size();
+  for (int i = 0; i < this->resources_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->resources(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ThreatHit::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ThreatHit*>(&from));
+}
+
+void ThreatHit::MergeFrom(const ThreatHit& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  resources_.MergeFrom(from.resources_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_threat_type()) {
+      set_threat_type(from.threat_type());
+    }
+    if (from.has_platform_type()) {
+      set_platform_type(from.platform_type());
+    }
+    if (from.has_entry()) {
+      mutable_entry()->::mozilla::safebrowsing::ThreatEntry::MergeFrom(from.entry());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ThreatHit::CopyFrom(const ThreatHit& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ThreatHit::IsInitialized() const {
+
+  return true;
+}
+
+void ThreatHit::Swap(ThreatHit* other) {
+  if (other != this) {
+    std::swap(threat_type_, other->threat_type_);
+    std::swap(platform_type_, other->platform_type_);
+    std::swap(entry_, other->entry_);
+    resources_.Swap(&other->resources_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ThreatHit::GetTypeName() const {
+  return "mozilla.safebrowsing.ThreatHit";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClientInfo::kClientIdFieldNumber;
+const int ClientInfo::kClientVersionFieldNumber;
+#endif  // !_MSC_VER
+
+ClientInfo::ClientInfo()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ClientInfo)
+}
+
+void ClientInfo::InitAsDefaultInstance() {
+}
+
+ClientInfo::ClientInfo(const ClientInfo& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ClientInfo)
+}
+
+void ClientInfo::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  client_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  client_version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientInfo::~ClientInfo() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ClientInfo)
+  SharedDtor();
+}
+
+void ClientInfo::SharedDtor() {
+  if (client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete client_id_;
+  }
+  if (client_version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete client_version_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientInfo& ClientInfo::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientInfo* ClientInfo::default_instance_ = NULL;
+
+ClientInfo* ClientInfo::New() const {
+  return new ClientInfo;
+}
+
+void ClientInfo::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_client_id()) {
+      if (client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        client_id_->clear();
+      }
+    }
+    if (has_client_version()) {
+      if (client_version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        client_version_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ClientInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string client_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_client_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_client_version;
+        break;
+      }
+
+      // optional string client_version = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_client_version:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_client_version()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.ClientInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ClientInfo)
+  return false;
+#undef DO_
+}
+
+void ClientInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ClientInfo)
+  // optional string client_id = 1;
+  if (has_client_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->client_id(), output);
+  }
+
+  // optional string client_version = 2;
+  if (has_client_version()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->client_version(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ClientInfo)
+}
+
+int ClientInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string client_id = 1;
+    if (has_client_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->client_id());
+    }
+
+    // optional string client_version = 2;
+    if (has_client_version()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->client_version());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientInfo::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientInfo*>(&from));
+}
+
+void ClientInfo::MergeFrom(const ClientInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_client_id()) {
+      set_client_id(from.client_id());
+    }
+    if (from.has_client_version()) {
+      set_client_version(from.client_version());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientInfo::CopyFrom(const ClientInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientInfo::IsInitialized() const {
+
+  return true;
+}
+
+void ClientInfo::Swap(ClientInfo* other) {
+  if (other != this) {
+    std::swap(client_id_, other->client_id_);
+    std::swap(client_version_, other->client_version_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientInfo::GetTypeName() const {
+  return "mozilla.safebrowsing.ClientInfo";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Checksum::kSha256FieldNumber;
+#endif  // !_MSC_VER
+
+Checksum::Checksum()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.Checksum)
+}
+
+void Checksum::InitAsDefaultInstance() {
+}
+
+Checksum::Checksum(const Checksum& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.Checksum)
+}
+
+void Checksum::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  sha256_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Checksum::~Checksum() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.Checksum)
+  SharedDtor();
+}
+
+void Checksum::SharedDtor() {
+  if (sha256_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete sha256_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void Checksum::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const Checksum& Checksum::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+Checksum* Checksum::default_instance_ = NULL;
+
+Checksum* Checksum::New() const {
+  return new Checksum;
+}
+
+void Checksum::Clear() {
+  if (has_sha256()) {
+    if (sha256_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+      sha256_->clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool Checksum::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.Checksum)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bytes sha256 = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_sha256()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.Checksum)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.Checksum)
+  return false;
+#undef DO_
+}
+
+void Checksum::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.Checksum)
+  // optional bytes sha256 = 1;
+  if (has_sha256()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->sha256(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.Checksum)
+}
+
+int Checksum::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bytes sha256 = 1;
+    if (has_sha256()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->sha256());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Checksum::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const Checksum*>(&from));
+}
+
+void Checksum::MergeFrom(const Checksum& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_sha256()) {
+      set_sha256(from.sha256());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void Checksum::CopyFrom(const Checksum& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Checksum::IsInitialized() const {
+
+  return true;
+}
+
+void Checksum::Swap(Checksum* other) {
+  if (other != this) {
+    std::swap(sha256_, other->sha256_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string Checksum::GetTypeName() const {
+  return "mozilla.safebrowsing.Checksum";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ThreatEntry::kHashFieldNumber;
+const int ThreatEntry::kUrlFieldNumber;
+#endif  // !_MSC_VER
+
+ThreatEntry::ThreatEntry()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatEntry)
+}
+
+void ThreatEntry::InitAsDefaultInstance() {
+}
+
+ThreatEntry::ThreatEntry(const ThreatEntry& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatEntry)
+}
+
+void ThreatEntry::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  hash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ThreatEntry::~ThreatEntry() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatEntry)
+  SharedDtor();
+}
+
+void ThreatEntry::SharedDtor() {
+  if (hash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete hash_;
+  }
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ThreatEntry::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ThreatEntry& ThreatEntry::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ThreatEntry* ThreatEntry::default_instance_ = NULL;
+
+ThreatEntry* ThreatEntry::New() const {
+  return new ThreatEntry;
+}
+
+void ThreatEntry::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_hash()) {
+      if (hash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        hash_->clear();
+      }
+    }
+    if (has_url()) {
+      if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        url_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ThreatEntry::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ThreatEntry)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bytes hash = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_hash()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_url;
+        break;
+      }
+
+      // optional string url = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_url:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_url()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.ThreatEntry)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ThreatEntry)
+  return false;
+#undef DO_
+}
+
+void ThreatEntry::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ThreatEntry)
+  // optional bytes hash = 1;
+  if (has_hash()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->hash(), output);
+  }
+
+  // optional string url = 2;
+  if (has_url()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->url(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ThreatEntry)
+}
+
+int ThreatEntry::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bytes hash = 1;
+    if (has_hash()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->hash());
+    }
+
+    // optional string url = 2;
+    if (has_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->url());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ThreatEntry::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ThreatEntry*>(&from));
+}
+
+void ThreatEntry::MergeFrom(const ThreatEntry& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_hash()) {
+      set_hash(from.hash());
+    }
+    if (from.has_url()) {
+      set_url(from.url());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ThreatEntry::CopyFrom(const ThreatEntry& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ThreatEntry::IsInitialized() const {
+
+  return true;
+}
+
+void ThreatEntry::Swap(ThreatEntry* other) {
+  if (other != this) {
+    std::swap(hash_, other->hash_);
+    std::swap(url_, other->url_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ThreatEntry::GetTypeName() const {
+  return "mozilla.safebrowsing.ThreatEntry";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ThreatEntrySet::kCompressionTypeFieldNumber;
+const int ThreatEntrySet::kRawHashesFieldNumber;
+const int ThreatEntrySet::kRawIndicesFieldNumber;
+const int ThreatEntrySet::kRiceHashesFieldNumber;
+const int ThreatEntrySet::kRiceIndicesFieldNumber;
+#endif  // !_MSC_VER
+
+ThreatEntrySet::ThreatEntrySet()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatEntrySet)
+}
+
+void ThreatEntrySet::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  raw_hashes_ = const_cast< ::mozilla::safebrowsing::RawHashes*>(
+      ::mozilla::safebrowsing::RawHashes::internal_default_instance());
+#else
+  raw_hashes_ = const_cast< ::mozilla::safebrowsing::RawHashes*>(&::mozilla::safebrowsing::RawHashes::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  raw_indices_ = const_cast< ::mozilla::safebrowsing::RawIndices*>(
+      ::mozilla::safebrowsing::RawIndices::internal_default_instance());
+#else
+  raw_indices_ = const_cast< ::mozilla::safebrowsing::RawIndices*>(&::mozilla::safebrowsing::RawIndices::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  rice_hashes_ = const_cast< ::mozilla::safebrowsing::RiceDeltaEncoding*>(
+      ::mozilla::safebrowsing::RiceDeltaEncoding::internal_default_instance());
+#else
+  rice_hashes_ = const_cast< ::mozilla::safebrowsing::RiceDeltaEncoding*>(&::mozilla::safebrowsing::RiceDeltaEncoding::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  rice_indices_ = const_cast< ::mozilla::safebrowsing::RiceDeltaEncoding*>(
+      ::mozilla::safebrowsing::RiceDeltaEncoding::internal_default_instance());
+#else
+  rice_indices_ = const_cast< ::mozilla::safebrowsing::RiceDeltaEncoding*>(&::mozilla::safebrowsing::RiceDeltaEncoding::default_instance());
+#endif
+}
+
+ThreatEntrySet::ThreatEntrySet(const ThreatEntrySet& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatEntrySet)
+}
+
+void ThreatEntrySet::SharedCtor() {
+  _cached_size_ = 0;
+  compression_type_ = 0;
+  raw_hashes_ = NULL;
+  raw_indices_ = NULL;
+  rice_hashes_ = NULL;
+  rice_indices_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ThreatEntrySet::~ThreatEntrySet() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatEntrySet)
+  SharedDtor();
+}
+
+void ThreatEntrySet::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete raw_hashes_;
+    delete raw_indices_;
+    delete rice_hashes_;
+    delete rice_indices_;
+  }
+}
+
+void ThreatEntrySet::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ThreatEntrySet& ThreatEntrySet::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ThreatEntrySet* ThreatEntrySet::default_instance_ = NULL;
+
+ThreatEntrySet* ThreatEntrySet::New() const {
+  return new ThreatEntrySet;
+}
+
+void ThreatEntrySet::Clear() {
+  if (_has_bits_[0 / 32] & 31) {
+    compression_type_ = 0;
+    if (has_raw_hashes()) {
+      if (raw_hashes_ != NULL) raw_hashes_->::mozilla::safebrowsing::RawHashes::Clear();
+    }
+    if (has_raw_indices()) {
+      if (raw_indices_ != NULL) raw_indices_->::mozilla::safebrowsing::RawIndices::Clear();
+    }
+    if (has_rice_hashes()) {
+      if (rice_hashes_ != NULL) rice_hashes_->::mozilla::safebrowsing::RiceDeltaEncoding::Clear();
+    }
+    if (has_rice_indices()) {
+      if (rice_indices_ != NULL) rice_indices_->::mozilla::safebrowsing::RiceDeltaEncoding::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ThreatEntrySet::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ThreatEntrySet)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .mozilla.safebrowsing.CompressionType compression_type = 1;
+      case 1: {
+        if (tag == 8) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::CompressionType_IsValid(value)) {
+            set_compression_type(static_cast< ::mozilla::safebrowsing::CompressionType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_raw_hashes;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.RawHashes raw_hashes = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_raw_hashes:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_raw_hashes()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_raw_indices;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.RawIndices raw_indices = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_raw_indices:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_raw_indices()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_rice_hashes;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_rice_hashes:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_rice_hashes()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_rice_indices;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_rice_indices:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_rice_indices()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.ThreatEntrySet)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ThreatEntrySet)
+  return false;
+#undef DO_
+}
+
+void ThreatEntrySet::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ThreatEntrySet)
+  // optional .mozilla.safebrowsing.CompressionType compression_type = 1;
+  if (has_compression_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->compression_type(), output);
+  }
+
+  // optional .mozilla.safebrowsing.RawHashes raw_hashes = 2;
+  if (has_raw_hashes()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->raw_hashes(), output);
+  }
+
+  // optional .mozilla.safebrowsing.RawIndices raw_indices = 3;
+  if (has_raw_indices()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->raw_indices(), output);
+  }
+
+  // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4;
+  if (has_rice_hashes()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      4, this->rice_hashes(), output);
+  }
+
+  // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5;
+  if (has_rice_indices()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      5, this->rice_indices(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ThreatEntrySet)
+}
+
+int ThreatEntrySet::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .mozilla.safebrowsing.CompressionType compression_type = 1;
+    if (has_compression_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->compression_type());
+    }
+
+    // optional .mozilla.safebrowsing.RawHashes raw_hashes = 2;
+    if (has_raw_hashes()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->raw_hashes());
+    }
+
+    // optional .mozilla.safebrowsing.RawIndices raw_indices = 3;
+    if (has_raw_indices()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->raw_indices());
+    }
+
+    // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4;
+    if (has_rice_hashes()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->rice_hashes());
+    }
+
+    // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5;
+    if (has_rice_indices()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->rice_indices());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ThreatEntrySet::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ThreatEntrySet*>(&from));
+}
+
+void ThreatEntrySet::MergeFrom(const ThreatEntrySet& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_compression_type()) {
+      set_compression_type(from.compression_type());
+    }
+    if (from.has_raw_hashes()) {
+      mutable_raw_hashes()->::mozilla::safebrowsing::RawHashes::MergeFrom(from.raw_hashes());
+    }
+    if (from.has_raw_indices()) {
+      mutable_raw_indices()->::mozilla::safebrowsing::RawIndices::MergeFrom(from.raw_indices());
+    }
+    if (from.has_rice_hashes()) {
+      mutable_rice_hashes()->::mozilla::safebrowsing::RiceDeltaEncoding::MergeFrom(from.rice_hashes());
+    }
+    if (from.has_rice_indices()) {
+      mutable_rice_indices()->::mozilla::safebrowsing::RiceDeltaEncoding::MergeFrom(from.rice_indices());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ThreatEntrySet::CopyFrom(const ThreatEntrySet& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ThreatEntrySet::IsInitialized() const {
+
+  return true;
+}
+
+void ThreatEntrySet::Swap(ThreatEntrySet* other) {
+  if (other != this) {
+    std::swap(compression_type_, other->compression_type_);
+    std::swap(raw_hashes_, other->raw_hashes_);
+    std::swap(raw_indices_, other->raw_indices_);
+    std::swap(rice_hashes_, other->rice_hashes_);
+    std::swap(rice_indices_, other->rice_indices_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ThreatEntrySet::GetTypeName() const {
+  return "mozilla.safebrowsing.ThreatEntrySet";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RawIndices::kIndicesFieldNumber;
+#endif  // !_MSC_VER
+
+RawIndices::RawIndices()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.RawIndices)
+}
+
+void RawIndices::InitAsDefaultInstance() {
+}
+
+RawIndices::RawIndices(const RawIndices& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.RawIndices)
+}
+
+void RawIndices::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RawIndices::~RawIndices() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.RawIndices)
+  SharedDtor();
+}
+
+void RawIndices::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void RawIndices::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const RawIndices& RawIndices::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+RawIndices* RawIndices::default_instance_ = NULL;
+
+RawIndices* RawIndices::New() const {
+  return new RawIndices;
+}
+
+void RawIndices::Clear() {
+  indices_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool RawIndices::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.RawIndices)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated int32 indices = 1;
+      case 1: {
+        if (tag == 8) {
+         parse_indices:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 1, 8, input, this->mutable_indices())));
+        } else if (tag == 10) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, this->mutable_indices())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(8)) goto parse_indices;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.RawIndices)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.RawIndices)
+  return false;
+#undef DO_
+}
+
+void RawIndices::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.RawIndices)
+  // repeated int32 indices = 1;
+  for (int i = 0; i < this->indices_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(
+      1, this->indices(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.RawIndices)
+}
+
+int RawIndices::ByteSize() const {
+  int total_size = 0;
+
+  // repeated int32 indices = 1;
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->indices_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        Int32Size(this->indices(i));
+    }
+    total_size += 1 * this->indices_size() + data_size;
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RawIndices::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const RawIndices*>(&from));
+}
+
+void RawIndices::MergeFrom(const RawIndices& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  indices_.MergeFrom(from.indices_);
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void RawIndices::CopyFrom(const RawIndices& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RawIndices::IsInitialized() const {
+
+  return true;
+}
+
+void RawIndices::Swap(RawIndices* other) {
+  if (other != this) {
+    indices_.Swap(&other->indices_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string RawIndices::GetTypeName() const {
+  return "mozilla.safebrowsing.RawIndices";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RawHashes::kPrefixSizeFieldNumber;
+const int RawHashes::kRawHashesFieldNumber;
+#endif  // !_MSC_VER
+
+RawHashes::RawHashes()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.RawHashes)
+}
+
+void RawHashes::InitAsDefaultInstance() {
+}
+
+RawHashes::RawHashes(const RawHashes& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.RawHashes)
+}
+
+void RawHashes::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  prefix_size_ = 0;
+  raw_hashes_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RawHashes::~RawHashes() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.RawHashes)
+  SharedDtor();
+}
+
+void RawHashes::SharedDtor() {
+  if (raw_hashes_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete raw_hashes_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void RawHashes::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const RawHashes& RawHashes::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+RawHashes* RawHashes::default_instance_ = NULL;
+
+RawHashes* RawHashes::New() const {
+  return new RawHashes;
+}
+
+void RawHashes::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    prefix_size_ = 0;
+    if (has_raw_hashes()) {
+      if (raw_hashes_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        raw_hashes_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool RawHashes::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.RawHashes)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional int32 prefix_size = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &prefix_size_)));
+          set_has_prefix_size();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_raw_hashes;
+        break;
+      }
+
+      // optional bytes raw_hashes = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_raw_hashes:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_raw_hashes()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.RawHashes)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.RawHashes)
+  return false;
+#undef DO_
+}
+
+void RawHashes::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.RawHashes)
+  // optional int32 prefix_size = 1;
+  if (has_prefix_size()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->prefix_size(), output);
+  }
+
+  // optional bytes raw_hashes = 2;
+  if (has_raw_hashes()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      2, this->raw_hashes(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.RawHashes)
+}
+
+int RawHashes::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional int32 prefix_size = 1;
+    if (has_prefix_size()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->prefix_size());
+    }
+
+    // optional bytes raw_hashes = 2;
+    if (has_raw_hashes()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->raw_hashes());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RawHashes::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const RawHashes*>(&from));
+}
+
+void RawHashes::MergeFrom(const RawHashes& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_prefix_size()) {
+      set_prefix_size(from.prefix_size());
+    }
+    if (from.has_raw_hashes()) {
+      set_raw_hashes(from.raw_hashes());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void RawHashes::CopyFrom(const RawHashes& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RawHashes::IsInitialized() const {
+
+  return true;
+}
+
+void RawHashes::Swap(RawHashes* other) {
+  if (other != this) {
+    std::swap(prefix_size_, other->prefix_size_);
+    std::swap(raw_hashes_, other->raw_hashes_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string RawHashes::GetTypeName() const {
+  return "mozilla.safebrowsing.RawHashes";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RiceDeltaEncoding::kFirstValueFieldNumber;
+const int RiceDeltaEncoding::kRiceParameterFieldNumber;
+const int RiceDeltaEncoding::kNumEntriesFieldNumber;
+const int RiceDeltaEncoding::kEncodedDataFieldNumber;
+#endif  // !_MSC_VER
+
+RiceDeltaEncoding::RiceDeltaEncoding()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.RiceDeltaEncoding)
+}
+
+void RiceDeltaEncoding::InitAsDefaultInstance() {
+}
+
+RiceDeltaEncoding::RiceDeltaEncoding(const RiceDeltaEncoding& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.RiceDeltaEncoding)
+}
+
+void RiceDeltaEncoding::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  first_value_ = GOOGLE_LONGLONG(0);
+  rice_parameter_ = 0;
+  num_entries_ = 0;
+  encoded_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RiceDeltaEncoding::~RiceDeltaEncoding() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.RiceDeltaEncoding)
+  SharedDtor();
+}
+
+void RiceDeltaEncoding::SharedDtor() {
+  if (encoded_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete encoded_data_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void RiceDeltaEncoding::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const RiceDeltaEncoding& RiceDeltaEncoding::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+RiceDeltaEncoding* RiceDeltaEncoding::default_instance_ = NULL;
+
+RiceDeltaEncoding* RiceDeltaEncoding::New() const {
+  return new RiceDeltaEncoding;
+}
+
+void RiceDeltaEncoding::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<RiceDeltaEncoding*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(first_value_, num_entries_);
+    if (has_encoded_data()) {
+      if (encoded_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        encoded_data_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool RiceDeltaEncoding::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.RiceDeltaEncoding)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional int64 first_value = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &first_value_)));
+          set_has_first_value();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_rice_parameter;
+        break;
+      }
+
+      // optional int32 rice_parameter = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_rice_parameter:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &rice_parameter_)));
+          set_has_rice_parameter();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_num_entries;
+        break;
+      }
+
+      // optional int32 num_entries = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_num_entries:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &num_entries_)));
+          set_has_num_entries();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_encoded_data;
+        break;
+      }
+
+      // optional bytes encoded_data = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_encoded_data:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_encoded_data()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.RiceDeltaEncoding)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.RiceDeltaEncoding)
+  return false;
+#undef DO_
+}
+
+void RiceDeltaEncoding::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.RiceDeltaEncoding)
+  // optional int64 first_value = 1;
+  if (has_first_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->first_value(), output);
+  }
+
+  // optional int32 rice_parameter = 2;
+  if (has_rice_parameter()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->rice_parameter(), output);
+  }
+
+  // optional int32 num_entries = 3;
+  if (has_num_entries()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->num_entries(), output);
+  }
+
+  // optional bytes encoded_data = 4;
+  if (has_encoded_data()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      4, this->encoded_data(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.RiceDeltaEncoding)
+}
+
+int RiceDeltaEncoding::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional int64 first_value = 1;
+    if (has_first_value()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->first_value());
+    }
+
+    // optional int32 rice_parameter = 2;
+    if (has_rice_parameter()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->rice_parameter());
+    }
+
+    // optional int32 num_entries = 3;
+    if (has_num_entries()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->num_entries());
+    }
+
+    // optional bytes encoded_data = 4;
+    if (has_encoded_data()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->encoded_data());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RiceDeltaEncoding::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const RiceDeltaEncoding*>(&from));
+}
+
+void RiceDeltaEncoding::MergeFrom(const RiceDeltaEncoding& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_first_value()) {
+      set_first_value(from.first_value());
+    }
+    if (from.has_rice_parameter()) {
+      set_rice_parameter(from.rice_parameter());
+    }
+    if (from.has_num_entries()) {
+      set_num_entries(from.num_entries());
+    }
+    if (from.has_encoded_data()) {
+      set_encoded_data(from.encoded_data());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void RiceDeltaEncoding::CopyFrom(const RiceDeltaEncoding& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RiceDeltaEncoding::IsInitialized() const {
+
+  return true;
+}
+
+void RiceDeltaEncoding::Swap(RiceDeltaEncoding* other) {
+  if (other != this) {
+    std::swap(first_value_, other->first_value_);
+    std::swap(rice_parameter_, other->rice_parameter_);
+    std::swap(num_entries_, other->num_entries_);
+    std::swap(encoded_data_, other->encoded_data_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string RiceDeltaEncoding::GetTypeName() const {
+  return "mozilla.safebrowsing.RiceDeltaEncoding";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ThreatEntryMetadata_MetadataEntry::kKeyFieldNumber;
+const int ThreatEntryMetadata_MetadataEntry::kValueFieldNumber;
+#endif  // !_MSC_VER
+
+ThreatEntryMetadata_MetadataEntry::ThreatEntryMetadata_MetadataEntry()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry)
+}
+
+void ThreatEntryMetadata_MetadataEntry::InitAsDefaultInstance() {
+}
+
+ThreatEntryMetadata_MetadataEntry::ThreatEntryMetadata_MetadataEntry(const ThreatEntryMetadata_MetadataEntry& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry)
+}
+
+void ThreatEntryMetadata_MetadataEntry::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ThreatEntryMetadata_MetadataEntry::~ThreatEntryMetadata_MetadataEntry() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry)
+  SharedDtor();
+}
+
+void ThreatEntryMetadata_MetadataEntry::SharedDtor() {
+  if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete key_;
+  }
+  if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete value_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ThreatEntryMetadata_MetadataEntry::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ThreatEntryMetadata_MetadataEntry& ThreatEntryMetadata_MetadataEntry::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ThreatEntryMetadata_MetadataEntry* ThreatEntryMetadata_MetadataEntry::default_instance_ = NULL;
+
+ThreatEntryMetadata_MetadataEntry* ThreatEntryMetadata_MetadataEntry::New() const {
+  return new ThreatEntryMetadata_MetadataEntry;
+}
+
+void ThreatEntryMetadata_MetadataEntry::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_key()) {
+      if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        key_->clear();
+      }
+    }
+    if (has_value()) {
+      if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        value_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ThreatEntryMetadata_MetadataEntry::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bytes key = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_key()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_value;
+        break;
+      }
+
+      // optional bytes value = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_value:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_value()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry)
+  return false;
+#undef DO_
+}
+
+void ThreatEntryMetadata_MetadataEntry::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry)
+  // optional bytes key = 1;
+  if (has_key()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->key(), output);
+  }
+
+  // optional bytes value = 2;
+  if (has_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      2, this->value(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry)
+}
+
+int ThreatEntryMetadata_MetadataEntry::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bytes key = 1;
+    if (has_key()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->key());
+    }
+
+    // optional bytes value = 2;
+    if (has_value()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->value());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ThreatEntryMetadata_MetadataEntry::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ThreatEntryMetadata_MetadataEntry*>(&from));
+}
+
+void ThreatEntryMetadata_MetadataEntry::MergeFrom(const ThreatEntryMetadata_MetadataEntry& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_key()) {
+      set_key(from.key());
+    }
+    if (from.has_value()) {
+      set_value(from.value());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ThreatEntryMetadata_MetadataEntry::CopyFrom(const ThreatEntryMetadata_MetadataEntry& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ThreatEntryMetadata_MetadataEntry::IsInitialized() const {
+
+  return true;
+}
+
+void ThreatEntryMetadata_MetadataEntry::Swap(ThreatEntryMetadata_MetadataEntry* other) {
+  if (other != this) {
+    std::swap(key_, other->key_);
+    std::swap(value_, other->value_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ThreatEntryMetadata_MetadataEntry::GetTypeName() const {
+  return "mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ThreatEntryMetadata::kEntriesFieldNumber;
+#endif  // !_MSC_VER
+
+ThreatEntryMetadata::ThreatEntryMetadata()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatEntryMetadata)
+}
+
+void ThreatEntryMetadata::InitAsDefaultInstance() {
+}
+
+ThreatEntryMetadata::ThreatEntryMetadata(const ThreatEntryMetadata& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatEntryMetadata)
+}
+
+void ThreatEntryMetadata::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ThreatEntryMetadata::~ThreatEntryMetadata() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatEntryMetadata)
+  SharedDtor();
+}
+
+void ThreatEntryMetadata::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ThreatEntryMetadata::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ThreatEntryMetadata& ThreatEntryMetadata::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ThreatEntryMetadata* ThreatEntryMetadata::default_instance_ = NULL;
+
+ThreatEntryMetadata* ThreatEntryMetadata::New() const {
+  return new ThreatEntryMetadata;
+}
+
+void ThreatEntryMetadata::Clear() {
+  entries_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ThreatEntryMetadata::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ThreatEntryMetadata)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_entries:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_entries()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_entries;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.ThreatEntryMetadata)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ThreatEntryMetadata)
+  return false;
+#undef DO_
+}
+
+void ThreatEntryMetadata::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ThreatEntryMetadata)
+  // repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1;
+  for (int i = 0; i < this->entries_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->entries(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ThreatEntryMetadata)
+}
+
+int ThreatEntryMetadata::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1;
+  total_size += 1 * this->entries_size();
+  for (int i = 0; i < this->entries_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->entries(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ThreatEntryMetadata::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ThreatEntryMetadata*>(&from));
+}
+
+void ThreatEntryMetadata::MergeFrom(const ThreatEntryMetadata& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  entries_.MergeFrom(from.entries_);
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ThreatEntryMetadata::CopyFrom(const ThreatEntryMetadata& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ThreatEntryMetadata::IsInitialized() const {
+
+  return true;
+}
+
+void ThreatEntryMetadata::Swap(ThreatEntryMetadata* other) {
+  if (other != this) {
+    entries_.Swap(&other->entries_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ThreatEntryMetadata::GetTypeName() const {
+  return "mozilla.safebrowsing.ThreatEntryMetadata";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ThreatListDescriptor::kThreatTypeFieldNumber;
+const int ThreatListDescriptor::kPlatformTypeFieldNumber;
+const int ThreatListDescriptor::kThreatEntryTypeFieldNumber;
+#endif  // !_MSC_VER
+
+ThreatListDescriptor::ThreatListDescriptor()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ThreatListDescriptor)
+}
+
+void ThreatListDescriptor::InitAsDefaultInstance() {
+}
+
+ThreatListDescriptor::ThreatListDescriptor(const ThreatListDescriptor& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ThreatListDescriptor)
+}
+
+void ThreatListDescriptor::SharedCtor() {
+  _cached_size_ = 0;
+  threat_type_ = 0;
+  platform_type_ = 0;
+  threat_entry_type_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ThreatListDescriptor::~ThreatListDescriptor() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ThreatListDescriptor)
+  SharedDtor();
+}
+
+void ThreatListDescriptor::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ThreatListDescriptor::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ThreatListDescriptor& ThreatListDescriptor::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ThreatListDescriptor* ThreatListDescriptor::default_instance_ = NULL;
+
+ThreatListDescriptor* ThreatListDescriptor::New() const {
+  return new ThreatListDescriptor;
+}
+
+void ThreatListDescriptor::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ThreatListDescriptor*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(threat_type_, threat_entry_type_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ThreatListDescriptor::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ThreatListDescriptor)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+      case 1: {
+        if (tag == 8) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::ThreatType_IsValid(value)) {
+            set_threat_type(static_cast< ::mozilla::safebrowsing::ThreatType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_platform_type;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_platform_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::PlatformType_IsValid(value)) {
+            set_platform_type(static_cast< ::mozilla::safebrowsing::PlatformType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_threat_entry_type;
+        break;
+      }
+
+      // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_threat_entry_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::mozilla::safebrowsing::ThreatEntryType_IsValid(value)) {
+            set_threat_entry_type(static_cast< ::mozilla::safebrowsing::ThreatEntryType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.ThreatListDescriptor)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ThreatListDescriptor)
+  return false;
+#undef DO_
+}
+
+void ThreatListDescriptor::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ThreatListDescriptor)
+  // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+  if (has_threat_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->threat_type(), output);
+  }
+
+  // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+  if (has_platform_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->platform_type(), output);
+  }
+
+  // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3;
+  if (has_threat_entry_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      3, this->threat_entry_type(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ThreatListDescriptor)
+}
+
+int ThreatListDescriptor::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+    if (has_threat_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_type());
+    }
+
+    // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+    if (has_platform_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->platform_type());
+    }
+
+    // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3;
+    if (has_threat_entry_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->threat_entry_type());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ThreatListDescriptor::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ThreatListDescriptor*>(&from));
+}
+
+void ThreatListDescriptor::MergeFrom(const ThreatListDescriptor& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_threat_type()) {
+      set_threat_type(from.threat_type());
+    }
+    if (from.has_platform_type()) {
+      set_platform_type(from.platform_type());
+    }
+    if (from.has_threat_entry_type()) {
+      set_threat_entry_type(from.threat_entry_type());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ThreatListDescriptor::CopyFrom(const ThreatListDescriptor& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ThreatListDescriptor::IsInitialized() const {
+
+  return true;
+}
+
+void ThreatListDescriptor::Swap(ThreatListDescriptor* other) {
+  if (other != this) {
+    std::swap(threat_type_, other->threat_type_);
+    std::swap(platform_type_, other->platform_type_);
+    std::swap(threat_entry_type_, other->threat_entry_type_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ThreatListDescriptor::GetTypeName() const {
+  return "mozilla.safebrowsing.ThreatListDescriptor";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ListThreatListsResponse::kThreatListsFieldNumber;
+#endif  // !_MSC_VER
+
+ListThreatListsResponse::ListThreatListsResponse()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.ListThreatListsResponse)
+}
+
+void ListThreatListsResponse::InitAsDefaultInstance() {
+}
+
+ListThreatListsResponse::ListThreatListsResponse(const ListThreatListsResponse& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.ListThreatListsResponse)
+}
+
+void ListThreatListsResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ListThreatListsResponse::~ListThreatListsResponse() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.ListThreatListsResponse)
+  SharedDtor();
+}
+
+void ListThreatListsResponse::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ListThreatListsResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ListThreatListsResponse& ListThreatListsResponse::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ListThreatListsResponse* ListThreatListsResponse::default_instance_ = NULL;
+
+ListThreatListsResponse* ListThreatListsResponse::New() const {
+  return new ListThreatListsResponse;
+}
+
+void ListThreatListsResponse::Clear() {
+  threat_lists_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ListThreatListsResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.ListThreatListsResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_threat_lists:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_threat_lists()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_threat_lists;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.ListThreatListsResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.ListThreatListsResponse)
+  return false;
+#undef DO_
+}
+
+void ListThreatListsResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.ListThreatListsResponse)
+  // repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1;
+  for (int i = 0; i < this->threat_lists_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->threat_lists(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.ListThreatListsResponse)
+}
+
+int ListThreatListsResponse::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1;
+  total_size += 1 * this->threat_lists_size();
+  for (int i = 0; i < this->threat_lists_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->threat_lists(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ListThreatListsResponse::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ListThreatListsResponse*>(&from));
+}
+
+void ListThreatListsResponse::MergeFrom(const ListThreatListsResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  threat_lists_.MergeFrom(from.threat_lists_);
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ListThreatListsResponse::CopyFrom(const ListThreatListsResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ListThreatListsResponse::IsInitialized() const {
+
+  return true;
+}
+
+void ListThreatListsResponse::Swap(ListThreatListsResponse* other) {
+  if (other != this) {
+    threat_lists_.Swap(&other->threat_lists_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ListThreatListsResponse::GetTypeName() const {
+  return "mozilla.safebrowsing.ListThreatListsResponse";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Duration::kSecondsFieldNumber;
+const int Duration::kNanosFieldNumber;
+#endif  // !_MSC_VER
+
+Duration::Duration()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.safebrowsing.Duration)
+}
+
+void Duration::InitAsDefaultInstance() {
+}
+
+Duration::Duration(const Duration& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.safebrowsing.Duration)
+}
+
+void Duration::SharedCtor() {
+  _cached_size_ = 0;
+  seconds_ = GOOGLE_LONGLONG(0);
+  nanos_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Duration::~Duration() {
+  // @@protoc_insertion_point(destructor:mozilla.safebrowsing.Duration)
+  SharedDtor();
+}
+
+void Duration::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void Duration::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const Duration& Duration::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_safebrowsing_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_safebrowsing_2eproto();
+#endif
+  return *default_instance_;
+}
+
+Duration* Duration::default_instance_ = NULL;
+
+Duration* Duration::New() const {
+  return new Duration;
+}
+
+void Duration::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<Duration*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(seconds_, nanos_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool Duration::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:mozilla.safebrowsing.Duration)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional int64 seconds = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &seconds_)));
+          set_has_seconds();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_nanos;
+        break;
+      }
+
+      // optional int32 nanos = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_nanos:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &nanos_)));
+          set_has_nanos();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.safebrowsing.Duration)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.safebrowsing.Duration)
+  return false;
+#undef DO_
+}
+
+void Duration::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.safebrowsing.Duration)
+  // optional int64 seconds = 1;
+  if (has_seconds()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->seconds(), output);
+  }
+
+  // optional int32 nanos = 2;
+  if (has_nanos()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->nanos(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:mozilla.safebrowsing.Duration)
+}
+
+int Duration::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional int64 seconds = 1;
+    if (has_seconds()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->seconds());
+    }
+
+    // optional int32 nanos = 2;
+    if (has_nanos()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->nanos());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Duration::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const Duration*>(&from));
+}
+
+void Duration::MergeFrom(const Duration& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_seconds()) {
+      set_seconds(from.seconds());
+    }
+    if (from.has_nanos()) {
+      set_nanos(from.nanos());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void Duration::CopyFrom(const Duration& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Duration::IsInitialized() const {
+
+  return true;
+}
+
+void Duration::Swap(Duration* other) {
+  if (other != this) {
+    std::swap(seconds_, other->seconds_);
+    std::swap(nanos_, other->nanos_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string Duration::GetTypeName() const {
+  return "mozilla.safebrowsing.Duration";
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace safebrowsing
+}  // namespace mozilla
+
+// @@protoc_insertion_point(global_scope)
diff --git a/toolkit/components/url-classifier/protobuf/safebrowsing.pb.h b/toolkit/components/url-classifier/protobuf/safebrowsing.pb.h
new file mode 100644
index 000000000..3c1b436df
--- /dev/null
+++ b/toolkit/components/url-classifier/protobuf/safebrowsing.pb.h
@@ -0,0 +1,6283 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: safebrowsing.proto
+
+#ifndef PROTOBUF_safebrowsing_2eproto__INCLUDED
+#define PROTOBUF_safebrowsing_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+// @@protoc_insertion_point(includes)
+
+namespace mozilla {
+namespace safebrowsing {
+
+// Internal implementation detail -- do not call these.
+void  protobuf_AddDesc_safebrowsing_2eproto();
+void protobuf_AssignDesc_safebrowsing_2eproto();
+void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+class ThreatInfo;
+class ThreatMatch;
+class FindThreatMatchesRequest;
+class FindThreatMatchesResponse;
+class FetchThreatListUpdatesRequest;
+class FetchThreatListUpdatesRequest_ListUpdateRequest;
+class FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints;
+class FetchThreatListUpdatesResponse;
+class FetchThreatListUpdatesResponse_ListUpdateResponse;
+class FindFullHashesRequest;
+class FindFullHashesResponse;
+class ThreatHit;
+class ThreatHit_ThreatSource;
+class ClientInfo;
+class Checksum;
+class ThreatEntry;
+class ThreatEntrySet;
+class RawIndices;
+class RawHashes;
+class RiceDeltaEncoding;
+class ThreatEntryMetadata;
+class ThreatEntryMetadata_MetadataEntry;
+class ThreatListDescriptor;
+class ListThreatListsResponse;
+class Duration;
+
+enum FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType {
+  FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_RESPONSE_TYPE_UNSPECIFIED = 0,
+  FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_PARTIAL_UPDATE = 1,
+  FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_FULL_UPDATE = 2
+};
+bool FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(int value);
+const FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MIN = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_RESPONSE_TYPE_UNSPECIFIED;
+const FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MAX = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_FULL_UPDATE;
+const int FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_ARRAYSIZE = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MAX + 1;
+
+enum ThreatHit_ThreatSourceType {
+  ThreatHit_ThreatSourceType_THREAT_SOURCE_TYPE_UNSPECIFIED = 0,
+  ThreatHit_ThreatSourceType_MATCHING_URL = 1,
+  ThreatHit_ThreatSourceType_TAB_URL = 2,
+  ThreatHit_ThreatSourceType_TAB_REDIRECT = 3
+};
+bool ThreatHit_ThreatSourceType_IsValid(int value);
+const ThreatHit_ThreatSourceType ThreatHit_ThreatSourceType_ThreatSourceType_MIN = ThreatHit_ThreatSourceType_THREAT_SOURCE_TYPE_UNSPECIFIED;
+const ThreatHit_ThreatSourceType ThreatHit_ThreatSourceType_ThreatSourceType_MAX = ThreatHit_ThreatSourceType_TAB_REDIRECT;
+const int ThreatHit_ThreatSourceType_ThreatSourceType_ARRAYSIZE = ThreatHit_ThreatSourceType_ThreatSourceType_MAX + 1;
+
+enum ThreatType {
+  THREAT_TYPE_UNSPECIFIED = 0,
+  MALWARE_THREAT = 1,
+  SOCIAL_ENGINEERING_PUBLIC = 2,
+  UNWANTED_SOFTWARE = 3,
+  POTENTIALLY_HARMFUL_APPLICATION = 4,
+  SOCIAL_ENGINEERING = 5,
+  API_ABUSE = 6
+};
+bool ThreatType_IsValid(int value);
+const ThreatType ThreatType_MIN = THREAT_TYPE_UNSPECIFIED;
+const ThreatType ThreatType_MAX = API_ABUSE;
+const int ThreatType_ARRAYSIZE = ThreatType_MAX + 1;
+
+enum PlatformType {
+  PLATFORM_TYPE_UNSPECIFIED = 0,
+  WINDOWS_PLATFORM = 1,
+  LINUX_PLATFORM = 2,
+  ANDROID_PLATFORM = 3,
+  OSX_PLATFORM = 4,
+  IOS_PLATFORM = 5,
+  ANY_PLATFORM = 6,
+  ALL_PLATFORMS = 7,
+  CHROME_PLATFORM = 8
+};
+bool PlatformType_IsValid(int value);
+const PlatformType PlatformType_MIN = PLATFORM_TYPE_UNSPECIFIED;
+const PlatformType PlatformType_MAX = CHROME_PLATFORM;
+const int PlatformType_ARRAYSIZE = PlatformType_MAX + 1;
+
+enum CompressionType {
+  COMPRESSION_TYPE_UNSPECIFIED = 0,
+  RAW = 1,
+  RICE = 2
+};
+bool CompressionType_IsValid(int value);
+const CompressionType CompressionType_MIN = COMPRESSION_TYPE_UNSPECIFIED;
+const CompressionType CompressionType_MAX = RICE;
+const int CompressionType_ARRAYSIZE = CompressionType_MAX + 1;
+
+enum ThreatEntryType {
+  THREAT_ENTRY_TYPE_UNSPECIFIED = 0,
+  URL = 1,
+  EXECUTABLE = 2,
+  IP_RANGE = 3
+};
+bool ThreatEntryType_IsValid(int value);
+const ThreatEntryType ThreatEntryType_MIN = THREAT_ENTRY_TYPE_UNSPECIFIED;
+const ThreatEntryType ThreatEntryType_MAX = IP_RANGE;
+const int ThreatEntryType_ARRAYSIZE = ThreatEntryType_MAX + 1;
+
+// ===================================================================
+
+class ThreatInfo : public ::google::protobuf::MessageLite {
+ public:
+  ThreatInfo();
+  virtual ~ThreatInfo();
+
+  ThreatInfo(const ThreatInfo& from);
+
+  inline ThreatInfo& operator=(const ThreatInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ThreatInfo& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ThreatInfo* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ThreatInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  ThreatInfo* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ThreatInfo& from);
+  void MergeFrom(const ThreatInfo& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .mozilla.safebrowsing.ThreatType threat_types = 1;
+  inline int threat_types_size() const;
+  inline void clear_threat_types();
+  static const int kThreatTypesFieldNumber = 1;
+  inline ::mozilla::safebrowsing::ThreatType threat_types(int index) const;
+  inline void set_threat_types(int index, ::mozilla::safebrowsing::ThreatType value);
+  inline void add_threat_types(::mozilla::safebrowsing::ThreatType value);
+  inline const ::google::protobuf::RepeatedField<int>& threat_types() const;
+  inline ::google::protobuf::RepeatedField<int>* mutable_threat_types();
+
+  // repeated .mozilla.safebrowsing.PlatformType platform_types = 2;
+  inline int platform_types_size() const;
+  inline void clear_platform_types();
+  static const int kPlatformTypesFieldNumber = 2;
+  inline ::mozilla::safebrowsing::PlatformType platform_types(int index) const;
+  inline void set_platform_types(int index, ::mozilla::safebrowsing::PlatformType value);
+  inline void add_platform_types(::mozilla::safebrowsing::PlatformType value);
+  inline const ::google::protobuf::RepeatedField<int>& platform_types() const;
+  inline ::google::protobuf::RepeatedField<int>* mutable_platform_types();
+
+  // repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4;
+  inline int threat_entry_types_size() const;
+  inline void clear_threat_entry_types();
+  static const int kThreatEntryTypesFieldNumber = 4;
+  inline ::mozilla::safebrowsing::ThreatEntryType threat_entry_types(int index) const;
+  inline void set_threat_entry_types(int index, ::mozilla::safebrowsing::ThreatEntryType value);
+  inline void add_threat_entry_types(::mozilla::safebrowsing::ThreatEntryType value);
+  inline const ::google::protobuf::RepeatedField<int>& threat_entry_types() const;
+  inline ::google::protobuf::RepeatedField<int>* mutable_threat_entry_types();
+
+  // repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3;
+  inline int threat_entries_size() const;
+  inline void clear_threat_entries();
+  static const int kThreatEntriesFieldNumber = 3;
+  inline const ::mozilla::safebrowsing::ThreatEntry& threat_entries(int index) const;
+  inline ::mozilla::safebrowsing::ThreatEntry* mutable_threat_entries(int index);
+  inline ::mozilla::safebrowsing::ThreatEntry* add_threat_entries();
+  inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >&
+      threat_entries() const;
+  inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >*
+      mutable_threat_entries();
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatInfo)
+ private:
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedField<int> threat_types_;
+  ::google::protobuf::RepeatedField<int> platform_types_;
+  ::google::protobuf::RepeatedField<int> threat_entry_types_;
+  ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry > threat_entries_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static ThreatInfo* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ThreatMatch : public ::google::protobuf::MessageLite {
+ public:
+  ThreatMatch();
+  virtual ~ThreatMatch();
+
+  ThreatMatch(const ThreatMatch& from);
+
+  inline ThreatMatch& operator=(const ThreatMatch& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ThreatMatch& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ThreatMatch* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ThreatMatch* other);
+
+  // implements Message ----------------------------------------------
+
+  ThreatMatch* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ThreatMatch& from);
+  void MergeFrom(const ThreatMatch& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+  inline bool has_threat_type() const;
+  inline void clear_threat_type();
+  static const int kThreatTypeFieldNumber = 1;
+  inline ::mozilla::safebrowsing::ThreatType threat_type() const;
+  inline void set_threat_type(::mozilla::safebrowsing::ThreatType value);
+
+  // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+  inline bool has_platform_type() const;
+  inline void clear_platform_type();
+  static const int kPlatformTypeFieldNumber = 2;
+  inline ::mozilla::safebrowsing::PlatformType platform_type() const;
+  inline void set_platform_type(::mozilla::safebrowsing::PlatformType value);
+
+  // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6;
+  inline bool has_threat_entry_type() const;
+  inline void clear_threat_entry_type();
+  static const int kThreatEntryTypeFieldNumber = 6;
+  inline ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const;
+  inline void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
+
+  // optional .mozilla.safebrowsing.ThreatEntry threat = 3;
+  inline bool has_threat() const;
+  inline void clear_threat();
+  static const int kThreatFieldNumber = 3;
+  inline const ::mozilla::safebrowsing::ThreatEntry& threat() const;
+  inline ::mozilla::safebrowsing::ThreatEntry* mutable_threat();
+  inline ::mozilla::safebrowsing::ThreatEntry* release_threat();
+  inline void set_allocated_threat(::mozilla::safebrowsing::ThreatEntry* threat);
+
+  // optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4;
+  inline bool has_threat_entry_metadata() const;
+  inline void clear_threat_entry_metadata();
+  static const int kThreatEntryMetadataFieldNumber = 4;
+  inline const ::mozilla::safebrowsing::ThreatEntryMetadata& threat_entry_metadata() const;
+  inline ::mozilla::safebrowsing::ThreatEntryMetadata* mutable_threat_entry_metadata();
+  inline ::mozilla::safebrowsing::ThreatEntryMetadata* release_threat_entry_metadata();
+  inline void set_allocated_threat_entry_metadata(::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata);
+
+  // optional .mozilla.safebrowsing.Duration cache_duration = 5;
+  inline bool has_cache_duration() const;
+  inline void clear_cache_duration();
+  static const int kCacheDurationFieldNumber = 5;
+  inline const ::mozilla::safebrowsing::Duration& cache_duration() const;
+  inline ::mozilla::safebrowsing::Duration* mutable_cache_duration();
+  inline ::mozilla::safebrowsing::Duration* release_cache_duration();
+  inline void set_allocated_cache_duration(::mozilla::safebrowsing::Duration* cache_duration);
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatMatch)
+ private:
+  inline void set_has_threat_type();
+  inline void clear_has_threat_type();
+  inline void set_has_platform_type();
+  inline void clear_has_platform_type();
+  inline void set_has_threat_entry_type();
+  inline void clear_has_threat_entry_type();
+  inline void set_has_threat();
+  inline void clear_has_threat();
+  inline void set_has_threat_entry_metadata();
+  inline void clear_has_threat_entry_metadata();
+  inline void set_has_cache_duration();
+  inline void clear_has_cache_duration();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  int threat_type_;
+  int platform_type_;
+  ::mozilla::safebrowsing::ThreatEntry* threat_;
+  ::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata_;
+  ::mozilla::safebrowsing::Duration* cache_duration_;
+  int threat_entry_type_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static ThreatMatch* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class FindThreatMatchesRequest : public ::google::protobuf::MessageLite {
+ public:
+  FindThreatMatchesRequest();
+  virtual ~FindThreatMatchesRequest();
+
+  FindThreatMatchesRequest(const FindThreatMatchesRequest& from);
+
+  inline FindThreatMatchesRequest& operator=(const FindThreatMatchesRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const FindThreatMatchesRequest& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const FindThreatMatchesRequest* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(FindThreatMatchesRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  FindThreatMatchesRequest* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const FindThreatMatchesRequest& from);
+  void MergeFrom(const FindThreatMatchesRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .mozilla.safebrowsing.ClientInfo client = 1;
+  inline bool has_client() const;
+  inline void clear_client();
+  static const int kClientFieldNumber = 1;
+  inline const ::mozilla::safebrowsing::ClientInfo& client() const;
+  inline ::mozilla::safebrowsing::ClientInfo* mutable_client();
+  inline ::mozilla::safebrowsing::ClientInfo* release_client();
+  inline void set_allocated_client(::mozilla::safebrowsing::ClientInfo* client);
+
+  // optional .mozilla.safebrowsing.ThreatInfo threat_info = 2;
+  inline bool has_threat_info() const;
+  inline void clear_threat_info();
+  static const int kThreatInfoFieldNumber = 2;
+  inline const ::mozilla::safebrowsing::ThreatInfo& threat_info() const;
+  inline ::mozilla::safebrowsing::ThreatInfo* mutable_threat_info();
+  inline ::mozilla::safebrowsing::ThreatInfo* release_threat_info();
+  inline void set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info);
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindThreatMatchesRequest)
+ private:
+  inline void set_has_client();
+  inline void clear_has_client();
+  inline void set_has_threat_info();
+  inline void clear_has_threat_info();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::mozilla::safebrowsing::ClientInfo* client_;
+  ::mozilla::safebrowsing::ThreatInfo* threat_info_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static FindThreatMatchesRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class FindThreatMatchesResponse : public ::google::protobuf::MessageLite {
+ public:
+  FindThreatMatchesResponse();
+  virtual ~FindThreatMatchesResponse();
+
+  FindThreatMatchesResponse(const FindThreatMatchesResponse& from);
+
+  inline FindThreatMatchesResponse& operator=(const FindThreatMatchesResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const FindThreatMatchesResponse& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const FindThreatMatchesResponse* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(FindThreatMatchesResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  FindThreatMatchesResponse* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const FindThreatMatchesResponse& from);
+  void MergeFrom(const FindThreatMatchesResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
+  inline int matches_size() const;
+  inline void clear_matches();
+  static const int kMatchesFieldNumber = 1;
+  inline const ::mozilla::safebrowsing::ThreatMatch& matches(int index) const;
+  inline ::mozilla::safebrowsing::ThreatMatch* mutable_matches(int index);
+  inline ::mozilla::safebrowsing::ThreatMatch* add_matches();
+  inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >&
+      matches() const;
+  inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >*
+      mutable_matches();
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindThreatMatchesResponse)
+ private:
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch > matches_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static FindThreatMatchesResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints : public ::google::protobuf::MessageLite {
+ public:
+  FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints();
+  virtual ~FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints();
+
+  FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from);
+
+  inline FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& operator=(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* other);
+
+  // implements Message ----------------------------------------------
+
+  FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from);
+  void MergeFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional int32 max_update_entries = 1;
+  inline bool has_max_update_entries() const;
+  inline void clear_max_update_entries();
+  static const int kMaxUpdateEntriesFieldNumber = 1;
+  inline ::google::protobuf::int32 max_update_entries() const;
+  inline void set_max_update_entries(::google::protobuf::int32 value);
+
+  // optional int32 max_database_entries = 2;
+  inline bool has_max_database_entries() const;
+  inline void clear_max_database_entries();
+  static const int kMaxDatabaseEntriesFieldNumber = 2;
+  inline ::google::protobuf::int32 max_database_entries() const;
+  inline void set_max_database_entries(::google::protobuf::int32 value);
+
+  // optional string region = 3;
+  inline bool has_region() const;
+  inline void clear_region();
+  static const int kRegionFieldNumber = 3;
+  inline const ::std::string& region() const;
+  inline void set_region(const ::std::string& value);
+  inline void set_region(const char* value);
+  inline void set_region(const char* value, size_t size);
+  inline ::std::string* mutable_region();
+  inline ::std::string* release_region();
+  inline void set_allocated_region(::std::string* region);
+
+  // repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4;
+  inline int supported_compressions_size() const;
+  inline void clear_supported_compressions();
+  static const int kSupportedCompressionsFieldNumber = 4;
+  inline ::mozilla::safebrowsing::CompressionType supported_compressions(int index) const;
+  inline void set_supported_compressions(int index, ::mozilla::safebrowsing::CompressionType value);
+  inline void add_supported_compressions(::mozilla::safebrowsing::CompressionType value);
+  inline const ::google::protobuf::RepeatedField<int>& supported_compressions() const;
+  inline ::google::protobuf::RepeatedField<int>* mutable_supported_compressions();
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints)
+ private:
+  inline void set_has_max_update_entries();
+  inline void clear_has_max_update_entries();
+  inline void set_has_max_database_entries();
+  inline void clear_has_max_database_entries();
+  inline void set_has_region();
+  inline void clear_has_region();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::int32 max_update_entries_;
+  ::google::protobuf::int32 max_database_entries_;
+  ::std::string* region_;
+  ::google::protobuf::RepeatedField<int> supported_compressions_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class FetchThreatListUpdatesRequest_ListUpdateRequest : public ::google::protobuf::MessageLite {
+ public:
+  FetchThreatListUpdatesRequest_ListUpdateRequest();
+  virtual ~FetchThreatListUpdatesRequest_ListUpdateRequest();
+
+  FetchThreatListUpdatesRequest_ListUpdateRequest(const FetchThreatListUpdatesRequest_ListUpdateRequest& from);
+
+  inline FetchThreatListUpdatesRequest_ListUpdateRequest& operator=(const FetchThreatListUpdatesRequest_ListUpdateRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const FetchThreatListUpdatesRequest_ListUpdateRequest& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const FetchThreatListUpdatesRequest_ListUpdateRequest* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(FetchThreatListUpdatesRequest_ListUpdateRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  FetchThreatListUpdatesRequest_ListUpdateRequest* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest& from);
+  void MergeFrom(const FetchThreatListUpdatesRequest_ListUpdateRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints Constraints;
+
+  // accessors -------------------------------------------------------
+
+  // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+  inline bool has_threat_type() const;
+  inline void clear_threat_type();
+  static const int kThreatTypeFieldNumber = 1;
+  inline ::mozilla::safebrowsing::ThreatType threat_type() const;
+  inline void set_threat_type(::mozilla::safebrowsing::ThreatType value);
+
+  // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+  inline bool has_platform_type() const;
+  inline void clear_platform_type();
+  static const int kPlatformTypeFieldNumber = 2;
+  inline ::mozilla::safebrowsing::PlatformType platform_type() const;
+  inline void set_platform_type(::mozilla::safebrowsing::PlatformType value);
+
+  // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5;
+  inline bool has_threat_entry_type() const;
+  inline void clear_threat_entry_type();
+  static const int kThreatEntryTypeFieldNumber = 5;
+  inline ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const;
+  inline void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
+
+  // optional bytes state = 3;
+  inline bool has_state() const;
+  inline void clear_state();
+  static const int kStateFieldNumber = 3;
+  inline const ::std::string& state() const;
+  inline void set_state(const ::std::string& value);
+  inline void set_state(const char* value);
+  inline void set_state(const void* value, size_t size);
+  inline ::std::string* mutable_state();
+  inline ::std::string* release_state();
+  inline void set_allocated_state(::std::string* state);
+
+  // optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4;
+  inline bool has_constraints() const;
+  inline void clear_constraints();
+  static const int kConstraintsFieldNumber = 4;
+  inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& constraints() const;
+  inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* mutable_constraints();
+  inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* release_constraints();
+  inline void set_allocated_constraints(::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints);
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest)
+ private:
+  inline void set_has_threat_type();
+  inline void clear_has_threat_type();
+  inline void set_has_platform_type();
+  inline void clear_has_platform_type();
+  inline void set_has_threat_entry_type();
+  inline void clear_has_threat_entry_type();
+  inline void set_has_state();
+  inline void clear_has_state();
+  inline void set_has_constraints();
+  inline void clear_has_constraints();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  int threat_type_;
+  int platform_type_;
+  ::std::string* state_;
+  ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints_;
+  int threat_entry_type_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static FetchThreatListUpdatesRequest_ListUpdateRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class FetchThreatListUpdatesRequest : public ::google::protobuf::MessageLite {
+ public:
+  FetchThreatListUpdatesRequest();
+  virtual ~FetchThreatListUpdatesRequest();
+
+  FetchThreatListUpdatesRequest(const FetchThreatListUpdatesRequest& from);
+
+  inline FetchThreatListUpdatesRequest& operator=(const FetchThreatListUpdatesRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const FetchThreatListUpdatesRequest& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const FetchThreatListUpdatesRequest* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(FetchThreatListUpdatesRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  FetchThreatListUpdatesRequest* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const FetchThreatListUpdatesRequest& from);
+  void MergeFrom(const FetchThreatListUpdatesRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef FetchThreatListUpdatesRequest_ListUpdateRequest ListUpdateRequest;
+
+  // accessors -------------------------------------------------------
+
+  // optional .mozilla.safebrowsing.ClientInfo client = 1;
+  inline bool has_client() const;
+  inline void clear_client();
+  static const int kClientFieldNumber = 1;
+  inline const ::mozilla::safebrowsing::ClientInfo& client() const;
+  inline ::mozilla::safebrowsing::ClientInfo* mutable_client();
+  inline ::mozilla::safebrowsing::ClientInfo* release_client();
+  inline void set_allocated_client(::mozilla::safebrowsing::ClientInfo* client);
+
+  // repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3;
+  inline int list_update_requests_size() const;
+  inline void clear_list_update_requests();
+  static const int kListUpdateRequestsFieldNumber = 3;
+  inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest& list_update_requests(int index) const;
+  inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* mutable_list_update_requests(int index);
+  inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* add_list_update_requests();
+  inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >&
+      list_update_requests() const;
+  inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >*
+      mutable_list_update_requests();
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesRequest)
+ private:
+  inline void set_has_client();
+  inline void clear_has_client();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::mozilla::safebrowsing::ClientInfo* client_;
+  ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest > list_update_requests_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static FetchThreatListUpdatesRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class FetchThreatListUpdatesResponse_ListUpdateResponse : public ::google::protobuf::MessageLite {
+ public:
+  FetchThreatListUpdatesResponse_ListUpdateResponse();
+  virtual ~FetchThreatListUpdatesResponse_ListUpdateResponse();
+
+  FetchThreatListUpdatesResponse_ListUpdateResponse(const FetchThreatListUpdatesResponse_ListUpdateResponse& from);
+
+  inline FetchThreatListUpdatesResponse_ListUpdateResponse& operator=(const FetchThreatListUpdatesResponse_ListUpdateResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const FetchThreatListUpdatesResponse_ListUpdateResponse& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const FetchThreatListUpdatesResponse_ListUpdateResponse* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(FetchThreatListUpdatesResponse_ListUpdateResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  FetchThreatListUpdatesResponse_ListUpdateResponse* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const FetchThreatListUpdatesResponse_ListUpdateResponse& from);
+  void MergeFrom(const FetchThreatListUpdatesResponse_ListUpdateResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType ResponseType;
+  static const ResponseType RESPONSE_TYPE_UNSPECIFIED = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_RESPONSE_TYPE_UNSPECIFIED;
+  static const ResponseType PARTIAL_UPDATE = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_PARTIAL_UPDATE;
+  static const ResponseType FULL_UPDATE = FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_FULL_UPDATE;
+  static inline bool ResponseType_IsValid(int value) {
+    return FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(value);
+  }
+  static const ResponseType ResponseType_MIN =
+    FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MIN;
+  static const ResponseType ResponseType_MAX =
+    FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_MAX;
+  static const int ResponseType_ARRAYSIZE =
+    FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_ResponseType_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+  inline bool has_threat_type() const;
+  inline void clear_threat_type();
+  static const int kThreatTypeFieldNumber = 1;
+  inline ::mozilla::safebrowsing::ThreatType threat_type() const;
+  inline void set_threat_type(::mozilla::safebrowsing::ThreatType value);
+
+  // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2;
+  inline bool has_threat_entry_type() const;
+  inline void clear_threat_entry_type();
+  static const int kThreatEntryTypeFieldNumber = 2;
+  inline ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const;
+  inline void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
+
+  // optional .mozilla.safebrowsing.PlatformType platform_type = 3;
+  inline bool has_platform_type() const;
+  inline void clear_platform_type();
+  static const int kPlatformTypeFieldNumber = 3;
+  inline ::mozilla::safebrowsing::PlatformType platform_type() const;
+  inline void set_platform_type(::mozilla::safebrowsing::PlatformType value);
+
+  // optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4;
+  inline bool has_response_type() const;
+  inline void clear_response_type();
+  static const int kResponseTypeFieldNumber = 4;
+  inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType response_type() const;
+  inline void set_response_type(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value);
+
+  // repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5;
+  inline int additions_size() const;
+  inline void clear_additions();
+  static const int kAdditionsFieldNumber = 5;
+  inline const ::mozilla::safebrowsing::ThreatEntrySet& additions(int index) const;
+  inline ::mozilla::safebrowsing::ThreatEntrySet* mutable_additions(int index);
+  inline ::mozilla::safebrowsing::ThreatEntrySet* add_additions();
+  inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >&
+      additions() const;
+  inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >*
+      mutable_additions();
+
+  // repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6;
+  inline int removals_size() const;
+  inline void clear_removals();
+  static const int kRemovalsFieldNumber = 6;
+  inline const ::mozilla::safebrowsing::ThreatEntrySet& removals(int index) const;
+  inline ::mozilla::safebrowsing::ThreatEntrySet* mutable_removals(int index);
+  inline ::mozilla::safebrowsing::ThreatEntrySet* add_removals();
+  inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >&
+      removals() const;
+  inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >*
+      mutable_removals();
+
+  // optional bytes new_client_state = 7;
+  inline bool has_new_client_state() const;
+  inline void clear_new_client_state();
+  static const int kNewClientStateFieldNumber = 7;
+  inline const ::std::string& new_client_state() const;
+  inline void set_new_client_state(const ::std::string& value);
+  inline void set_new_client_state(const char* value);
+  inline void set_new_client_state(const void* value, size_t size);
+  inline ::std::string* mutable_new_client_state();
+  inline ::std::string* release_new_client_state();
+  inline void set_allocated_new_client_state(::std::string* new_client_state);
+
+  // optional .mozilla.safebrowsing.Checksum checksum = 8;
+  inline bool has_checksum() const;
+  inline void clear_checksum();
+  static const int kChecksumFieldNumber = 8;
+  inline const ::mozilla::safebrowsing::Checksum& checksum() const;
+  inline ::mozilla::safebrowsing::Checksum* mutable_checksum();
+  inline ::mozilla::safebrowsing::Checksum* release_checksum();
+  inline void set_allocated_checksum(::mozilla::safebrowsing::Checksum* checksum);
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse)
+ private:
+  inline void set_has_threat_type();
+  inline void clear_has_threat_type();
+  inline void set_has_threat_entry_type();
+  inline void clear_has_threat_entry_type();
+  inline void set_has_platform_type();
+  inline void clear_has_platform_type();
+  inline void set_has_response_type();
+  inline void clear_has_response_type();
+  inline void set_has_new_client_state();
+  inline void clear_has_new_client_state();
+  inline void set_has_checksum();
+  inline void clear_has_checksum();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  int threat_type_;
+  int threat_entry_type_;
+  int platform_type_;
+  int response_type_;
+  ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet > additions_;
+  ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet > removals_;
+  ::std::string* new_client_state_;
+  ::mozilla::safebrowsing::Checksum* checksum_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static FetchThreatListUpdatesResponse_ListUpdateResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class FetchThreatListUpdatesResponse : public ::google::protobuf::MessageLite {
+ public:
+  FetchThreatListUpdatesResponse();
+  virtual ~FetchThreatListUpdatesResponse();
+
+  FetchThreatListUpdatesResponse(const FetchThreatListUpdatesResponse& from);
+
+  inline FetchThreatListUpdatesResponse& operator=(const FetchThreatListUpdatesResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const FetchThreatListUpdatesResponse& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const FetchThreatListUpdatesResponse* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(FetchThreatListUpdatesResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  FetchThreatListUpdatesResponse* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const FetchThreatListUpdatesResponse& from);
+  void MergeFrom(const FetchThreatListUpdatesResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef FetchThreatListUpdatesResponse_ListUpdateResponse ListUpdateResponse;
+
+  // accessors -------------------------------------------------------
+
+  // repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1;
+  inline int list_update_responses_size() const;
+  inline void clear_list_update_responses();
+  static const int kListUpdateResponsesFieldNumber = 1;
+  inline const ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse& list_update_responses(int index) const;
+  inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* mutable_list_update_responses(int index);
+  inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* add_list_update_responses();
+  inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >&
+      list_update_responses() const;
+  inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >*
+      mutable_list_update_responses();
+
+  // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
+  inline bool has_minimum_wait_duration() const;
+  inline void clear_minimum_wait_duration();
+  static const int kMinimumWaitDurationFieldNumber = 2;
+  inline const ::mozilla::safebrowsing::Duration& minimum_wait_duration() const;
+  inline ::mozilla::safebrowsing::Duration* mutable_minimum_wait_duration();
+  inline ::mozilla::safebrowsing::Duration* release_minimum_wait_duration();
+  inline void set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration* minimum_wait_duration);
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FetchThreatListUpdatesResponse)
+ private:
+  inline void set_has_minimum_wait_duration();
+  inline void clear_has_minimum_wait_duration();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse > list_update_responses_;
+  ::mozilla::safebrowsing::Duration* minimum_wait_duration_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static FetchThreatListUpdatesResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class FindFullHashesRequest : public ::google::protobuf::MessageLite {
+ public:
+  FindFullHashesRequest();
+  virtual ~FindFullHashesRequest();
+
+  FindFullHashesRequest(const FindFullHashesRequest& from);
+
+  inline FindFullHashesRequest& operator=(const FindFullHashesRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const FindFullHashesRequest& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const FindFullHashesRequest* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(FindFullHashesRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  FindFullHashesRequest* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const FindFullHashesRequest& from);
+  void MergeFrom(const FindFullHashesRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .mozilla.safebrowsing.ClientInfo client = 1;
+  inline bool has_client() const;
+  inline void clear_client();
+  static const int kClientFieldNumber = 1;
+  inline const ::mozilla::safebrowsing::ClientInfo& client() const;
+  inline ::mozilla::safebrowsing::ClientInfo* mutable_client();
+  inline ::mozilla::safebrowsing::ClientInfo* release_client();
+  inline void set_allocated_client(::mozilla::safebrowsing::ClientInfo* client);
+
+  // repeated bytes client_states = 2;
+  inline int client_states_size() const;
+  inline void clear_client_states();
+  static const int kClientStatesFieldNumber = 2;
+  inline const ::std::string& client_states(int index) const;
+  inline ::std::string* mutable_client_states(int index);
+  inline void set_client_states(int index, const ::std::string& value);
+  inline void set_client_states(int index, const char* value);
+  inline void set_client_states(int index, const void* value, size_t size);
+  inline ::std::string* add_client_states();
+  inline void add_client_states(const ::std::string& value);
+  inline void add_client_states(const char* value);
+  inline void add_client_states(const void* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& client_states() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_client_states();
+
+  // optional .mozilla.safebrowsing.ThreatInfo threat_info = 3;
+  inline bool has_threat_info() const;
+  inline void clear_threat_info();
+  static const int kThreatInfoFieldNumber = 3;
+  inline const ::mozilla::safebrowsing::ThreatInfo& threat_info() const;
+  inline ::mozilla::safebrowsing::ThreatInfo* mutable_threat_info();
+  inline ::mozilla::safebrowsing::ThreatInfo* release_threat_info();
+  inline void set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info);
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindFullHashesRequest)
+ private:
+  inline void set_has_client();
+  inline void clear_has_client();
+  inline void set_has_threat_info();
+  inline void clear_has_threat_info();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::mozilla::safebrowsing::ClientInfo* client_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> client_states_;
+  ::mozilla::safebrowsing::ThreatInfo* threat_info_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static FindFullHashesRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class FindFullHashesResponse : public ::google::protobuf::MessageLite {
+ public:
+  FindFullHashesResponse();
+  virtual ~FindFullHashesResponse();
+
+  FindFullHashesResponse(const FindFullHashesResponse& from);
+
+  inline FindFullHashesResponse& operator=(const FindFullHashesResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const FindFullHashesResponse& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const FindFullHashesResponse* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(FindFullHashesResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  FindFullHashesResponse* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const FindFullHashesResponse& from);
+  void MergeFrom(const FindFullHashesResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
+  inline int matches_size() const;
+  inline void clear_matches();
+  static const int kMatchesFieldNumber = 1;
+  inline const ::mozilla::safebrowsing::ThreatMatch& matches(int index) const;
+  inline ::mozilla::safebrowsing::ThreatMatch* mutable_matches(int index);
+  inline ::mozilla::safebrowsing::ThreatMatch* add_matches();
+  inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >&
+      matches() const;
+  inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >*
+      mutable_matches();
+
+  // optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
+  inline bool has_minimum_wait_duration() const;
+  inline void clear_minimum_wait_duration();
+  static const int kMinimumWaitDurationFieldNumber = 2;
+  inline const ::mozilla::safebrowsing::Duration& minimum_wait_duration() const;
+  inline ::mozilla::safebrowsing::Duration* mutable_minimum_wait_duration();
+  inline ::mozilla::safebrowsing::Duration* release_minimum_wait_duration();
+  inline void set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration* minimum_wait_duration);
+
+  // optional .mozilla.safebrowsing.Duration negative_cache_duration = 3;
+  inline bool has_negative_cache_duration() const;
+  inline void clear_negative_cache_duration();
+  static const int kNegativeCacheDurationFieldNumber = 3;
+  inline const ::mozilla::safebrowsing::Duration& negative_cache_duration() const;
+  inline ::mozilla::safebrowsing::Duration* mutable_negative_cache_duration();
+  inline ::mozilla::safebrowsing::Duration* release_negative_cache_duration();
+  inline void set_allocated_negative_cache_duration(::mozilla::safebrowsing::Duration* negative_cache_duration);
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.FindFullHashesResponse)
+ private:
+  inline void set_has_minimum_wait_duration();
+  inline void clear_has_minimum_wait_duration();
+  inline void set_has_negative_cache_duration();
+  inline void clear_has_negative_cache_duration();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch > matches_;
+  ::mozilla::safebrowsing::Duration* minimum_wait_duration_;
+  ::mozilla::safebrowsing::Duration* negative_cache_duration_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static FindFullHashesResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ThreatHit_ThreatSource : public ::google::protobuf::MessageLite {
+ public:
+  ThreatHit_ThreatSource();
+  virtual ~ThreatHit_ThreatSource();
+
+  ThreatHit_ThreatSource(const ThreatHit_ThreatSource& from);
+
+  inline ThreatHit_ThreatSource& operator=(const ThreatHit_ThreatSource& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ThreatHit_ThreatSource& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ThreatHit_ThreatSource* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ThreatHit_ThreatSource* other);
+
+  // implements Message ----------------------------------------------
+
+  ThreatHit_ThreatSource* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ThreatHit_ThreatSource& from);
+  void MergeFrom(const ThreatHit_ThreatSource& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string url = 1;
+  inline bool has_url() const;
+  inline void clear_url();
+  static const int kUrlFieldNumber = 1;
+  inline const ::std::string& url() const;
+  inline void set_url(const ::std::string& value);
+  inline void set_url(const char* value);
+  inline void set_url(const char* value, size_t size);
+  inline ::std::string* mutable_url();
+  inline ::std::string* release_url();
+  inline void set_allocated_url(::std::string* url);
+
+  // optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 2;
+  inline ::mozilla::safebrowsing::ThreatHit_ThreatSourceType type() const;
+  inline void set_type(::mozilla::safebrowsing::ThreatHit_ThreatSourceType value);
+
+  // optional string remote_ip = 3;
+  inline bool has_remote_ip() const;
+  inline void clear_remote_ip();
+  static const int kRemoteIpFieldNumber = 3;
+  inline const ::std::string& remote_ip() const;
+  inline void set_remote_ip(const ::std::string& value);
+  inline void set_remote_ip(const char* value);
+  inline void set_remote_ip(const char* value, size_t size);
+  inline ::std::string* mutable_remote_ip();
+  inline ::std::string* release_remote_ip();
+  inline void set_allocated_remote_ip(::std::string* remote_ip);
+
+  // optional string referrer = 4;
+  inline bool has_referrer() const;
+  inline void clear_referrer();
+  static const int kReferrerFieldNumber = 4;
+  inline const ::std::string& referrer() const;
+  inline void set_referrer(const ::std::string& value);
+  inline void set_referrer(const char* value);
+  inline void set_referrer(const char* value, size_t size);
+  inline ::std::string* mutable_referrer();
+  inline ::std::string* release_referrer();
+  inline void set_allocated_referrer(::std::string* referrer);
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatHit.ThreatSource)
+ private:
+  inline void set_has_url();
+  inline void clear_has_url();
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_remote_ip();
+  inline void clear_has_remote_ip();
+  inline void set_has_referrer();
+  inline void clear_has_referrer();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* url_;
+  ::std::string* remote_ip_;
+  ::std::string* referrer_;
+  int type_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static ThreatHit_ThreatSource* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ThreatHit : public ::google::protobuf::MessageLite {
+ public:
+  ThreatHit();
+  virtual ~ThreatHit();
+
+  ThreatHit(const ThreatHit& from);
+
+  inline ThreatHit& operator=(const ThreatHit& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ThreatHit& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ThreatHit* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ThreatHit* other);
+
+  // implements Message ----------------------------------------------
+
+  ThreatHit* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ThreatHit& from);
+  void MergeFrom(const ThreatHit& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ThreatHit_ThreatSource ThreatSource;
+
+  typedef ThreatHit_ThreatSourceType ThreatSourceType;
+  static const ThreatSourceType THREAT_SOURCE_TYPE_UNSPECIFIED = ThreatHit_ThreatSourceType_THREAT_SOURCE_TYPE_UNSPECIFIED;
+  static const ThreatSourceType MATCHING_URL = ThreatHit_ThreatSourceType_MATCHING_URL;
+  static const ThreatSourceType TAB_URL = ThreatHit_ThreatSourceType_TAB_URL;
+  static const ThreatSourceType TAB_REDIRECT = ThreatHit_ThreatSourceType_TAB_REDIRECT;
+  static inline bool ThreatSourceType_IsValid(int value) {
+    return ThreatHit_ThreatSourceType_IsValid(value);
+  }
+  static const ThreatSourceType ThreatSourceType_MIN =
+    ThreatHit_ThreatSourceType_ThreatSourceType_MIN;
+  static const ThreatSourceType ThreatSourceType_MAX =
+    ThreatHit_ThreatSourceType_ThreatSourceType_MAX;
+  static const int ThreatSourceType_ARRAYSIZE =
+    ThreatHit_ThreatSourceType_ThreatSourceType_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+  inline bool has_threat_type() const;
+  inline void clear_threat_type();
+  static const int kThreatTypeFieldNumber = 1;
+  inline ::mozilla::safebrowsing::ThreatType threat_type() const;
+  inline void set_threat_type(::mozilla::safebrowsing::ThreatType value);
+
+  // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+  inline bool has_platform_type() const;
+  inline void clear_platform_type();
+  static const int kPlatformTypeFieldNumber = 2;
+  inline ::mozilla::safebrowsing::PlatformType platform_type() const;
+  inline void set_platform_type(::mozilla::safebrowsing::PlatformType value);
+
+  // optional .mozilla.safebrowsing.ThreatEntry entry = 3;
+  inline bool has_entry() const;
+  inline void clear_entry();
+  static const int kEntryFieldNumber = 3;
+  inline const ::mozilla::safebrowsing::ThreatEntry& entry() const;
+  inline ::mozilla::safebrowsing::ThreatEntry* mutable_entry();
+  inline ::mozilla::safebrowsing::ThreatEntry* release_entry();
+  inline void set_allocated_entry(::mozilla::safebrowsing::ThreatEntry* entry);
+
+  // repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4;
+  inline int resources_size() const;
+  inline void clear_resources();
+  static const int kResourcesFieldNumber = 4;
+  inline const ::mozilla::safebrowsing::ThreatHit_ThreatSource& resources(int index) const;
+  inline ::mozilla::safebrowsing::ThreatHit_ThreatSource* mutable_resources(int index);
+  inline ::mozilla::safebrowsing::ThreatHit_ThreatSource* add_resources();
+  inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >&
+      resources() const;
+  inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >*
+      mutable_resources();
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatHit)
+ private:
+  inline void set_has_threat_type();
+  inline void clear_has_threat_type();
+  inline void set_has_platform_type();
+  inline void clear_has_platform_type();
+  inline void set_has_entry();
+  inline void clear_has_entry();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  int threat_type_;
+  int platform_type_;
+  ::mozilla::safebrowsing::ThreatEntry* entry_;
+  ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource > resources_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static ThreatHit* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientInfo : public ::google::protobuf::MessageLite {
+ public:
+  ClientInfo();
+  virtual ~ClientInfo();
+
+  ClientInfo(const ClientInfo& from);
+
+  inline ClientInfo& operator=(const ClientInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientInfo& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientInfo* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientInfo* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientInfo& from);
+  void MergeFrom(const ClientInfo& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string client_id = 1;
+  inline bool has_client_id() const;
+  inline void clear_client_id();
+  static const int kClientIdFieldNumber = 1;
+  inline const ::std::string& client_id() const;
+  inline void set_client_id(const ::std::string& value);
+  inline void set_client_id(const char* value);
+  inline void set_client_id(const char* value, size_t size);
+  inline ::std::string* mutable_client_id();
+  inline ::std::string* release_client_id();
+  inline void set_allocated_client_id(::std::string* client_id);
+
+  // optional string client_version = 2;
+  inline bool has_client_version() const;
+  inline void clear_client_version();
+  static const int kClientVersionFieldNumber = 2;
+  inline const ::std::string& client_version() const;
+  inline void set_client_version(const ::std::string& value);
+  inline void set_client_version(const char* value);
+  inline void set_client_version(const char* value, size_t size);
+  inline ::std::string* mutable_client_version();
+  inline ::std::string* release_client_version();
+  inline void set_allocated_client_version(::std::string* client_version);
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ClientInfo)
+ private:
+  inline void set_has_client_id();
+  inline void clear_has_client_id();
+  inline void set_has_client_version();
+  inline void clear_has_client_version();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* client_id_;
+  ::std::string* client_version_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientInfo* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class Checksum : public ::google::protobuf::MessageLite {
+ public:
+  Checksum();
+  virtual ~Checksum();
+
+  Checksum(const Checksum& from);
+
+  inline Checksum& operator=(const Checksum& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const Checksum& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const Checksum* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(Checksum* other);
+
+  // implements Message ----------------------------------------------
+
+  Checksum* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const Checksum& from);
+  void MergeFrom(const Checksum& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional bytes sha256 = 1;
+  inline bool has_sha256() const;
+  inline void clear_sha256();
+  static const int kSha256FieldNumber = 1;
+  inline const ::std::string& sha256() const;
+  inline void set_sha256(const ::std::string& value);
+  inline void set_sha256(const char* value);
+  inline void set_sha256(const void* value, size_t size);
+  inline ::std::string* mutable_sha256();
+  inline ::std::string* release_sha256();
+  inline void set_allocated_sha256(::std::string* sha256);
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.Checksum)
+ private:
+  inline void set_has_sha256();
+  inline void clear_has_sha256();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* sha256_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static Checksum* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ThreatEntry : public ::google::protobuf::MessageLite {
+ public:
+  ThreatEntry();
+  virtual ~ThreatEntry();
+
+  ThreatEntry(const ThreatEntry& from);
+
+  inline ThreatEntry& operator=(const ThreatEntry& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ThreatEntry& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ThreatEntry* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ThreatEntry* other);
+
+  // implements Message ----------------------------------------------
+
+  ThreatEntry* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ThreatEntry& from);
+  void MergeFrom(const ThreatEntry& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional bytes hash = 1;
+  inline bool has_hash() const;
+  inline void clear_hash();
+  static const int kHashFieldNumber = 1;
+  inline const ::std::string& hash() const;
+  inline void set_hash(const ::std::string& value);
+  inline void set_hash(const char* value);
+  inline void set_hash(const void* value, size_t size);
+  inline ::std::string* mutable_hash();
+  inline ::std::string* release_hash();
+  inline void set_allocated_hash(::std::string* hash);
+
+  // optional string url = 2;
+  inline bool has_url() const;
+  inline void clear_url();
+  static const int kUrlFieldNumber = 2;
+  inline const ::std::string& url() const;
+  inline void set_url(const ::std::string& value);
+  inline void set_url(const char* value);
+  inline void set_url(const char* value, size_t size);
+  inline ::std::string* mutable_url();
+  inline ::std::string* release_url();
+  inline void set_allocated_url(::std::string* url);
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntry)
+ private:
+  inline void set_has_hash();
+  inline void clear_has_hash();
+  inline void set_has_url();
+  inline void clear_has_url();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* hash_;
+  ::std::string* url_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static ThreatEntry* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ThreatEntrySet : public ::google::protobuf::MessageLite {
+ public:
+  ThreatEntrySet();
+  virtual ~ThreatEntrySet();
+
+  ThreatEntrySet(const ThreatEntrySet& from);
+
+  inline ThreatEntrySet& operator=(const ThreatEntrySet& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ThreatEntrySet& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ThreatEntrySet* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ThreatEntrySet* other);
+
+  // implements Message ----------------------------------------------
+
+  ThreatEntrySet* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ThreatEntrySet& from);
+  void MergeFrom(const ThreatEntrySet& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .mozilla.safebrowsing.CompressionType compression_type = 1;
+  inline bool has_compression_type() const;
+  inline void clear_compression_type();
+  static const int kCompressionTypeFieldNumber = 1;
+  inline ::mozilla::safebrowsing::CompressionType compression_type() const;
+  inline void set_compression_type(::mozilla::safebrowsing::CompressionType value);
+
+  // optional .mozilla.safebrowsing.RawHashes raw_hashes = 2;
+  inline bool has_raw_hashes() const;
+  inline void clear_raw_hashes();
+  static const int kRawHashesFieldNumber = 2;
+  inline const ::mozilla::safebrowsing::RawHashes& raw_hashes() const;
+  inline ::mozilla::safebrowsing::RawHashes* mutable_raw_hashes();
+  inline ::mozilla::safebrowsing::RawHashes* release_raw_hashes();
+  inline void set_allocated_raw_hashes(::mozilla::safebrowsing::RawHashes* raw_hashes);
+
+  // optional .mozilla.safebrowsing.RawIndices raw_indices = 3;
+  inline bool has_raw_indices() const;
+  inline void clear_raw_indices();
+  static const int kRawIndicesFieldNumber = 3;
+  inline const ::mozilla::safebrowsing::RawIndices& raw_indices() const;
+  inline ::mozilla::safebrowsing::RawIndices* mutable_raw_indices();
+  inline ::mozilla::safebrowsing::RawIndices* release_raw_indices();
+  inline void set_allocated_raw_indices(::mozilla::safebrowsing::RawIndices* raw_indices);
+
+  // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4;
+  inline bool has_rice_hashes() const;
+  inline void clear_rice_hashes();
+  static const int kRiceHashesFieldNumber = 4;
+  inline const ::mozilla::safebrowsing::RiceDeltaEncoding& rice_hashes() const;
+  inline ::mozilla::safebrowsing::RiceDeltaEncoding* mutable_rice_hashes();
+  inline ::mozilla::safebrowsing::RiceDeltaEncoding* release_rice_hashes();
+  inline void set_allocated_rice_hashes(::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes);
+
+  // optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5;
+  inline bool has_rice_indices() const;
+  inline void clear_rice_indices();
+  static const int kRiceIndicesFieldNumber = 5;
+  inline const ::mozilla::safebrowsing::RiceDeltaEncoding& rice_indices() const;
+  inline ::mozilla::safebrowsing::RiceDeltaEncoding* mutable_rice_indices();
+  inline ::mozilla::safebrowsing::RiceDeltaEncoding* release_rice_indices();
+  inline void set_allocated_rice_indices(::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices);
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntrySet)
+ private:
+  inline void set_has_compression_type();
+  inline void clear_has_compression_type();
+  inline void set_has_raw_hashes();
+  inline void clear_has_raw_hashes();
+  inline void set_has_raw_indices();
+  inline void clear_has_raw_indices();
+  inline void set_has_rice_hashes();
+  inline void clear_has_rice_hashes();
+  inline void set_has_rice_indices();
+  inline void clear_has_rice_indices();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::mozilla::safebrowsing::RawHashes* raw_hashes_;
+  ::mozilla::safebrowsing::RawIndices* raw_indices_;
+  ::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes_;
+  ::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices_;
+  int compression_type_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static ThreatEntrySet* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class RawIndices : public ::google::protobuf::MessageLite {
+ public:
+  RawIndices();
+  virtual ~RawIndices();
+
+  RawIndices(const RawIndices& from);
+
+  inline RawIndices& operator=(const RawIndices& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const RawIndices& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const RawIndices* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(RawIndices* other);
+
+  // implements Message ----------------------------------------------
+
+  RawIndices* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const RawIndices& from);
+  void MergeFrom(const RawIndices& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated int32 indices = 1;
+  inline int indices_size() const;
+  inline void clear_indices();
+  static const int kIndicesFieldNumber = 1;
+  inline ::google::protobuf::int32 indices(int index) const;
+  inline void set_indices(int index, ::google::protobuf::int32 value);
+  inline void add_indices(::google::protobuf::int32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+      indices() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+      mutable_indices();
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.RawIndices)
+ private:
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > indices_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static RawIndices* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class RawHashes : public ::google::protobuf::MessageLite {
+ public:
+  RawHashes();
+  virtual ~RawHashes();
+
+  RawHashes(const RawHashes& from);
+
+  inline RawHashes& operator=(const RawHashes& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const RawHashes& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const RawHashes* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(RawHashes* other);
+
+  // implements Message ----------------------------------------------
+
+  RawHashes* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const RawHashes& from);
+  void MergeFrom(const RawHashes& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional int32 prefix_size = 1;
+  inline bool has_prefix_size() const;
+  inline void clear_prefix_size();
+  static const int kPrefixSizeFieldNumber = 1;
+  inline ::google::protobuf::int32 prefix_size() const;
+  inline void set_prefix_size(::google::protobuf::int32 value);
+
+  // optional bytes raw_hashes = 2;
+  inline bool has_raw_hashes() const;
+  inline void clear_raw_hashes();
+  static const int kRawHashesFieldNumber = 2;
+  inline const ::std::string& raw_hashes() const;
+  inline void set_raw_hashes(const ::std::string& value);
+  inline void set_raw_hashes(const char* value);
+  inline void set_raw_hashes(const void* value, size_t size);
+  inline ::std::string* mutable_raw_hashes();
+  inline ::std::string* release_raw_hashes();
+  inline void set_allocated_raw_hashes(::std::string* raw_hashes);
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.RawHashes)
+ private:
+  inline void set_has_prefix_size();
+  inline void clear_has_prefix_size();
+  inline void set_has_raw_hashes();
+  inline void clear_has_raw_hashes();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* raw_hashes_;
+  ::google::protobuf::int32 prefix_size_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static RawHashes* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class RiceDeltaEncoding : public ::google::protobuf::MessageLite {
+ public:
+  RiceDeltaEncoding();
+  virtual ~RiceDeltaEncoding();
+
+  RiceDeltaEncoding(const RiceDeltaEncoding& from);
+
+  inline RiceDeltaEncoding& operator=(const RiceDeltaEncoding& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const RiceDeltaEncoding& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const RiceDeltaEncoding* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(RiceDeltaEncoding* other);
+
+  // implements Message ----------------------------------------------
+
+  RiceDeltaEncoding* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const RiceDeltaEncoding& from);
+  void MergeFrom(const RiceDeltaEncoding& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional int64 first_value = 1;
+  inline bool has_first_value() const;
+  inline void clear_first_value();
+  static const int kFirstValueFieldNumber = 1;
+  inline ::google::protobuf::int64 first_value() const;
+  inline void set_first_value(::google::protobuf::int64 value);
+
+  // optional int32 rice_parameter = 2;
+  inline bool has_rice_parameter() const;
+  inline void clear_rice_parameter();
+  static const int kRiceParameterFieldNumber = 2;
+  inline ::google::protobuf::int32 rice_parameter() const;
+  inline void set_rice_parameter(::google::protobuf::int32 value);
+
+  // optional int32 num_entries = 3;
+  inline bool has_num_entries() const;
+  inline void clear_num_entries();
+  static const int kNumEntriesFieldNumber = 3;
+  inline ::google::protobuf::int32 num_entries() const;
+  inline void set_num_entries(::google::protobuf::int32 value);
+
+  // optional bytes encoded_data = 4;
+  inline bool has_encoded_data() const;
+  inline void clear_encoded_data();
+  static const int kEncodedDataFieldNumber = 4;
+  inline const ::std::string& encoded_data() const;
+  inline void set_encoded_data(const ::std::string& value);
+  inline void set_encoded_data(const char* value);
+  inline void set_encoded_data(const void* value, size_t size);
+  inline ::std::string* mutable_encoded_data();
+  inline ::std::string* release_encoded_data();
+  inline void set_allocated_encoded_data(::std::string* encoded_data);
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.RiceDeltaEncoding)
+ private:
+  inline void set_has_first_value();
+  inline void clear_has_first_value();
+  inline void set_has_rice_parameter();
+  inline void clear_has_rice_parameter();
+  inline void set_has_num_entries();
+  inline void clear_has_num_entries();
+  inline void set_has_encoded_data();
+  inline void clear_has_encoded_data();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::int64 first_value_;
+  ::google::protobuf::int32 rice_parameter_;
+  ::google::protobuf::int32 num_entries_;
+  ::std::string* encoded_data_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static RiceDeltaEncoding* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ThreatEntryMetadata_MetadataEntry : public ::google::protobuf::MessageLite {
+ public:
+  ThreatEntryMetadata_MetadataEntry();
+  virtual ~ThreatEntryMetadata_MetadataEntry();
+
+  ThreatEntryMetadata_MetadataEntry(const ThreatEntryMetadata_MetadataEntry& from);
+
+  inline ThreatEntryMetadata_MetadataEntry& operator=(const ThreatEntryMetadata_MetadataEntry& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ThreatEntryMetadata_MetadataEntry& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ThreatEntryMetadata_MetadataEntry* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ThreatEntryMetadata_MetadataEntry* other);
+
+  // implements Message ----------------------------------------------
+
+  ThreatEntryMetadata_MetadataEntry* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ThreatEntryMetadata_MetadataEntry& from);
+  void MergeFrom(const ThreatEntryMetadata_MetadataEntry& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional bytes key = 1;
+  inline bool has_key() const;
+  inline void clear_key();
+  static const int kKeyFieldNumber = 1;
+  inline const ::std::string& key() const;
+  inline void set_key(const ::std::string& value);
+  inline void set_key(const char* value);
+  inline void set_key(const void* value, size_t size);
+  inline ::std::string* mutable_key();
+  inline ::std::string* release_key();
+  inline void set_allocated_key(::std::string* key);
+
+  // optional bytes value = 2;
+  inline bool has_value() const;
+  inline void clear_value();
+  static const int kValueFieldNumber = 2;
+  inline const ::std::string& value() const;
+  inline void set_value(const ::std::string& value);
+  inline void set_value(const char* value);
+  inline void set_value(const void* value, size_t size);
+  inline ::std::string* mutable_value();
+  inline ::std::string* release_value();
+  inline void set_allocated_value(::std::string* value);
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry)
+ private:
+  inline void set_has_key();
+  inline void clear_has_key();
+  inline void set_has_value();
+  inline void clear_has_value();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* key_;
+  ::std::string* value_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static ThreatEntryMetadata_MetadataEntry* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ThreatEntryMetadata : public ::google::protobuf::MessageLite {
+ public:
+  ThreatEntryMetadata();
+  virtual ~ThreatEntryMetadata();
+
+  ThreatEntryMetadata(const ThreatEntryMetadata& from);
+
+  inline ThreatEntryMetadata& operator=(const ThreatEntryMetadata& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ThreatEntryMetadata& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ThreatEntryMetadata* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ThreatEntryMetadata* other);
+
+  // implements Message ----------------------------------------------
+
+  ThreatEntryMetadata* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ThreatEntryMetadata& from);
+  void MergeFrom(const ThreatEntryMetadata& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ThreatEntryMetadata_MetadataEntry MetadataEntry;
+
+  // accessors -------------------------------------------------------
+
+  // repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1;
+  inline int entries_size() const;
+  inline void clear_entries();
+  static const int kEntriesFieldNumber = 1;
+  inline const ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry& entries(int index) const;
+  inline ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* mutable_entries(int index);
+  inline ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* add_entries();
+  inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >&
+      entries() const;
+  inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >*
+      mutable_entries();
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatEntryMetadata)
+ private:
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry > entries_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static ThreatEntryMetadata* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ThreatListDescriptor : public ::google::protobuf::MessageLite {
+ public:
+  ThreatListDescriptor();
+  virtual ~ThreatListDescriptor();
+
+  ThreatListDescriptor(const ThreatListDescriptor& from);
+
+  inline ThreatListDescriptor& operator=(const ThreatListDescriptor& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ThreatListDescriptor& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ThreatListDescriptor* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ThreatListDescriptor* other);
+
+  // implements Message ----------------------------------------------
+
+  ThreatListDescriptor* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ThreatListDescriptor& from);
+  void MergeFrom(const ThreatListDescriptor& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+  inline bool has_threat_type() const;
+  inline void clear_threat_type();
+  static const int kThreatTypeFieldNumber = 1;
+  inline ::mozilla::safebrowsing::ThreatType threat_type() const;
+  inline void set_threat_type(::mozilla::safebrowsing::ThreatType value);
+
+  // optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+  inline bool has_platform_type() const;
+  inline void clear_platform_type();
+  static const int kPlatformTypeFieldNumber = 2;
+  inline ::mozilla::safebrowsing::PlatformType platform_type() const;
+  inline void set_platform_type(::mozilla::safebrowsing::PlatformType value);
+
+  // optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3;
+  inline bool has_threat_entry_type() const;
+  inline void clear_threat_entry_type();
+  static const int kThreatEntryTypeFieldNumber = 3;
+  inline ::mozilla::safebrowsing::ThreatEntryType threat_entry_type() const;
+  inline void set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value);
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ThreatListDescriptor)
+ private:
+  inline void set_has_threat_type();
+  inline void clear_has_threat_type();
+  inline void set_has_platform_type();
+  inline void clear_has_platform_type();
+  inline void set_has_threat_entry_type();
+  inline void clear_has_threat_entry_type();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  int threat_type_;
+  int platform_type_;
+  int threat_entry_type_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static ThreatListDescriptor* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ListThreatListsResponse : public ::google::protobuf::MessageLite {
+ public:
+  ListThreatListsResponse();
+  virtual ~ListThreatListsResponse();
+
+  ListThreatListsResponse(const ListThreatListsResponse& from);
+
+  inline ListThreatListsResponse& operator=(const ListThreatListsResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ListThreatListsResponse& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ListThreatListsResponse* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ListThreatListsResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  ListThreatListsResponse* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ListThreatListsResponse& from);
+  void MergeFrom(const ListThreatListsResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1;
+  inline int threat_lists_size() const;
+  inline void clear_threat_lists();
+  static const int kThreatListsFieldNumber = 1;
+  inline const ::mozilla::safebrowsing::ThreatListDescriptor& threat_lists(int index) const;
+  inline ::mozilla::safebrowsing::ThreatListDescriptor* mutable_threat_lists(int index);
+  inline ::mozilla::safebrowsing::ThreatListDescriptor* add_threat_lists();
+  inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >&
+      threat_lists() const;
+  inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >*
+      mutable_threat_lists();
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.ListThreatListsResponse)
+ private:
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor > threat_lists_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static ListThreatListsResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class Duration : public ::google::protobuf::MessageLite {
+ public:
+  Duration();
+  virtual ~Duration();
+
+  Duration(const Duration& from);
+
+  inline Duration& operator=(const Duration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const Duration& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const Duration* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(Duration* other);
+
+  // implements Message ----------------------------------------------
+
+  Duration* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const Duration& from);
+  void MergeFrom(const Duration& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional int64 seconds = 1;
+  inline bool has_seconds() const;
+  inline void clear_seconds();
+  static const int kSecondsFieldNumber = 1;
+  inline ::google::protobuf::int64 seconds() const;
+  inline void set_seconds(::google::protobuf::int64 value);
+
+  // optional int32 nanos = 2;
+  inline bool has_nanos() const;
+  inline void clear_nanos();
+  static const int kNanosFieldNumber = 2;
+  inline ::google::protobuf::int32 nanos() const;
+  inline void set_nanos(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:mozilla.safebrowsing.Duration)
+ private:
+  inline void set_has_seconds();
+  inline void clear_has_seconds();
+  inline void set_has_nanos();
+  inline void clear_has_nanos();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::int64 seconds_;
+  ::google::protobuf::int32 nanos_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_safebrowsing_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_safebrowsing_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_safebrowsing_2eproto();
+  friend void protobuf_ShutdownFile_safebrowsing_2eproto();
+
+  void InitAsDefaultInstance();
+  static Duration* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+// ThreatInfo
+
+// repeated .mozilla.safebrowsing.ThreatType threat_types = 1;
+inline int ThreatInfo::threat_types_size() const {
+  return threat_types_.size();
+}
+inline void ThreatInfo::clear_threat_types() {
+  threat_types_.Clear();
+}
+inline ::mozilla::safebrowsing::ThreatType ThreatInfo::threat_types(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.threat_types)
+  return static_cast< ::mozilla::safebrowsing::ThreatType >(threat_types_.Get(index));
+}
+inline void ThreatInfo::set_threat_types(int index, ::mozilla::safebrowsing::ThreatType value) {
+  assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
+  threat_types_.Set(index, value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatInfo.threat_types)
+}
+inline void ThreatInfo::add_threat_types(::mozilla::safebrowsing::ThreatType value) {
+  assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
+  threat_types_.Add(value);
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.threat_types)
+}
+inline const ::google::protobuf::RepeatedField<int>&
+ThreatInfo::threat_types() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.threat_types)
+  return threat_types_;
+}
+inline ::google::protobuf::RepeatedField<int>*
+ThreatInfo::mutable_threat_types() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.threat_types)
+  return &threat_types_;
+}
+
+// repeated .mozilla.safebrowsing.PlatformType platform_types = 2;
+inline int ThreatInfo::platform_types_size() const {
+  return platform_types_.size();
+}
+inline void ThreatInfo::clear_platform_types() {
+  platform_types_.Clear();
+}
+inline ::mozilla::safebrowsing::PlatformType ThreatInfo::platform_types(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.platform_types)
+  return static_cast< ::mozilla::safebrowsing::PlatformType >(platform_types_.Get(index));
+}
+inline void ThreatInfo::set_platform_types(int index, ::mozilla::safebrowsing::PlatformType value) {
+  assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
+  platform_types_.Set(index, value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatInfo.platform_types)
+}
+inline void ThreatInfo::add_platform_types(::mozilla::safebrowsing::PlatformType value) {
+  assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
+  platform_types_.Add(value);
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.platform_types)
+}
+inline const ::google::protobuf::RepeatedField<int>&
+ThreatInfo::platform_types() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.platform_types)
+  return platform_types_;
+}
+inline ::google::protobuf::RepeatedField<int>*
+ThreatInfo::mutable_platform_types() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.platform_types)
+  return &platform_types_;
+}
+
+// repeated .mozilla.safebrowsing.ThreatEntryType threat_entry_types = 4;
+inline int ThreatInfo::threat_entry_types_size() const {
+  return threat_entry_types_.size();
+}
+inline void ThreatInfo::clear_threat_entry_types() {
+  threat_entry_types_.Clear();
+}
+inline ::mozilla::safebrowsing::ThreatEntryType ThreatInfo::threat_entry_types(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.threat_entry_types)
+  return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(threat_entry_types_.Get(index));
+}
+inline void ThreatInfo::set_threat_entry_types(int index, ::mozilla::safebrowsing::ThreatEntryType value) {
+  assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value));
+  threat_entry_types_.Set(index, value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatInfo.threat_entry_types)
+}
+inline void ThreatInfo::add_threat_entry_types(::mozilla::safebrowsing::ThreatEntryType value) {
+  assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value));
+  threat_entry_types_.Add(value);
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.threat_entry_types)
+}
+inline const ::google::protobuf::RepeatedField<int>&
+ThreatInfo::threat_entry_types() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.threat_entry_types)
+  return threat_entry_types_;
+}
+inline ::google::protobuf::RepeatedField<int>*
+ThreatInfo::mutable_threat_entry_types() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.threat_entry_types)
+  return &threat_entry_types_;
+}
+
+// repeated .mozilla.safebrowsing.ThreatEntry threat_entries = 3;
+inline int ThreatInfo::threat_entries_size() const {
+  return threat_entries_.size();
+}
+inline void ThreatInfo::clear_threat_entries() {
+  threat_entries_.Clear();
+}
+inline const ::mozilla::safebrowsing::ThreatEntry& ThreatInfo::threat_entries(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatInfo.threat_entries)
+  return threat_entries_.Get(index);
+}
+inline ::mozilla::safebrowsing::ThreatEntry* ThreatInfo::mutable_threat_entries(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatInfo.threat_entries)
+  return threat_entries_.Mutable(index);
+}
+inline ::mozilla::safebrowsing::ThreatEntry* ThreatInfo::add_threat_entries() {
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatInfo.threat_entries)
+  return threat_entries_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >&
+ThreatInfo::threat_entries() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatInfo.threat_entries)
+  return threat_entries_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntry >*
+ThreatInfo::mutable_threat_entries() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatInfo.threat_entries)
+  return &threat_entries_;
+}
+
+// -------------------------------------------------------------------
+
+// ThreatMatch
+
+// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+inline bool ThreatMatch::has_threat_type() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ThreatMatch::set_has_threat_type() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ThreatMatch::clear_has_threat_type() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ThreatMatch::clear_threat_type() {
+  threat_type_ = 0;
+  clear_has_threat_type();
+}
+inline ::mozilla::safebrowsing::ThreatType ThreatMatch::threat_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat_type)
+  return static_cast< ::mozilla::safebrowsing::ThreatType >(threat_type_);
+}
+inline void ThreatMatch::set_threat_type(::mozilla::safebrowsing::ThreatType value) {
+  assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
+  set_has_threat_type();
+  threat_type_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatMatch.threat_type)
+}
+
+// optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+inline bool ThreatMatch::has_platform_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ThreatMatch::set_has_platform_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ThreatMatch::clear_has_platform_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ThreatMatch::clear_platform_type() {
+  platform_type_ = 0;
+  clear_has_platform_type();
+}
+inline ::mozilla::safebrowsing::PlatformType ThreatMatch::platform_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.platform_type)
+  return static_cast< ::mozilla::safebrowsing::PlatformType >(platform_type_);
+}
+inline void ThreatMatch::set_platform_type(::mozilla::safebrowsing::PlatformType value) {
+  assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
+  set_has_platform_type();
+  platform_type_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatMatch.platform_type)
+}
+
+// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 6;
+inline bool ThreatMatch::has_threat_entry_type() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ThreatMatch::set_has_threat_entry_type() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ThreatMatch::clear_has_threat_entry_type() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ThreatMatch::clear_threat_entry_type() {
+  threat_entry_type_ = 0;
+  clear_has_threat_entry_type();
+}
+inline ::mozilla::safebrowsing::ThreatEntryType ThreatMatch::threat_entry_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat_entry_type)
+  return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(threat_entry_type_);
+}
+inline void ThreatMatch::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
+  assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value));
+  set_has_threat_entry_type();
+  threat_entry_type_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatMatch.threat_entry_type)
+}
+
+// optional .mozilla.safebrowsing.ThreatEntry threat = 3;
+inline bool ThreatMatch::has_threat() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ThreatMatch::set_has_threat() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ThreatMatch::clear_has_threat() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ThreatMatch::clear_threat() {
+  if (threat_ != NULL) threat_->::mozilla::safebrowsing::ThreatEntry::Clear();
+  clear_has_threat();
+}
+inline const ::mozilla::safebrowsing::ThreatEntry& ThreatMatch::threat() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return threat_ != NULL ? *threat_ : *default_instance().threat_;
+#else
+  return threat_ != NULL ? *threat_ : *default_instance_->threat_;
+#endif
+}
+inline ::mozilla::safebrowsing::ThreatEntry* ThreatMatch::mutable_threat() {
+  set_has_threat();
+  if (threat_ == NULL) threat_ = new ::mozilla::safebrowsing::ThreatEntry;
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatMatch.threat)
+  return threat_;
+}
+inline ::mozilla::safebrowsing::ThreatEntry* ThreatMatch::release_threat() {
+  clear_has_threat();
+  ::mozilla::safebrowsing::ThreatEntry* temp = threat_;
+  threat_ = NULL;
+  return temp;
+}
+inline void ThreatMatch::set_allocated_threat(::mozilla::safebrowsing::ThreatEntry* threat) {
+  delete threat_;
+  threat_ = threat;
+  if (threat) {
+    set_has_threat();
+  } else {
+    clear_has_threat();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatMatch.threat)
+}
+
+// optional .mozilla.safebrowsing.ThreatEntryMetadata threat_entry_metadata = 4;
+inline bool ThreatMatch::has_threat_entry_metadata() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ThreatMatch::set_has_threat_entry_metadata() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ThreatMatch::clear_has_threat_entry_metadata() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ThreatMatch::clear_threat_entry_metadata() {
+  if (threat_entry_metadata_ != NULL) threat_entry_metadata_->::mozilla::safebrowsing::ThreatEntryMetadata::Clear();
+  clear_has_threat_entry_metadata();
+}
+inline const ::mozilla::safebrowsing::ThreatEntryMetadata& ThreatMatch::threat_entry_metadata() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return threat_entry_metadata_ != NULL ? *threat_entry_metadata_ : *default_instance().threat_entry_metadata_;
+#else
+  return threat_entry_metadata_ != NULL ? *threat_entry_metadata_ : *default_instance_->threat_entry_metadata_;
+#endif
+}
+inline ::mozilla::safebrowsing::ThreatEntryMetadata* ThreatMatch::mutable_threat_entry_metadata() {
+  set_has_threat_entry_metadata();
+  if (threat_entry_metadata_ == NULL) threat_entry_metadata_ = new ::mozilla::safebrowsing::ThreatEntryMetadata;
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata)
+  return threat_entry_metadata_;
+}
+inline ::mozilla::safebrowsing::ThreatEntryMetadata* ThreatMatch::release_threat_entry_metadata() {
+  clear_has_threat_entry_metadata();
+  ::mozilla::safebrowsing::ThreatEntryMetadata* temp = threat_entry_metadata_;
+  threat_entry_metadata_ = NULL;
+  return temp;
+}
+inline void ThreatMatch::set_allocated_threat_entry_metadata(::mozilla::safebrowsing::ThreatEntryMetadata* threat_entry_metadata) {
+  delete threat_entry_metadata_;
+  threat_entry_metadata_ = threat_entry_metadata;
+  if (threat_entry_metadata) {
+    set_has_threat_entry_metadata();
+  } else {
+    clear_has_threat_entry_metadata();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatMatch.threat_entry_metadata)
+}
+
+// optional .mozilla.safebrowsing.Duration cache_duration = 5;
+inline bool ThreatMatch::has_cache_duration() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ThreatMatch::set_has_cache_duration() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ThreatMatch::clear_has_cache_duration() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ThreatMatch::clear_cache_duration() {
+  if (cache_duration_ != NULL) cache_duration_->::mozilla::safebrowsing::Duration::Clear();
+  clear_has_cache_duration();
+}
+inline const ::mozilla::safebrowsing::Duration& ThreatMatch::cache_duration() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatMatch.cache_duration)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return cache_duration_ != NULL ? *cache_duration_ : *default_instance().cache_duration_;
+#else
+  return cache_duration_ != NULL ? *cache_duration_ : *default_instance_->cache_duration_;
+#endif
+}
+inline ::mozilla::safebrowsing::Duration* ThreatMatch::mutable_cache_duration() {
+  set_has_cache_duration();
+  if (cache_duration_ == NULL) cache_duration_ = new ::mozilla::safebrowsing::Duration;
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatMatch.cache_duration)
+  return cache_duration_;
+}
+inline ::mozilla::safebrowsing::Duration* ThreatMatch::release_cache_duration() {
+  clear_has_cache_duration();
+  ::mozilla::safebrowsing::Duration* temp = cache_duration_;
+  cache_duration_ = NULL;
+  return temp;
+}
+inline void ThreatMatch::set_allocated_cache_duration(::mozilla::safebrowsing::Duration* cache_duration) {
+  delete cache_duration_;
+  cache_duration_ = cache_duration;
+  if (cache_duration) {
+    set_has_cache_duration();
+  } else {
+    clear_has_cache_duration();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatMatch.cache_duration)
+}
+
+// -------------------------------------------------------------------
+
+// FindThreatMatchesRequest
+
+// optional .mozilla.safebrowsing.ClientInfo client = 1;
+inline bool FindThreatMatchesRequest::has_client() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void FindThreatMatchesRequest::set_has_client() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void FindThreatMatchesRequest::clear_has_client() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void FindThreatMatchesRequest::clear_client() {
+  if (client_ != NULL) client_->::mozilla::safebrowsing::ClientInfo::Clear();
+  clear_has_client();
+}
+inline const ::mozilla::safebrowsing::ClientInfo& FindThreatMatchesRequest::client() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindThreatMatchesRequest.client)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return client_ != NULL ? *client_ : *default_instance().client_;
+#else
+  return client_ != NULL ? *client_ : *default_instance_->client_;
+#endif
+}
+inline ::mozilla::safebrowsing::ClientInfo* FindThreatMatchesRequest::mutable_client() {
+  set_has_client();
+  if (client_ == NULL) client_ = new ::mozilla::safebrowsing::ClientInfo;
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindThreatMatchesRequest.client)
+  return client_;
+}
+inline ::mozilla::safebrowsing::ClientInfo* FindThreatMatchesRequest::release_client() {
+  clear_has_client();
+  ::mozilla::safebrowsing::ClientInfo* temp = client_;
+  client_ = NULL;
+  return temp;
+}
+inline void FindThreatMatchesRequest::set_allocated_client(::mozilla::safebrowsing::ClientInfo* client) {
+  delete client_;
+  client_ = client;
+  if (client) {
+    set_has_client();
+  } else {
+    clear_has_client();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindThreatMatchesRequest.client)
+}
+
+// optional .mozilla.safebrowsing.ThreatInfo threat_info = 2;
+inline bool FindThreatMatchesRequest::has_threat_info() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void FindThreatMatchesRequest::set_has_threat_info() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void FindThreatMatchesRequest::clear_has_threat_info() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void FindThreatMatchesRequest::clear_threat_info() {
+  if (threat_info_ != NULL) threat_info_->::mozilla::safebrowsing::ThreatInfo::Clear();
+  clear_has_threat_info();
+}
+inline const ::mozilla::safebrowsing::ThreatInfo& FindThreatMatchesRequest::threat_info() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return threat_info_ != NULL ? *threat_info_ : *default_instance().threat_info_;
+#else
+  return threat_info_ != NULL ? *threat_info_ : *default_instance_->threat_info_;
+#endif
+}
+inline ::mozilla::safebrowsing::ThreatInfo* FindThreatMatchesRequest::mutable_threat_info() {
+  set_has_threat_info();
+  if (threat_info_ == NULL) threat_info_ = new ::mozilla::safebrowsing::ThreatInfo;
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info)
+  return threat_info_;
+}
+inline ::mozilla::safebrowsing::ThreatInfo* FindThreatMatchesRequest::release_threat_info() {
+  clear_has_threat_info();
+  ::mozilla::safebrowsing::ThreatInfo* temp = threat_info_;
+  threat_info_ = NULL;
+  return temp;
+}
+inline void FindThreatMatchesRequest::set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info) {
+  delete threat_info_;
+  threat_info_ = threat_info;
+  if (threat_info) {
+    set_has_threat_info();
+  } else {
+    clear_has_threat_info();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindThreatMatchesRequest.threat_info)
+}
+
+// -------------------------------------------------------------------
+
+// FindThreatMatchesResponse
+
+// repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
+inline int FindThreatMatchesResponse::matches_size() const {
+  return matches_.size();
+}
+inline void FindThreatMatchesResponse::clear_matches() {
+  matches_.Clear();
+}
+inline const ::mozilla::safebrowsing::ThreatMatch& FindThreatMatchesResponse::matches(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindThreatMatchesResponse.matches)
+  return matches_.Get(index);
+}
+inline ::mozilla::safebrowsing::ThreatMatch* FindThreatMatchesResponse::mutable_matches(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindThreatMatchesResponse.matches)
+  return matches_.Mutable(index);
+}
+inline ::mozilla::safebrowsing::ThreatMatch* FindThreatMatchesResponse::add_matches() {
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FindThreatMatchesResponse.matches)
+  return matches_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >&
+FindThreatMatchesResponse::matches() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FindThreatMatchesResponse.matches)
+  return matches_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >*
+FindThreatMatchesResponse::mutable_matches() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FindThreatMatchesResponse.matches)
+  return &matches_;
+}
+
+// -------------------------------------------------------------------
+
+// FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints
+
+// optional int32 max_update_entries = 1;
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::has_max_update_entries() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_has_max_update_entries() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_has_max_update_entries() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_max_update_entries() {
+  max_update_entries_ = 0;
+  clear_has_max_update_entries();
+}
+inline ::google::protobuf::int32 FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::max_update_entries() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_update_entries)
+  return max_update_entries_;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_max_update_entries(::google::protobuf::int32 value) {
+  set_has_max_update_entries();
+  max_update_entries_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_update_entries)
+}
+
+// optional int32 max_database_entries = 2;
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::has_max_database_entries() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_has_max_database_entries() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_has_max_database_entries() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_max_database_entries() {
+  max_database_entries_ = 0;
+  clear_has_max_database_entries();
+}
+inline ::google::protobuf::int32 FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::max_database_entries() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_database_entries)
+  return max_database_entries_;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_max_database_entries(::google::protobuf::int32 value) {
+  set_has_max_database_entries();
+  max_database_entries_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.max_database_entries)
+}
+
+// optional string region = 3;
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::has_region() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_has_region() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_has_region() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_region() {
+  if (region_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    region_->clear();
+  }
+  clear_has_region();
+}
+inline const ::std::string& FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::region() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
+  return *region_;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_region(const ::std::string& value) {
+  set_has_region();
+  if (region_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    region_ = new ::std::string;
+  }
+  region_->assign(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_region(const char* value) {
+  set_has_region();
+  if (region_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    region_ = new ::std::string;
+  }
+  region_->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_region(const char* value, size_t size) {
+  set_has_region();
+  if (region_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    region_ = new ::std::string;
+  }
+  region_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
+}
+inline ::std::string* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::mutable_region() {
+  set_has_region();
+  if (region_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    region_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
+  return region_;
+}
+inline ::std::string* FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::release_region() {
+  clear_has_region();
+  if (region_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = region_;
+    region_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_allocated_region(::std::string* region) {
+  if (region_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete region_;
+  }
+  if (region) {
+    set_has_region();
+    region_ = region;
+  } else {
+    clear_has_region();
+    region_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.region)
+}
+
+// repeated .mozilla.safebrowsing.CompressionType supported_compressions = 4;
+inline int FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::supported_compressions_size() const {
+  return supported_compressions_.size();
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::clear_supported_compressions() {
+  supported_compressions_.Clear();
+}
+inline ::mozilla::safebrowsing::CompressionType FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::supported_compressions(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions)
+  return static_cast< ::mozilla::safebrowsing::CompressionType >(supported_compressions_.Get(index));
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::set_supported_compressions(int index, ::mozilla::safebrowsing::CompressionType value) {
+  assert(::mozilla::safebrowsing::CompressionType_IsValid(value));
+  supported_compressions_.Set(index, value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions)
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::add_supported_compressions(::mozilla::safebrowsing::CompressionType value) {
+  assert(::mozilla::safebrowsing::CompressionType_IsValid(value));
+  supported_compressions_.Add(value);
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions)
+}
+inline const ::google::protobuf::RepeatedField<int>&
+FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::supported_compressions() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions)
+  return supported_compressions_;
+}
+inline ::google::protobuf::RepeatedField<int>*
+FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::mutable_supported_compressions() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints.supported_compressions)
+  return &supported_compressions_;
+}
+
+// -------------------------------------------------------------------
+
+// FetchThreatListUpdatesRequest_ListUpdateRequest
+
+// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_threat_type() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_has_threat_type() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_has_threat_type() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_threat_type() {
+  threat_type_ = 0;
+  clear_has_threat_type();
+}
+inline ::mozilla::safebrowsing::ThreatType FetchThreatListUpdatesRequest_ListUpdateRequest::threat_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_type)
+  return static_cast< ::mozilla::safebrowsing::ThreatType >(threat_type_);
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_threat_type(::mozilla::safebrowsing::ThreatType value) {
+  assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
+  set_has_threat_type();
+  threat_type_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_type)
+}
+
+// optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_platform_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_has_platform_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_has_platform_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_platform_type() {
+  platform_type_ = 0;
+  clear_has_platform_type();
+}
+inline ::mozilla::safebrowsing::PlatformType FetchThreatListUpdatesRequest_ListUpdateRequest::platform_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.platform_type)
+  return static_cast< ::mozilla::safebrowsing::PlatformType >(platform_type_);
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_platform_type(::mozilla::safebrowsing::PlatformType value) {
+  assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
+  set_has_platform_type();
+  platform_type_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.platform_type)
+}
+
+// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 5;
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_threat_entry_type() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_has_threat_entry_type() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_has_threat_entry_type() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_threat_entry_type() {
+  threat_entry_type_ = 0;
+  clear_has_threat_entry_type();
+}
+inline ::mozilla::safebrowsing::ThreatEntryType FetchThreatListUpdatesRequest_ListUpdateRequest::threat_entry_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_entry_type)
+  return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(threat_entry_type_);
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
+  assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value));
+  set_has_threat_entry_type();
+  threat_entry_type_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.threat_entry_type)
+}
+
+// optional bytes state = 3;
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_state() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_has_state() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_has_state() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_state() {
+  if (state_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    state_->clear();
+  }
+  clear_has_state();
+}
+inline const ::std::string& FetchThreatListUpdatesRequest_ListUpdateRequest::state() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
+  return *state_;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_state(const ::std::string& value) {
+  set_has_state();
+  if (state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    state_ = new ::std::string;
+  }
+  state_->assign(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_state(const char* value) {
+  set_has_state();
+  if (state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    state_ = new ::std::string;
+  }
+  state_->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_state(const void* value, size_t size) {
+  set_has_state();
+  if (state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    state_ = new ::std::string;
+  }
+  state_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
+}
+inline ::std::string* FetchThreatListUpdatesRequest_ListUpdateRequest::mutable_state() {
+  set_has_state();
+  if (state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    state_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
+  return state_;
+}
+inline ::std::string* FetchThreatListUpdatesRequest_ListUpdateRequest::release_state() {
+  clear_has_state();
+  if (state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = state_;
+    state_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_allocated_state(::std::string* state) {
+  if (state_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete state_;
+  }
+  if (state) {
+    set_has_state();
+    state_ = state;
+  } else {
+    clear_has_state();
+    state_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.state)
+}
+
+// optional .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.Constraints constraints = 4;
+inline bool FetchThreatListUpdatesRequest_ListUpdateRequest::has_constraints() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_has_constraints() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_has_constraints() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::clear_constraints() {
+  if (constraints_ != NULL) constraints_->::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints::Clear();
+  clear_has_constraints();
+}
+inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints& FetchThreatListUpdatesRequest_ListUpdateRequest::constraints() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return constraints_ != NULL ? *constraints_ : *default_instance().constraints_;
+#else
+  return constraints_ != NULL ? *constraints_ : *default_instance_->constraints_;
+#endif
+}
+inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest::mutable_constraints() {
+  set_has_constraints();
+  if (constraints_ == NULL) constraints_ = new ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints;
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints)
+  return constraints_;
+}
+inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* FetchThreatListUpdatesRequest_ListUpdateRequest::release_constraints() {
+  clear_has_constraints();
+  ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* temp = constraints_;
+  constraints_ = NULL;
+  return temp;
+}
+inline void FetchThreatListUpdatesRequest_ListUpdateRequest::set_allocated_constraints(::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest_Constraints* constraints) {
+  delete constraints_;
+  constraints_ = constraints;
+  if (constraints) {
+    set_has_constraints();
+  } else {
+    clear_has_constraints();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest.constraints)
+}
+
+// -------------------------------------------------------------------
+
+// FetchThreatListUpdatesRequest
+
+// optional .mozilla.safebrowsing.ClientInfo client = 1;
+inline bool FetchThreatListUpdatesRequest::has_client() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void FetchThreatListUpdatesRequest::set_has_client() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void FetchThreatListUpdatesRequest::clear_has_client() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void FetchThreatListUpdatesRequest::clear_client() {
+  if (client_ != NULL) client_->::mozilla::safebrowsing::ClientInfo::Clear();
+  clear_has_client();
+}
+inline const ::mozilla::safebrowsing::ClientInfo& FetchThreatListUpdatesRequest::client() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return client_ != NULL ? *client_ : *default_instance().client_;
+#else
+  return client_ != NULL ? *client_ : *default_instance_->client_;
+#endif
+}
+inline ::mozilla::safebrowsing::ClientInfo* FetchThreatListUpdatesRequest::mutable_client() {
+  set_has_client();
+  if (client_ == NULL) client_ = new ::mozilla::safebrowsing::ClientInfo;
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client)
+  return client_;
+}
+inline ::mozilla::safebrowsing::ClientInfo* FetchThreatListUpdatesRequest::release_client() {
+  clear_has_client();
+  ::mozilla::safebrowsing::ClientInfo* temp = client_;
+  client_ = NULL;
+  return temp;
+}
+inline void FetchThreatListUpdatesRequest::set_allocated_client(::mozilla::safebrowsing::ClientInfo* client) {
+  delete client_;
+  client_ = client;
+  if (client) {
+    set_has_client();
+  } else {
+    clear_has_client();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesRequest.client)
+}
+
+// repeated .mozilla.safebrowsing.FetchThreatListUpdatesRequest.ListUpdateRequest list_update_requests = 3;
+inline int FetchThreatListUpdatesRequest::list_update_requests_size() const {
+  return list_update_requests_.size();
+}
+inline void FetchThreatListUpdatesRequest::clear_list_update_requests() {
+  list_update_requests_.Clear();
+}
+inline const ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest& FetchThreatListUpdatesRequest::list_update_requests(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests)
+  return list_update_requests_.Get(index);
+}
+inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* FetchThreatListUpdatesRequest::mutable_list_update_requests(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests)
+  return list_update_requests_.Mutable(index);
+}
+inline ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest* FetchThreatListUpdatesRequest::add_list_update_requests() {
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests)
+  return list_update_requests_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >&
+FetchThreatListUpdatesRequest::list_update_requests() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests)
+  return list_update_requests_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesRequest_ListUpdateRequest >*
+FetchThreatListUpdatesRequest::mutable_list_update_requests() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesRequest.list_update_requests)
+  return &list_update_requests_;
+}
+
+// -------------------------------------------------------------------
+
+// FetchThreatListUpdatesResponse_ListUpdateResponse
+
+// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_threat_type() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_has_threat_type() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_has_threat_type() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_threat_type() {
+  threat_type_ = 0;
+  clear_has_threat_type();
+}
+inline ::mozilla::safebrowsing::ThreatType FetchThreatListUpdatesResponse_ListUpdateResponse::threat_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_type)
+  return static_cast< ::mozilla::safebrowsing::ThreatType >(threat_type_);
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_threat_type(::mozilla::safebrowsing::ThreatType value) {
+  assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
+  set_has_threat_type();
+  threat_type_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_type)
+}
+
+// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 2;
+inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_threat_entry_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_has_threat_entry_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_has_threat_entry_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_threat_entry_type() {
+  threat_entry_type_ = 0;
+  clear_has_threat_entry_type();
+}
+inline ::mozilla::safebrowsing::ThreatEntryType FetchThreatListUpdatesResponse_ListUpdateResponse::threat_entry_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_entry_type)
+  return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(threat_entry_type_);
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
+  assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value));
+  set_has_threat_entry_type();
+  threat_entry_type_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.threat_entry_type)
+}
+
+// optional .mozilla.safebrowsing.PlatformType platform_type = 3;
+inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_platform_type() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_has_platform_type() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_has_platform_type() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_platform_type() {
+  platform_type_ = 0;
+  clear_has_platform_type();
+}
+inline ::mozilla::safebrowsing::PlatformType FetchThreatListUpdatesResponse_ListUpdateResponse::platform_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.platform_type)
+  return static_cast< ::mozilla::safebrowsing::PlatformType >(platform_type_);
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_platform_type(::mozilla::safebrowsing::PlatformType value) {
+  assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
+  set_has_platform_type();
+  platform_type_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.platform_type)
+}
+
+// optional .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.ResponseType response_type = 4;
+inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_response_type() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_has_response_type() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_has_response_type() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_response_type() {
+  response_type_ = 0;
+  clear_has_response_type();
+}
+inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType FetchThreatListUpdatesResponse_ListUpdateResponse::response_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.response_type)
+  return static_cast< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType >(response_type_);
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_response_type(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType value) {
+  assert(::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse_ResponseType_IsValid(value));
+  set_has_response_type();
+  response_type_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.response_type)
+}
+
+// repeated .mozilla.safebrowsing.ThreatEntrySet additions = 5;
+inline int FetchThreatListUpdatesResponse_ListUpdateResponse::additions_size() const {
+  return additions_.size();
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_additions() {
+  additions_.Clear();
+}
+inline const ::mozilla::safebrowsing::ThreatEntrySet& FetchThreatListUpdatesResponse_ListUpdateResponse::additions(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions)
+  return additions_.Get(index);
+}
+inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_additions(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions)
+  return additions_.Mutable(index);
+}
+inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::add_additions() {
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions)
+  return additions_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >&
+FetchThreatListUpdatesResponse_ListUpdateResponse::additions() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions)
+  return additions_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >*
+FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_additions() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.additions)
+  return &additions_;
+}
+
+// repeated .mozilla.safebrowsing.ThreatEntrySet removals = 6;
+inline int FetchThreatListUpdatesResponse_ListUpdateResponse::removals_size() const {
+  return removals_.size();
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_removals() {
+  removals_.Clear();
+}
+inline const ::mozilla::safebrowsing::ThreatEntrySet& FetchThreatListUpdatesResponse_ListUpdateResponse::removals(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals)
+  return removals_.Get(index);
+}
+inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_removals(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals)
+  return removals_.Mutable(index);
+}
+inline ::mozilla::safebrowsing::ThreatEntrySet* FetchThreatListUpdatesResponse_ListUpdateResponse::add_removals() {
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals)
+  return removals_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >&
+FetchThreatListUpdatesResponse_ListUpdateResponse::removals() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals)
+  return removals_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntrySet >*
+FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_removals() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.removals)
+  return &removals_;
+}
+
+// optional bytes new_client_state = 7;
+inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_new_client_state() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_has_new_client_state() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_has_new_client_state() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_new_client_state() {
+  if (new_client_state_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    new_client_state_->clear();
+  }
+  clear_has_new_client_state();
+}
+inline const ::std::string& FetchThreatListUpdatesResponse_ListUpdateResponse::new_client_state() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
+  return *new_client_state_;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_new_client_state(const ::std::string& value) {
+  set_has_new_client_state();
+  if (new_client_state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    new_client_state_ = new ::std::string;
+  }
+  new_client_state_->assign(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_new_client_state(const char* value) {
+  set_has_new_client_state();
+  if (new_client_state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    new_client_state_ = new ::std::string;
+  }
+  new_client_state_->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_new_client_state(const void* value, size_t size) {
+  set_has_new_client_state();
+  if (new_client_state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    new_client_state_ = new ::std::string;
+  }
+  new_client_state_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
+}
+inline ::std::string* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_new_client_state() {
+  set_has_new_client_state();
+  if (new_client_state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    new_client_state_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
+  return new_client_state_;
+}
+inline ::std::string* FetchThreatListUpdatesResponse_ListUpdateResponse::release_new_client_state() {
+  clear_has_new_client_state();
+  if (new_client_state_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = new_client_state_;
+    new_client_state_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_allocated_new_client_state(::std::string* new_client_state) {
+  if (new_client_state_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete new_client_state_;
+  }
+  if (new_client_state) {
+    set_has_new_client_state();
+    new_client_state_ = new_client_state;
+  } else {
+    clear_has_new_client_state();
+    new_client_state_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.new_client_state)
+}
+
+// optional .mozilla.safebrowsing.Checksum checksum = 8;
+inline bool FetchThreatListUpdatesResponse_ListUpdateResponse::has_checksum() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_has_checksum() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_has_checksum() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::clear_checksum() {
+  if (checksum_ != NULL) checksum_->::mozilla::safebrowsing::Checksum::Clear();
+  clear_has_checksum();
+}
+inline const ::mozilla::safebrowsing::Checksum& FetchThreatListUpdatesResponse_ListUpdateResponse::checksum() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return checksum_ != NULL ? *checksum_ : *default_instance().checksum_;
+#else
+  return checksum_ != NULL ? *checksum_ : *default_instance_->checksum_;
+#endif
+}
+inline ::mozilla::safebrowsing::Checksum* FetchThreatListUpdatesResponse_ListUpdateResponse::mutable_checksum() {
+  set_has_checksum();
+  if (checksum_ == NULL) checksum_ = new ::mozilla::safebrowsing::Checksum;
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum)
+  return checksum_;
+}
+inline ::mozilla::safebrowsing::Checksum* FetchThreatListUpdatesResponse_ListUpdateResponse::release_checksum() {
+  clear_has_checksum();
+  ::mozilla::safebrowsing::Checksum* temp = checksum_;
+  checksum_ = NULL;
+  return temp;
+}
+inline void FetchThreatListUpdatesResponse_ListUpdateResponse::set_allocated_checksum(::mozilla::safebrowsing::Checksum* checksum) {
+  delete checksum_;
+  checksum_ = checksum;
+  if (checksum) {
+    set_has_checksum();
+  } else {
+    clear_has_checksum();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse.checksum)
+}
+
+// -------------------------------------------------------------------
+
+// FetchThreatListUpdatesResponse
+
+// repeated .mozilla.safebrowsing.FetchThreatListUpdatesResponse.ListUpdateResponse list_update_responses = 1;
+inline int FetchThreatListUpdatesResponse::list_update_responses_size() const {
+  return list_update_responses_.size();
+}
+inline void FetchThreatListUpdatesResponse::clear_list_update_responses() {
+  list_update_responses_.Clear();
+}
+inline const ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse& FetchThreatListUpdatesResponse::list_update_responses(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses)
+  return list_update_responses_.Get(index);
+}
+inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* FetchThreatListUpdatesResponse::mutable_list_update_responses(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses)
+  return list_update_responses_.Mutable(index);
+}
+inline ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse* FetchThreatListUpdatesResponse::add_list_update_responses() {
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses)
+  return list_update_responses_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >&
+FetchThreatListUpdatesResponse::list_update_responses() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses)
+  return list_update_responses_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::FetchThreatListUpdatesResponse_ListUpdateResponse >*
+FetchThreatListUpdatesResponse::mutable_list_update_responses() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FetchThreatListUpdatesResponse.list_update_responses)
+  return &list_update_responses_;
+}
+
+// optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
+inline bool FetchThreatListUpdatesResponse::has_minimum_wait_duration() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void FetchThreatListUpdatesResponse::set_has_minimum_wait_duration() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void FetchThreatListUpdatesResponse::clear_has_minimum_wait_duration() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void FetchThreatListUpdatesResponse::clear_minimum_wait_duration() {
+  if (minimum_wait_duration_ != NULL) minimum_wait_duration_->::mozilla::safebrowsing::Duration::Clear();
+  clear_has_minimum_wait_duration();
+}
+inline const ::mozilla::safebrowsing::Duration& FetchThreatListUpdatesResponse::minimum_wait_duration() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return minimum_wait_duration_ != NULL ? *minimum_wait_duration_ : *default_instance().minimum_wait_duration_;
+#else
+  return minimum_wait_duration_ != NULL ? *minimum_wait_duration_ : *default_instance_->minimum_wait_duration_;
+#endif
+}
+inline ::mozilla::safebrowsing::Duration* FetchThreatListUpdatesResponse::mutable_minimum_wait_duration() {
+  set_has_minimum_wait_duration();
+  if (minimum_wait_duration_ == NULL) minimum_wait_duration_ = new ::mozilla::safebrowsing::Duration;
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration)
+  return minimum_wait_duration_;
+}
+inline ::mozilla::safebrowsing::Duration* FetchThreatListUpdatesResponse::release_minimum_wait_duration() {
+  clear_has_minimum_wait_duration();
+  ::mozilla::safebrowsing::Duration* temp = minimum_wait_duration_;
+  minimum_wait_duration_ = NULL;
+  return temp;
+}
+inline void FetchThreatListUpdatesResponse::set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration* minimum_wait_duration) {
+  delete minimum_wait_duration_;
+  minimum_wait_duration_ = minimum_wait_duration;
+  if (minimum_wait_duration) {
+    set_has_minimum_wait_duration();
+  } else {
+    clear_has_minimum_wait_duration();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FetchThreatListUpdatesResponse.minimum_wait_duration)
+}
+
+// -------------------------------------------------------------------
+
+// FindFullHashesRequest
+
+// optional .mozilla.safebrowsing.ClientInfo client = 1;
+inline bool FindFullHashesRequest::has_client() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void FindFullHashesRequest::set_has_client() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void FindFullHashesRequest::clear_has_client() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void FindFullHashesRequest::clear_client() {
+  if (client_ != NULL) client_->::mozilla::safebrowsing::ClientInfo::Clear();
+  clear_has_client();
+}
+inline const ::mozilla::safebrowsing::ClientInfo& FindFullHashesRequest::client() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesRequest.client)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return client_ != NULL ? *client_ : *default_instance().client_;
+#else
+  return client_ != NULL ? *client_ : *default_instance_->client_;
+#endif
+}
+inline ::mozilla::safebrowsing::ClientInfo* FindFullHashesRequest::mutable_client() {
+  set_has_client();
+  if (client_ == NULL) client_ = new ::mozilla::safebrowsing::ClientInfo;
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesRequest.client)
+  return client_;
+}
+inline ::mozilla::safebrowsing::ClientInfo* FindFullHashesRequest::release_client() {
+  clear_has_client();
+  ::mozilla::safebrowsing::ClientInfo* temp = client_;
+  client_ = NULL;
+  return temp;
+}
+inline void FindFullHashesRequest::set_allocated_client(::mozilla::safebrowsing::ClientInfo* client) {
+  delete client_;
+  client_ = client;
+  if (client) {
+    set_has_client();
+  } else {
+    clear_has_client();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesRequest.client)
+}
+
+// repeated bytes client_states = 2;
+inline int FindFullHashesRequest::client_states_size() const {
+  return client_states_.size();
+}
+inline void FindFullHashesRequest::clear_client_states() {
+  client_states_.Clear();
+}
+inline const ::std::string& FindFullHashesRequest::client_states(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+  return client_states_.Get(index);
+}
+inline ::std::string* FindFullHashesRequest::mutable_client_states(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+  return client_states_.Mutable(index);
+}
+inline void FindFullHashesRequest::set_client_states(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+  client_states_.Mutable(index)->assign(value);
+}
+inline void FindFullHashesRequest::set_client_states(int index, const char* value) {
+  client_states_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+}
+inline void FindFullHashesRequest::set_client_states(int index, const void* value, size_t size) {
+  client_states_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+}
+inline ::std::string* FindFullHashesRequest::add_client_states() {
+  return client_states_.Add();
+}
+inline void FindFullHashesRequest::add_client_states(const ::std::string& value) {
+  client_states_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+}
+inline void FindFullHashesRequest::add_client_states(const char* value) {
+  client_states_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+}
+inline void FindFullHashesRequest::add_client_states(const void* value, size_t size) {
+  client_states_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+FindFullHashesRequest::client_states() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+  return client_states_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+FindFullHashesRequest::mutable_client_states() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FindFullHashesRequest.client_states)
+  return &client_states_;
+}
+
+// optional .mozilla.safebrowsing.ThreatInfo threat_info = 3;
+inline bool FindFullHashesRequest::has_threat_info() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void FindFullHashesRequest::set_has_threat_info() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void FindFullHashesRequest::clear_has_threat_info() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void FindFullHashesRequest::clear_threat_info() {
+  if (threat_info_ != NULL) threat_info_->::mozilla::safebrowsing::ThreatInfo::Clear();
+  clear_has_threat_info();
+}
+inline const ::mozilla::safebrowsing::ThreatInfo& FindFullHashesRequest::threat_info() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesRequest.threat_info)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return threat_info_ != NULL ? *threat_info_ : *default_instance().threat_info_;
+#else
+  return threat_info_ != NULL ? *threat_info_ : *default_instance_->threat_info_;
+#endif
+}
+inline ::mozilla::safebrowsing::ThreatInfo* FindFullHashesRequest::mutable_threat_info() {
+  set_has_threat_info();
+  if (threat_info_ == NULL) threat_info_ = new ::mozilla::safebrowsing::ThreatInfo;
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesRequest.threat_info)
+  return threat_info_;
+}
+inline ::mozilla::safebrowsing::ThreatInfo* FindFullHashesRequest::release_threat_info() {
+  clear_has_threat_info();
+  ::mozilla::safebrowsing::ThreatInfo* temp = threat_info_;
+  threat_info_ = NULL;
+  return temp;
+}
+inline void FindFullHashesRequest::set_allocated_threat_info(::mozilla::safebrowsing::ThreatInfo* threat_info) {
+  delete threat_info_;
+  threat_info_ = threat_info;
+  if (threat_info) {
+    set_has_threat_info();
+  } else {
+    clear_has_threat_info();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesRequest.threat_info)
+}
+
+// -------------------------------------------------------------------
+
+// FindFullHashesResponse
+
+// repeated .mozilla.safebrowsing.ThreatMatch matches = 1;
+inline int FindFullHashesResponse::matches_size() const {
+  return matches_.size();
+}
+inline void FindFullHashesResponse::clear_matches() {
+  matches_.Clear();
+}
+inline const ::mozilla::safebrowsing::ThreatMatch& FindFullHashesResponse::matches(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesResponse.matches)
+  return matches_.Get(index);
+}
+inline ::mozilla::safebrowsing::ThreatMatch* FindFullHashesResponse::mutable_matches(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesResponse.matches)
+  return matches_.Mutable(index);
+}
+inline ::mozilla::safebrowsing::ThreatMatch* FindFullHashesResponse::add_matches() {
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.FindFullHashesResponse.matches)
+  return matches_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >&
+FindFullHashesResponse::matches() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.FindFullHashesResponse.matches)
+  return matches_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatMatch >*
+FindFullHashesResponse::mutable_matches() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.FindFullHashesResponse.matches)
+  return &matches_;
+}
+
+// optional .mozilla.safebrowsing.Duration minimum_wait_duration = 2;
+inline bool FindFullHashesResponse::has_minimum_wait_duration() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void FindFullHashesResponse::set_has_minimum_wait_duration() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void FindFullHashesResponse::clear_has_minimum_wait_duration() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void FindFullHashesResponse::clear_minimum_wait_duration() {
+  if (minimum_wait_duration_ != NULL) minimum_wait_duration_->::mozilla::safebrowsing::Duration::Clear();
+  clear_has_minimum_wait_duration();
+}
+inline const ::mozilla::safebrowsing::Duration& FindFullHashesResponse::minimum_wait_duration() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return minimum_wait_duration_ != NULL ? *minimum_wait_duration_ : *default_instance().minimum_wait_duration_;
+#else
+  return minimum_wait_duration_ != NULL ? *minimum_wait_duration_ : *default_instance_->minimum_wait_duration_;
+#endif
+}
+inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::mutable_minimum_wait_duration() {
+  set_has_minimum_wait_duration();
+  if (minimum_wait_duration_ == NULL) minimum_wait_duration_ = new ::mozilla::safebrowsing::Duration;
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration)
+  return minimum_wait_duration_;
+}
+inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::release_minimum_wait_duration() {
+  clear_has_minimum_wait_duration();
+  ::mozilla::safebrowsing::Duration* temp = minimum_wait_duration_;
+  minimum_wait_duration_ = NULL;
+  return temp;
+}
+inline void FindFullHashesResponse::set_allocated_minimum_wait_duration(::mozilla::safebrowsing::Duration* minimum_wait_duration) {
+  delete minimum_wait_duration_;
+  minimum_wait_duration_ = minimum_wait_duration;
+  if (minimum_wait_duration) {
+    set_has_minimum_wait_duration();
+  } else {
+    clear_has_minimum_wait_duration();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesResponse.minimum_wait_duration)
+}
+
+// optional .mozilla.safebrowsing.Duration negative_cache_duration = 3;
+inline bool FindFullHashesResponse::has_negative_cache_duration() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void FindFullHashesResponse::set_has_negative_cache_duration() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void FindFullHashesResponse::clear_has_negative_cache_duration() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void FindFullHashesResponse::clear_negative_cache_duration() {
+  if (negative_cache_duration_ != NULL) negative_cache_duration_->::mozilla::safebrowsing::Duration::Clear();
+  clear_has_negative_cache_duration();
+}
+inline const ::mozilla::safebrowsing::Duration& FindFullHashesResponse::negative_cache_duration() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return negative_cache_duration_ != NULL ? *negative_cache_duration_ : *default_instance().negative_cache_duration_;
+#else
+  return negative_cache_duration_ != NULL ? *negative_cache_duration_ : *default_instance_->negative_cache_duration_;
+#endif
+}
+inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::mutable_negative_cache_duration() {
+  set_has_negative_cache_duration();
+  if (negative_cache_duration_ == NULL) negative_cache_duration_ = new ::mozilla::safebrowsing::Duration;
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration)
+  return negative_cache_duration_;
+}
+inline ::mozilla::safebrowsing::Duration* FindFullHashesResponse::release_negative_cache_duration() {
+  clear_has_negative_cache_duration();
+  ::mozilla::safebrowsing::Duration* temp = negative_cache_duration_;
+  negative_cache_duration_ = NULL;
+  return temp;
+}
+inline void FindFullHashesResponse::set_allocated_negative_cache_duration(::mozilla::safebrowsing::Duration* negative_cache_duration) {
+  delete negative_cache_duration_;
+  negative_cache_duration_ = negative_cache_duration;
+  if (negative_cache_duration) {
+    set_has_negative_cache_duration();
+  } else {
+    clear_has_negative_cache_duration();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.FindFullHashesResponse.negative_cache_duration)
+}
+
+// -------------------------------------------------------------------
+
+// ThreatHit_ThreatSource
+
+// optional string url = 1;
+inline bool ThreatHit_ThreatSource::has_url() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ThreatHit_ThreatSource::set_has_url() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ThreatHit_ThreatSource::clear_has_url() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ThreatHit_ThreatSource::clear_url() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_->clear();
+  }
+  clear_has_url();
+}
+inline const ::std::string& ThreatHit_ThreatSource::url() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
+  return *url_;
+}
+inline void ThreatHit_ThreatSource::set_url(const ::std::string& value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
+}
+inline void ThreatHit_ThreatSource::set_url(const char* value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
+}
+inline void ThreatHit_ThreatSource::set_url(const char* value, size_t size) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
+}
+inline ::std::string* ThreatHit_ThreatSource::mutable_url() {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
+  return url_;
+}
+inline ::std::string* ThreatHit_ThreatSource::release_url() {
+  clear_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = url_;
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ThreatHit_ThreatSource::set_allocated_url(::std::string* url) {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (url) {
+    set_has_url();
+    url_ = url;
+  } else {
+    clear_has_url();
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.ThreatSource.url)
+}
+
+// optional .mozilla.safebrowsing.ThreatHit.ThreatSourceType type = 2;
+inline bool ThreatHit_ThreatSource::has_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ThreatHit_ThreatSource::set_has_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ThreatHit_ThreatSource::clear_has_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ThreatHit_ThreatSource::clear_type() {
+  type_ = 0;
+  clear_has_type();
+}
+inline ::mozilla::safebrowsing::ThreatHit_ThreatSourceType ThreatHit_ThreatSource::type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.type)
+  return static_cast< ::mozilla::safebrowsing::ThreatHit_ThreatSourceType >(type_);
+}
+inline void ThreatHit_ThreatSource::set_type(::mozilla::safebrowsing::ThreatHit_ThreatSourceType value) {
+  assert(::mozilla::safebrowsing::ThreatHit_ThreatSourceType_IsValid(value));
+  set_has_type();
+  type_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.type)
+}
+
+// optional string remote_ip = 3;
+inline bool ThreatHit_ThreatSource::has_remote_ip() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ThreatHit_ThreatSource::set_has_remote_ip() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ThreatHit_ThreatSource::clear_has_remote_ip() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ThreatHit_ThreatSource::clear_remote_ip() {
+  if (remote_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    remote_ip_->clear();
+  }
+  clear_has_remote_ip();
+}
+inline const ::std::string& ThreatHit_ThreatSource::remote_ip() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
+  return *remote_ip_;
+}
+inline void ThreatHit_ThreatSource::set_remote_ip(const ::std::string& value) {
+  set_has_remote_ip();
+  if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    remote_ip_ = new ::std::string;
+  }
+  remote_ip_->assign(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
+}
+inline void ThreatHit_ThreatSource::set_remote_ip(const char* value) {
+  set_has_remote_ip();
+  if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    remote_ip_ = new ::std::string;
+  }
+  remote_ip_->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
+}
+inline void ThreatHit_ThreatSource::set_remote_ip(const char* value, size_t size) {
+  set_has_remote_ip();
+  if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    remote_ip_ = new ::std::string;
+  }
+  remote_ip_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
+}
+inline ::std::string* ThreatHit_ThreatSource::mutable_remote_ip() {
+  set_has_remote_ip();
+  if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    remote_ip_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
+  return remote_ip_;
+}
+inline ::std::string* ThreatHit_ThreatSource::release_remote_ip() {
+  clear_has_remote_ip();
+  if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = remote_ip_;
+    remote_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ThreatHit_ThreatSource::set_allocated_remote_ip(::std::string* remote_ip) {
+  if (remote_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete remote_ip_;
+  }
+  if (remote_ip) {
+    set_has_remote_ip();
+    remote_ip_ = remote_ip;
+  } else {
+    clear_has_remote_ip();
+    remote_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.ThreatSource.remote_ip)
+}
+
+// optional string referrer = 4;
+inline bool ThreatHit_ThreatSource::has_referrer() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ThreatHit_ThreatSource::set_has_referrer() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ThreatHit_ThreatSource::clear_has_referrer() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ThreatHit_ThreatSource::clear_referrer() {
+  if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_->clear();
+  }
+  clear_has_referrer();
+}
+inline const ::std::string& ThreatHit_ThreatSource::referrer() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
+  return *referrer_;
+}
+inline void ThreatHit_ThreatSource::set_referrer(const ::std::string& value) {
+  set_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_ = new ::std::string;
+  }
+  referrer_->assign(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
+}
+inline void ThreatHit_ThreatSource::set_referrer(const char* value) {
+  set_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_ = new ::std::string;
+  }
+  referrer_->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
+}
+inline void ThreatHit_ThreatSource::set_referrer(const char* value, size_t size) {
+  set_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_ = new ::std::string;
+  }
+  referrer_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
+}
+inline ::std::string* ThreatHit_ThreatSource::mutable_referrer() {
+  set_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
+  return referrer_;
+}
+inline ::std::string* ThreatHit_ThreatSource::release_referrer() {
+  clear_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = referrer_;
+    referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ThreatHit_ThreatSource::set_allocated_referrer(::std::string* referrer) {
+  if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete referrer_;
+  }
+  if (referrer) {
+    set_has_referrer();
+    referrer_ = referrer;
+  } else {
+    clear_has_referrer();
+    referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.ThreatSource.referrer)
+}
+
+// -------------------------------------------------------------------
+
+// ThreatHit
+
+// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+inline bool ThreatHit::has_threat_type() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ThreatHit::set_has_threat_type() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ThreatHit::clear_has_threat_type() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ThreatHit::clear_threat_type() {
+  threat_type_ = 0;
+  clear_has_threat_type();
+}
+inline ::mozilla::safebrowsing::ThreatType ThreatHit::threat_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.threat_type)
+  return static_cast< ::mozilla::safebrowsing::ThreatType >(threat_type_);
+}
+inline void ThreatHit::set_threat_type(::mozilla::safebrowsing::ThreatType value) {
+  assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
+  set_has_threat_type();
+  threat_type_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.threat_type)
+}
+
+// optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+inline bool ThreatHit::has_platform_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ThreatHit::set_has_platform_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ThreatHit::clear_has_platform_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ThreatHit::clear_platform_type() {
+  platform_type_ = 0;
+  clear_has_platform_type();
+}
+inline ::mozilla::safebrowsing::PlatformType ThreatHit::platform_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.platform_type)
+  return static_cast< ::mozilla::safebrowsing::PlatformType >(platform_type_);
+}
+inline void ThreatHit::set_platform_type(::mozilla::safebrowsing::PlatformType value) {
+  assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
+  set_has_platform_type();
+  platform_type_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatHit.platform_type)
+}
+
+// optional .mozilla.safebrowsing.ThreatEntry entry = 3;
+inline bool ThreatHit::has_entry() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ThreatHit::set_has_entry() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ThreatHit::clear_has_entry() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ThreatHit::clear_entry() {
+  if (entry_ != NULL) entry_->::mozilla::safebrowsing::ThreatEntry::Clear();
+  clear_has_entry();
+}
+inline const ::mozilla::safebrowsing::ThreatEntry& ThreatHit::entry() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.entry)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return entry_ != NULL ? *entry_ : *default_instance().entry_;
+#else
+  return entry_ != NULL ? *entry_ : *default_instance_->entry_;
+#endif
+}
+inline ::mozilla::safebrowsing::ThreatEntry* ThreatHit::mutable_entry() {
+  set_has_entry();
+  if (entry_ == NULL) entry_ = new ::mozilla::safebrowsing::ThreatEntry;
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.entry)
+  return entry_;
+}
+inline ::mozilla::safebrowsing::ThreatEntry* ThreatHit::release_entry() {
+  clear_has_entry();
+  ::mozilla::safebrowsing::ThreatEntry* temp = entry_;
+  entry_ = NULL;
+  return temp;
+}
+inline void ThreatHit::set_allocated_entry(::mozilla::safebrowsing::ThreatEntry* entry) {
+  delete entry_;
+  entry_ = entry;
+  if (entry) {
+    set_has_entry();
+  } else {
+    clear_has_entry();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatHit.entry)
+}
+
+// repeated .mozilla.safebrowsing.ThreatHit.ThreatSource resources = 4;
+inline int ThreatHit::resources_size() const {
+  return resources_.size();
+}
+inline void ThreatHit::clear_resources() {
+  resources_.Clear();
+}
+inline const ::mozilla::safebrowsing::ThreatHit_ThreatSource& ThreatHit::resources(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatHit.resources)
+  return resources_.Get(index);
+}
+inline ::mozilla::safebrowsing::ThreatHit_ThreatSource* ThreatHit::mutable_resources(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatHit.resources)
+  return resources_.Mutable(index);
+}
+inline ::mozilla::safebrowsing::ThreatHit_ThreatSource* ThreatHit::add_resources() {
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatHit.resources)
+  return resources_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >&
+ThreatHit::resources() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatHit.resources)
+  return resources_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatHit_ThreatSource >*
+ThreatHit::mutable_resources() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatHit.resources)
+  return &resources_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientInfo
+
+// optional string client_id = 1;
+inline bool ClientInfo::has_client_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientInfo::set_has_client_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientInfo::clear_has_client_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientInfo::clear_client_id() {
+  if (client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_id_->clear();
+  }
+  clear_has_client_id();
+}
+inline const ::std::string& ClientInfo::client_id() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ClientInfo.client_id)
+  return *client_id_;
+}
+inline void ClientInfo::set_client_id(const ::std::string& value) {
+  set_has_client_id();
+  if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_id_ = new ::std::string;
+  }
+  client_id_->assign(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ClientInfo.client_id)
+}
+inline void ClientInfo::set_client_id(const char* value) {
+  set_has_client_id();
+  if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_id_ = new ::std::string;
+  }
+  client_id_->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ClientInfo.client_id)
+}
+inline void ClientInfo::set_client_id(const char* value, size_t size) {
+  set_has_client_id();
+  if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_id_ = new ::std::string;
+  }
+  client_id_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ClientInfo.client_id)
+}
+inline ::std::string* ClientInfo::mutable_client_id() {
+  set_has_client_id();
+  if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_id_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ClientInfo.client_id)
+  return client_id_;
+}
+inline ::std::string* ClientInfo::release_client_id() {
+  clear_has_client_id();
+  if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = client_id_;
+    client_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientInfo::set_allocated_client_id(::std::string* client_id) {
+  if (client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete client_id_;
+  }
+  if (client_id) {
+    set_has_client_id();
+    client_id_ = client_id;
+  } else {
+    clear_has_client_id();
+    client_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ClientInfo.client_id)
+}
+
+// optional string client_version = 2;
+inline bool ClientInfo::has_client_version() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientInfo::set_has_client_version() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientInfo::clear_has_client_version() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientInfo::clear_client_version() {
+  if (client_version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_version_->clear();
+  }
+  clear_has_client_version();
+}
+inline const ::std::string& ClientInfo::client_version() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ClientInfo.client_version)
+  return *client_version_;
+}
+inline void ClientInfo::set_client_version(const ::std::string& value) {
+  set_has_client_version();
+  if (client_version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_version_ = new ::std::string;
+  }
+  client_version_->assign(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ClientInfo.client_version)
+}
+inline void ClientInfo::set_client_version(const char* value) {
+  set_has_client_version();
+  if (client_version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_version_ = new ::std::string;
+  }
+  client_version_->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ClientInfo.client_version)
+}
+inline void ClientInfo::set_client_version(const char* value, size_t size) {
+  set_has_client_version();
+  if (client_version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_version_ = new ::std::string;
+  }
+  client_version_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ClientInfo.client_version)
+}
+inline ::std::string* ClientInfo::mutable_client_version() {
+  set_has_client_version();
+  if (client_version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_version_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ClientInfo.client_version)
+  return client_version_;
+}
+inline ::std::string* ClientInfo::release_client_version() {
+  clear_has_client_version();
+  if (client_version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = client_version_;
+    client_version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientInfo::set_allocated_client_version(::std::string* client_version) {
+  if (client_version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete client_version_;
+  }
+  if (client_version) {
+    set_has_client_version();
+    client_version_ = client_version;
+  } else {
+    clear_has_client_version();
+    client_version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ClientInfo.client_version)
+}
+
+// -------------------------------------------------------------------
+
+// Checksum
+
+// optional bytes sha256 = 1;
+inline bool Checksum::has_sha256() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Checksum::set_has_sha256() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Checksum::clear_has_sha256() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Checksum::clear_sha256() {
+  if (sha256_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sha256_->clear();
+  }
+  clear_has_sha256();
+}
+inline const ::std::string& Checksum::sha256() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.Checksum.sha256)
+  return *sha256_;
+}
+inline void Checksum::set_sha256(const ::std::string& value) {
+  set_has_sha256();
+  if (sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sha256_ = new ::std::string;
+  }
+  sha256_->assign(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.Checksum.sha256)
+}
+inline void Checksum::set_sha256(const char* value) {
+  set_has_sha256();
+  if (sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sha256_ = new ::std::string;
+  }
+  sha256_->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.Checksum.sha256)
+}
+inline void Checksum::set_sha256(const void* value, size_t size) {
+  set_has_sha256();
+  if (sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sha256_ = new ::std::string;
+  }
+  sha256_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.Checksum.sha256)
+}
+inline ::std::string* Checksum::mutable_sha256() {
+  set_has_sha256();
+  if (sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sha256_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.Checksum.sha256)
+  return sha256_;
+}
+inline ::std::string* Checksum::release_sha256() {
+  clear_has_sha256();
+  if (sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = sha256_;
+    sha256_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Checksum::set_allocated_sha256(::std::string* sha256) {
+  if (sha256_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete sha256_;
+  }
+  if (sha256) {
+    set_has_sha256();
+    sha256_ = sha256;
+  } else {
+    clear_has_sha256();
+    sha256_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.Checksum.sha256)
+}
+
+// -------------------------------------------------------------------
+
+// ThreatEntry
+
+// optional bytes hash = 1;
+inline bool ThreatEntry::has_hash() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ThreatEntry::set_has_hash() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ThreatEntry::clear_has_hash() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ThreatEntry::clear_hash() {
+  if (hash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    hash_->clear();
+  }
+  clear_has_hash();
+}
+inline const ::std::string& ThreatEntry::hash() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntry.hash)
+  return *hash_;
+}
+inline void ThreatEntry::set_hash(const ::std::string& value) {
+  set_has_hash();
+  if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    hash_ = new ::std::string;
+  }
+  hash_->assign(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntry.hash)
+}
+inline void ThreatEntry::set_hash(const char* value) {
+  set_has_hash();
+  if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    hash_ = new ::std::string;
+  }
+  hash_->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatEntry.hash)
+}
+inline void ThreatEntry::set_hash(const void* value, size_t size) {
+  set_has_hash();
+  if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    hash_ = new ::std::string;
+  }
+  hash_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatEntry.hash)
+}
+inline ::std::string* ThreatEntry::mutable_hash() {
+  set_has_hash();
+  if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    hash_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntry.hash)
+  return hash_;
+}
+inline ::std::string* ThreatEntry::release_hash() {
+  clear_has_hash();
+  if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = hash_;
+    hash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ThreatEntry::set_allocated_hash(::std::string* hash) {
+  if (hash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete hash_;
+  }
+  if (hash) {
+    set_has_hash();
+    hash_ = hash;
+  } else {
+    clear_has_hash();
+    hash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntry.hash)
+}
+
+// optional string url = 2;
+inline bool ThreatEntry::has_url() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ThreatEntry::set_has_url() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ThreatEntry::clear_has_url() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ThreatEntry::clear_url() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_->clear();
+  }
+  clear_has_url();
+}
+inline const ::std::string& ThreatEntry::url() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntry.url)
+  return *url_;
+}
+inline void ThreatEntry::set_url(const ::std::string& value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntry.url)
+}
+inline void ThreatEntry::set_url(const char* value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatEntry.url)
+}
+inline void ThreatEntry::set_url(const char* value, size_t size) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatEntry.url)
+}
+inline ::std::string* ThreatEntry::mutable_url() {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntry.url)
+  return url_;
+}
+inline ::std::string* ThreatEntry::release_url() {
+  clear_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = url_;
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ThreatEntry::set_allocated_url(::std::string* url) {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (url) {
+    set_has_url();
+    url_ = url;
+  } else {
+    clear_has_url();
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntry.url)
+}
+
+// -------------------------------------------------------------------
+
+// ThreatEntrySet
+
+// optional .mozilla.safebrowsing.CompressionType compression_type = 1;
+inline bool ThreatEntrySet::has_compression_type() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ThreatEntrySet::set_has_compression_type() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ThreatEntrySet::clear_has_compression_type() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ThreatEntrySet::clear_compression_type() {
+  compression_type_ = 0;
+  clear_has_compression_type();
+}
+inline ::mozilla::safebrowsing::CompressionType ThreatEntrySet::compression_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.compression_type)
+  return static_cast< ::mozilla::safebrowsing::CompressionType >(compression_type_);
+}
+inline void ThreatEntrySet::set_compression_type(::mozilla::safebrowsing::CompressionType value) {
+  assert(::mozilla::safebrowsing::CompressionType_IsValid(value));
+  set_has_compression_type();
+  compression_type_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntrySet.compression_type)
+}
+
+// optional .mozilla.safebrowsing.RawHashes raw_hashes = 2;
+inline bool ThreatEntrySet::has_raw_hashes() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ThreatEntrySet::set_has_raw_hashes() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ThreatEntrySet::clear_has_raw_hashes() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ThreatEntrySet::clear_raw_hashes() {
+  if (raw_hashes_ != NULL) raw_hashes_->::mozilla::safebrowsing::RawHashes::Clear();
+  clear_has_raw_hashes();
+}
+inline const ::mozilla::safebrowsing::RawHashes& ThreatEntrySet::raw_hashes() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.raw_hashes)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return raw_hashes_ != NULL ? *raw_hashes_ : *default_instance().raw_hashes_;
+#else
+  return raw_hashes_ != NULL ? *raw_hashes_ : *default_instance_->raw_hashes_;
+#endif
+}
+inline ::mozilla::safebrowsing::RawHashes* ThreatEntrySet::mutable_raw_hashes() {
+  set_has_raw_hashes();
+  if (raw_hashes_ == NULL) raw_hashes_ = new ::mozilla::safebrowsing::RawHashes;
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.raw_hashes)
+  return raw_hashes_;
+}
+inline ::mozilla::safebrowsing::RawHashes* ThreatEntrySet::release_raw_hashes() {
+  clear_has_raw_hashes();
+  ::mozilla::safebrowsing::RawHashes* temp = raw_hashes_;
+  raw_hashes_ = NULL;
+  return temp;
+}
+inline void ThreatEntrySet::set_allocated_raw_hashes(::mozilla::safebrowsing::RawHashes* raw_hashes) {
+  delete raw_hashes_;
+  raw_hashes_ = raw_hashes;
+  if (raw_hashes) {
+    set_has_raw_hashes();
+  } else {
+    clear_has_raw_hashes();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.raw_hashes)
+}
+
+// optional .mozilla.safebrowsing.RawIndices raw_indices = 3;
+inline bool ThreatEntrySet::has_raw_indices() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ThreatEntrySet::set_has_raw_indices() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ThreatEntrySet::clear_has_raw_indices() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ThreatEntrySet::clear_raw_indices() {
+  if (raw_indices_ != NULL) raw_indices_->::mozilla::safebrowsing::RawIndices::Clear();
+  clear_has_raw_indices();
+}
+inline const ::mozilla::safebrowsing::RawIndices& ThreatEntrySet::raw_indices() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.raw_indices)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return raw_indices_ != NULL ? *raw_indices_ : *default_instance().raw_indices_;
+#else
+  return raw_indices_ != NULL ? *raw_indices_ : *default_instance_->raw_indices_;
+#endif
+}
+inline ::mozilla::safebrowsing::RawIndices* ThreatEntrySet::mutable_raw_indices() {
+  set_has_raw_indices();
+  if (raw_indices_ == NULL) raw_indices_ = new ::mozilla::safebrowsing::RawIndices;
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.raw_indices)
+  return raw_indices_;
+}
+inline ::mozilla::safebrowsing::RawIndices* ThreatEntrySet::release_raw_indices() {
+  clear_has_raw_indices();
+  ::mozilla::safebrowsing::RawIndices* temp = raw_indices_;
+  raw_indices_ = NULL;
+  return temp;
+}
+inline void ThreatEntrySet::set_allocated_raw_indices(::mozilla::safebrowsing::RawIndices* raw_indices) {
+  delete raw_indices_;
+  raw_indices_ = raw_indices;
+  if (raw_indices) {
+    set_has_raw_indices();
+  } else {
+    clear_has_raw_indices();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.raw_indices)
+}
+
+// optional .mozilla.safebrowsing.RiceDeltaEncoding rice_hashes = 4;
+inline bool ThreatEntrySet::has_rice_hashes() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ThreatEntrySet::set_has_rice_hashes() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ThreatEntrySet::clear_has_rice_hashes() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ThreatEntrySet::clear_rice_hashes() {
+  if (rice_hashes_ != NULL) rice_hashes_->::mozilla::safebrowsing::RiceDeltaEncoding::Clear();
+  clear_has_rice_hashes();
+}
+inline const ::mozilla::safebrowsing::RiceDeltaEncoding& ThreatEntrySet::rice_hashes() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.rice_hashes)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return rice_hashes_ != NULL ? *rice_hashes_ : *default_instance().rice_hashes_;
+#else
+  return rice_hashes_ != NULL ? *rice_hashes_ : *default_instance_->rice_hashes_;
+#endif
+}
+inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::mutable_rice_hashes() {
+  set_has_rice_hashes();
+  if (rice_hashes_ == NULL) rice_hashes_ = new ::mozilla::safebrowsing::RiceDeltaEncoding;
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.rice_hashes)
+  return rice_hashes_;
+}
+inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::release_rice_hashes() {
+  clear_has_rice_hashes();
+  ::mozilla::safebrowsing::RiceDeltaEncoding* temp = rice_hashes_;
+  rice_hashes_ = NULL;
+  return temp;
+}
+inline void ThreatEntrySet::set_allocated_rice_hashes(::mozilla::safebrowsing::RiceDeltaEncoding* rice_hashes) {
+  delete rice_hashes_;
+  rice_hashes_ = rice_hashes;
+  if (rice_hashes) {
+    set_has_rice_hashes();
+  } else {
+    clear_has_rice_hashes();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.rice_hashes)
+}
+
+// optional .mozilla.safebrowsing.RiceDeltaEncoding rice_indices = 5;
+inline bool ThreatEntrySet::has_rice_indices() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ThreatEntrySet::set_has_rice_indices() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ThreatEntrySet::clear_has_rice_indices() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ThreatEntrySet::clear_rice_indices() {
+  if (rice_indices_ != NULL) rice_indices_->::mozilla::safebrowsing::RiceDeltaEncoding::Clear();
+  clear_has_rice_indices();
+}
+inline const ::mozilla::safebrowsing::RiceDeltaEncoding& ThreatEntrySet::rice_indices() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntrySet.rice_indices)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return rice_indices_ != NULL ? *rice_indices_ : *default_instance().rice_indices_;
+#else
+  return rice_indices_ != NULL ? *rice_indices_ : *default_instance_->rice_indices_;
+#endif
+}
+inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::mutable_rice_indices() {
+  set_has_rice_indices();
+  if (rice_indices_ == NULL) rice_indices_ = new ::mozilla::safebrowsing::RiceDeltaEncoding;
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntrySet.rice_indices)
+  return rice_indices_;
+}
+inline ::mozilla::safebrowsing::RiceDeltaEncoding* ThreatEntrySet::release_rice_indices() {
+  clear_has_rice_indices();
+  ::mozilla::safebrowsing::RiceDeltaEncoding* temp = rice_indices_;
+  rice_indices_ = NULL;
+  return temp;
+}
+inline void ThreatEntrySet::set_allocated_rice_indices(::mozilla::safebrowsing::RiceDeltaEncoding* rice_indices) {
+  delete rice_indices_;
+  rice_indices_ = rice_indices;
+  if (rice_indices) {
+    set_has_rice_indices();
+  } else {
+    clear_has_rice_indices();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntrySet.rice_indices)
+}
+
+// -------------------------------------------------------------------
+
+// RawIndices
+
+// repeated int32 indices = 1;
+inline int RawIndices::indices_size() const {
+  return indices_.size();
+}
+inline void RawIndices::clear_indices() {
+  indices_.Clear();
+}
+inline ::google::protobuf::int32 RawIndices::indices(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RawIndices.indices)
+  return indices_.Get(index);
+}
+inline void RawIndices::set_indices(int index, ::google::protobuf::int32 value) {
+  indices_.Set(index, value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RawIndices.indices)
+}
+inline void RawIndices::add_indices(::google::protobuf::int32 value) {
+  indices_.Add(value);
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.RawIndices.indices)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+RawIndices::indices() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.RawIndices.indices)
+  return indices_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+RawIndices::mutable_indices() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.RawIndices.indices)
+  return &indices_;
+}
+
+// -------------------------------------------------------------------
+
+// RawHashes
+
+// optional int32 prefix_size = 1;
+inline bool RawHashes::has_prefix_size() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RawHashes::set_has_prefix_size() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RawHashes::clear_has_prefix_size() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RawHashes::clear_prefix_size() {
+  prefix_size_ = 0;
+  clear_has_prefix_size();
+}
+inline ::google::protobuf::int32 RawHashes::prefix_size() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RawHashes.prefix_size)
+  return prefix_size_;
+}
+inline void RawHashes::set_prefix_size(::google::protobuf::int32 value) {
+  set_has_prefix_size();
+  prefix_size_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RawHashes.prefix_size)
+}
+
+// optional bytes raw_hashes = 2;
+inline bool RawHashes::has_raw_hashes() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void RawHashes::set_has_raw_hashes() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void RawHashes::clear_has_raw_hashes() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void RawHashes::clear_raw_hashes() {
+  if (raw_hashes_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raw_hashes_->clear();
+  }
+  clear_has_raw_hashes();
+}
+inline const ::std::string& RawHashes::raw_hashes() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RawHashes.raw_hashes)
+  return *raw_hashes_;
+}
+inline void RawHashes::set_raw_hashes(const ::std::string& value) {
+  set_has_raw_hashes();
+  if (raw_hashes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raw_hashes_ = new ::std::string;
+  }
+  raw_hashes_->assign(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RawHashes.raw_hashes)
+}
+inline void RawHashes::set_raw_hashes(const char* value) {
+  set_has_raw_hashes();
+  if (raw_hashes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raw_hashes_ = new ::std::string;
+  }
+  raw_hashes_->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.RawHashes.raw_hashes)
+}
+inline void RawHashes::set_raw_hashes(const void* value, size_t size) {
+  set_has_raw_hashes();
+  if (raw_hashes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raw_hashes_ = new ::std::string;
+  }
+  raw_hashes_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.RawHashes.raw_hashes)
+}
+inline ::std::string* RawHashes::mutable_raw_hashes() {
+  set_has_raw_hashes();
+  if (raw_hashes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raw_hashes_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.RawHashes.raw_hashes)
+  return raw_hashes_;
+}
+inline ::std::string* RawHashes::release_raw_hashes() {
+  clear_has_raw_hashes();
+  if (raw_hashes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = raw_hashes_;
+    raw_hashes_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void RawHashes::set_allocated_raw_hashes(::std::string* raw_hashes) {
+  if (raw_hashes_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete raw_hashes_;
+  }
+  if (raw_hashes) {
+    set_has_raw_hashes();
+    raw_hashes_ = raw_hashes;
+  } else {
+    clear_has_raw_hashes();
+    raw_hashes_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.RawHashes.raw_hashes)
+}
+
+// -------------------------------------------------------------------
+
+// RiceDeltaEncoding
+
+// optional int64 first_value = 1;
+inline bool RiceDeltaEncoding::has_first_value() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RiceDeltaEncoding::set_has_first_value() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RiceDeltaEncoding::clear_has_first_value() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RiceDeltaEncoding::clear_first_value() {
+  first_value_ = GOOGLE_LONGLONG(0);
+  clear_has_first_value();
+}
+inline ::google::protobuf::int64 RiceDeltaEncoding::first_value() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.first_value)
+  return first_value_;
+}
+inline void RiceDeltaEncoding::set_first_value(::google::protobuf::int64 value) {
+  set_has_first_value();
+  first_value_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.first_value)
+}
+
+// optional int32 rice_parameter = 2;
+inline bool RiceDeltaEncoding::has_rice_parameter() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void RiceDeltaEncoding::set_has_rice_parameter() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void RiceDeltaEncoding::clear_has_rice_parameter() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void RiceDeltaEncoding::clear_rice_parameter() {
+  rice_parameter_ = 0;
+  clear_has_rice_parameter();
+}
+inline ::google::protobuf::int32 RiceDeltaEncoding::rice_parameter() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.rice_parameter)
+  return rice_parameter_;
+}
+inline void RiceDeltaEncoding::set_rice_parameter(::google::protobuf::int32 value) {
+  set_has_rice_parameter();
+  rice_parameter_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.rice_parameter)
+}
+
+// optional int32 num_entries = 3;
+inline bool RiceDeltaEncoding::has_num_entries() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void RiceDeltaEncoding::set_has_num_entries() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void RiceDeltaEncoding::clear_has_num_entries() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void RiceDeltaEncoding::clear_num_entries() {
+  num_entries_ = 0;
+  clear_has_num_entries();
+}
+inline ::google::protobuf::int32 RiceDeltaEncoding::num_entries() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.num_entries)
+  return num_entries_;
+}
+inline void RiceDeltaEncoding::set_num_entries(::google::protobuf::int32 value) {
+  set_has_num_entries();
+  num_entries_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.num_entries)
+}
+
+// optional bytes encoded_data = 4;
+inline bool RiceDeltaEncoding::has_encoded_data() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void RiceDeltaEncoding::set_has_encoded_data() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void RiceDeltaEncoding::clear_has_encoded_data() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void RiceDeltaEncoding::clear_encoded_data() {
+  if (encoded_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    encoded_data_->clear();
+  }
+  clear_has_encoded_data();
+}
+inline const ::std::string& RiceDeltaEncoding::encoded_data() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data)
+  return *encoded_data_;
+}
+inline void RiceDeltaEncoding::set_encoded_data(const ::std::string& value) {
+  set_has_encoded_data();
+  if (encoded_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    encoded_data_ = new ::std::string;
+  }
+  encoded_data_->assign(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data)
+}
+inline void RiceDeltaEncoding::set_encoded_data(const char* value) {
+  set_has_encoded_data();
+  if (encoded_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    encoded_data_ = new ::std::string;
+  }
+  encoded_data_->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data)
+}
+inline void RiceDeltaEncoding::set_encoded_data(const void* value, size_t size) {
+  set_has_encoded_data();
+  if (encoded_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    encoded_data_ = new ::std::string;
+  }
+  encoded_data_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data)
+}
+inline ::std::string* RiceDeltaEncoding::mutable_encoded_data() {
+  set_has_encoded_data();
+  if (encoded_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    encoded_data_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data)
+  return encoded_data_;
+}
+inline ::std::string* RiceDeltaEncoding::release_encoded_data() {
+  clear_has_encoded_data();
+  if (encoded_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = encoded_data_;
+    encoded_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void RiceDeltaEncoding::set_allocated_encoded_data(::std::string* encoded_data) {
+  if (encoded_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete encoded_data_;
+  }
+  if (encoded_data) {
+    set_has_encoded_data();
+    encoded_data_ = encoded_data;
+  } else {
+    clear_has_encoded_data();
+    encoded_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.RiceDeltaEncoding.encoded_data)
+}
+
+// -------------------------------------------------------------------
+
+// ThreatEntryMetadata_MetadataEntry
+
+// optional bytes key = 1;
+inline bool ThreatEntryMetadata_MetadataEntry::has_key() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ThreatEntryMetadata_MetadataEntry::set_has_key() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ThreatEntryMetadata_MetadataEntry::clear_has_key() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ThreatEntryMetadata_MetadataEntry::clear_key() {
+  if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    key_->clear();
+  }
+  clear_has_key();
+}
+inline const ::std::string& ThreatEntryMetadata_MetadataEntry::key() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
+  return *key_;
+}
+inline void ThreatEntryMetadata_MetadataEntry::set_key(const ::std::string& value) {
+  set_has_key();
+  if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    key_ = new ::std::string;
+  }
+  key_->assign(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
+}
+inline void ThreatEntryMetadata_MetadataEntry::set_key(const char* value) {
+  set_has_key();
+  if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    key_ = new ::std::string;
+  }
+  key_->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
+}
+inline void ThreatEntryMetadata_MetadataEntry::set_key(const void* value, size_t size) {
+  set_has_key();
+  if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    key_ = new ::std::string;
+  }
+  key_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
+}
+inline ::std::string* ThreatEntryMetadata_MetadataEntry::mutable_key() {
+  set_has_key();
+  if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    key_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
+  return key_;
+}
+inline ::std::string* ThreatEntryMetadata_MetadataEntry::release_key() {
+  clear_has_key();
+  if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = key_;
+    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ThreatEntryMetadata_MetadataEntry::set_allocated_key(::std::string* key) {
+  if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete key_;
+  }
+  if (key) {
+    set_has_key();
+    key_ = key;
+  } else {
+    clear_has_key();
+    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.key)
+}
+
+// optional bytes value = 2;
+inline bool ThreatEntryMetadata_MetadataEntry::has_value() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ThreatEntryMetadata_MetadataEntry::set_has_value() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ThreatEntryMetadata_MetadataEntry::clear_has_value() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ThreatEntryMetadata_MetadataEntry::clear_value() {
+  if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    value_->clear();
+  }
+  clear_has_value();
+}
+inline const ::std::string& ThreatEntryMetadata_MetadataEntry::value() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
+  return *value_;
+}
+inline void ThreatEntryMetadata_MetadataEntry::set_value(const ::std::string& value) {
+  set_has_value();
+  if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    value_ = new ::std::string;
+  }
+  value_->assign(value);
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
+}
+inline void ThreatEntryMetadata_MetadataEntry::set_value(const char* value) {
+  set_has_value();
+  if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    value_ = new ::std::string;
+  }
+  value_->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
+}
+inline void ThreatEntryMetadata_MetadataEntry::set_value(const void* value, size_t size) {
+  set_has_value();
+  if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    value_ = new ::std::string;
+  }
+  value_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
+}
+inline ::std::string* ThreatEntryMetadata_MetadataEntry::mutable_value() {
+  set_has_value();
+  if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    value_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
+  return value_;
+}
+inline ::std::string* ThreatEntryMetadata_MetadataEntry::release_value() {
+  clear_has_value();
+  if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = value_;
+    value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ThreatEntryMetadata_MetadataEntry::set_allocated_value(::std::string* value) {
+  if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete value_;
+  }
+  if (value) {
+    set_has_value();
+    value_ = value;
+  } else {
+    clear_has_value();
+    value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry.value)
+}
+
+// -------------------------------------------------------------------
+
+// ThreatEntryMetadata
+
+// repeated .mozilla.safebrowsing.ThreatEntryMetadata.MetadataEntry entries = 1;
+inline int ThreatEntryMetadata::entries_size() const {
+  return entries_.size();
+}
+inline void ThreatEntryMetadata::clear_entries() {
+  entries_.Clear();
+}
+inline const ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry& ThreatEntryMetadata::entries(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatEntryMetadata.entries)
+  return entries_.Get(index);
+}
+inline ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* ThreatEntryMetadata::mutable_entries(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ThreatEntryMetadata.entries)
+  return entries_.Mutable(index);
+}
+inline ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry* ThreatEntryMetadata::add_entries() {
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ThreatEntryMetadata.entries)
+  return entries_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >&
+ThreatEntryMetadata::entries() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ThreatEntryMetadata.entries)
+  return entries_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatEntryMetadata_MetadataEntry >*
+ThreatEntryMetadata::mutable_entries() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ThreatEntryMetadata.entries)
+  return &entries_;
+}
+
+// -------------------------------------------------------------------
+
+// ThreatListDescriptor
+
+// optional .mozilla.safebrowsing.ThreatType threat_type = 1;
+inline bool ThreatListDescriptor::has_threat_type() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ThreatListDescriptor::set_has_threat_type() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ThreatListDescriptor::clear_has_threat_type() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ThreatListDescriptor::clear_threat_type() {
+  threat_type_ = 0;
+  clear_has_threat_type();
+}
+inline ::mozilla::safebrowsing::ThreatType ThreatListDescriptor::threat_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatListDescriptor.threat_type)
+  return static_cast< ::mozilla::safebrowsing::ThreatType >(threat_type_);
+}
+inline void ThreatListDescriptor::set_threat_type(::mozilla::safebrowsing::ThreatType value) {
+  assert(::mozilla::safebrowsing::ThreatType_IsValid(value));
+  set_has_threat_type();
+  threat_type_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatListDescriptor.threat_type)
+}
+
+// optional .mozilla.safebrowsing.PlatformType platform_type = 2;
+inline bool ThreatListDescriptor::has_platform_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ThreatListDescriptor::set_has_platform_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ThreatListDescriptor::clear_has_platform_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ThreatListDescriptor::clear_platform_type() {
+  platform_type_ = 0;
+  clear_has_platform_type();
+}
+inline ::mozilla::safebrowsing::PlatformType ThreatListDescriptor::platform_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatListDescriptor.platform_type)
+  return static_cast< ::mozilla::safebrowsing::PlatformType >(platform_type_);
+}
+inline void ThreatListDescriptor::set_platform_type(::mozilla::safebrowsing::PlatformType value) {
+  assert(::mozilla::safebrowsing::PlatformType_IsValid(value));
+  set_has_platform_type();
+  platform_type_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatListDescriptor.platform_type)
+}
+
+// optional .mozilla.safebrowsing.ThreatEntryType threat_entry_type = 3;
+inline bool ThreatListDescriptor::has_threat_entry_type() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ThreatListDescriptor::set_has_threat_entry_type() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ThreatListDescriptor::clear_has_threat_entry_type() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ThreatListDescriptor::clear_threat_entry_type() {
+  threat_entry_type_ = 0;
+  clear_has_threat_entry_type();
+}
+inline ::mozilla::safebrowsing::ThreatEntryType ThreatListDescriptor::threat_entry_type() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ThreatListDescriptor.threat_entry_type)
+  return static_cast< ::mozilla::safebrowsing::ThreatEntryType >(threat_entry_type_);
+}
+inline void ThreatListDescriptor::set_threat_entry_type(::mozilla::safebrowsing::ThreatEntryType value) {
+  assert(::mozilla::safebrowsing::ThreatEntryType_IsValid(value));
+  set_has_threat_entry_type();
+  threat_entry_type_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.ThreatListDescriptor.threat_entry_type)
+}
+
+// -------------------------------------------------------------------
+
+// ListThreatListsResponse
+
+// repeated .mozilla.safebrowsing.ThreatListDescriptor threat_lists = 1;
+inline int ListThreatListsResponse::threat_lists_size() const {
+  return threat_lists_.size();
+}
+inline void ListThreatListsResponse::clear_threat_lists() {
+  threat_lists_.Clear();
+}
+inline const ::mozilla::safebrowsing::ThreatListDescriptor& ListThreatListsResponse::threat_lists(int index) const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.ListThreatListsResponse.threat_lists)
+  return threat_lists_.Get(index);
+}
+inline ::mozilla::safebrowsing::ThreatListDescriptor* ListThreatListsResponse::mutable_threat_lists(int index) {
+  // @@protoc_insertion_point(field_mutable:mozilla.safebrowsing.ListThreatListsResponse.threat_lists)
+  return threat_lists_.Mutable(index);
+}
+inline ::mozilla::safebrowsing::ThreatListDescriptor* ListThreatListsResponse::add_threat_lists() {
+  // @@protoc_insertion_point(field_add:mozilla.safebrowsing.ListThreatListsResponse.threat_lists)
+  return threat_lists_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >&
+ListThreatListsResponse::threat_lists() const {
+  // @@protoc_insertion_point(field_list:mozilla.safebrowsing.ListThreatListsResponse.threat_lists)
+  return threat_lists_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::mozilla::safebrowsing::ThreatListDescriptor >*
+ListThreatListsResponse::mutable_threat_lists() {
+  // @@protoc_insertion_point(field_mutable_list:mozilla.safebrowsing.ListThreatListsResponse.threat_lists)
+  return &threat_lists_;
+}
+
+// -------------------------------------------------------------------
+
+// Duration
+
+// optional int64 seconds = 1;
+inline bool Duration::has_seconds() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Duration::set_has_seconds() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Duration::clear_has_seconds() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Duration::clear_seconds() {
+  seconds_ = GOOGLE_LONGLONG(0);
+  clear_has_seconds();
+}
+inline ::google::protobuf::int64 Duration::seconds() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.Duration.seconds)
+  return seconds_;
+}
+inline void Duration::set_seconds(::google::protobuf::int64 value) {
+  set_has_seconds();
+  seconds_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.Duration.seconds)
+}
+
+// optional int32 nanos = 2;
+inline bool Duration::has_nanos() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Duration::set_has_nanos() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Duration::clear_has_nanos() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Duration::clear_nanos() {
+  nanos_ = 0;
+  clear_has_nanos();
+}
+inline ::google::protobuf::int32 Duration::nanos() const {
+  // @@protoc_insertion_point(field_get:mozilla.safebrowsing.Duration.nanos)
+  return nanos_;
+}
+inline void Duration::set_nanos(::google::protobuf::int32 value) {
+  set_has_nanos();
+  nanos_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.safebrowsing.Duration.nanos)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace safebrowsing
+}  // namespace mozilla
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_safebrowsing_2eproto__INCLUDED